Define decimal separator in one more way to make sure it works properly (#967 )

Send warn if using debug command on player who is not loaded (#959 )
Send warn if both per world playerlist and layout are enabled
2026-11-12 20:22:01 -05:00 · 2023-07-07 15:25:11 +02:00 · 2023-07-06 20:55:16 +02:00 · 2023-07-06 15:12:28 +02:00 · 2023-07-06 12:37:24 +02:00 · 2023-07-06 12:33:47 +02:00
555 changed files with 95962 additions and 89269 deletions
@@ -0,0 +1,7 @@
+* text=auto
+
+*.sh text eol=lf
+gradlew text eol=lf
+*.bat text eol=crlf
+
+*.jar binary
@@ -1,28 +0,0 @@
---
-name: Bug report
-about: Report a bug
-title: ''
-labels: ''
-assignees: ''
-
---
-
-**Server version**
-
-
-**Plugin version** ("latest" is not a version)
-
-
-**Describe the bug**
-
-
-**How to reproduce**
-
-
-**Expected behavior**
-
-
-**Actual behavior**
-
-
-**Additional info** (errors, screenshots, ...)
@@ -0,0 +1,63 @@
+name: Bug Report
+description: Plugin does not work as described.
+labels: ["Type: Bug"]
+body:
+  - type: input
+    attributes:
+      label: Server version
+      description: Version and type of used server software where TAB is installed.
+      placeholder: Spigot 1.18.1
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: TAB version
+      description: Full version in numbers, "latest" is not a version.
+      placeholder: 3.0.2
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Describe the bug
+      description: How the plugin behaves
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Expected behavior
+      description: How the plugin is supposed to behave instead with your configuration.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to reproduce
+      description: What to do in order to reproduce this issue
+      placeholder: |
+        Step 1: ..
+        Step 2: ..
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Additional info
+      description: Anything else you want to provide that will help in resolving the issue faster, such as screenshots or videos.
+    validations:
+      required: false
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Let's make sure this report is valid
+      options:
+        - label: I am running latest version of the plugin
+          required: true
+        - label: I have read the wiki to make sure it's not an issue with configuration
+          required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false
+        - label: I have read the Compatibility wiki page and am not trying to run the plugin on an unsupported server version / platform
+          required: true
@@ -0,0 +1,57 @@
+name: Error
+description: Error message with a stack trace in console or error file.
+labels: ["Type: Error"]
+body:
+  - type: input
+    attributes:
+      label: Server version
+      description: Version and type of used server software where TAB is installed.
+      placeholder: Spigot 1.18.1
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: TAB version
+      description: Full version in numbers, "latest" is not a version.
+      placeholder: 3.0.2
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Stack trace
+      description: The error message and stack trace you received in console or errors.log file.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to reproduce (if known)
+      description: What to do in order to reproduce this issue
+      placeholder: |
+        Step 1: ..
+        Step 2: ..
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: Additional info
+      description: Any other info you want to provide.
+    validations:
+      required: false
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Let's make sure this report is valid
+      options:
+        - label: I am running latest version of the plugin
+          required: true
+        - label: I have included a paste of the error
+          required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false
+        - label: I have read the Compatibility wiki page and am not trying to run the plugin on an unsupported server version / platform
+          required: true
@@ -0,0 +1,56 @@
+name: Memory leak
+description: Memory leak caused by TAB.
+labels: ["Type: Memory leak"]
+body:
+  - type: input
+    attributes:
+      label: Server version
+      description: Version and type of used server software where TAB is installed.
+      placeholder: Spigot 1.18.1
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: TAB version
+      description: Full version in numbers, "latest" is not a version.
+      placeholder: 3.0.2
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Heap dump
+      description: Link to uploaded memory dump which I can look into.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Uncleared object(s)
+      description: Objects you believe should have been removed from the memory but are not
+      placeholder: |
+        There is only 1 player online, but heap dump has 100 instances of TabPlayer
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: Additional info
+      description: Any other info you want to provide.
+    validations:
+      required: false
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Let's make sure this report is valid
+      options:
+        - label: I am running latest version of the plugin
+          required: true
+        - label: I have included download link of my heap dump
+          required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false
+        - label: I have explained what I believe is wrong with the heap dump
+          required: true
@@ -0,0 +1,55 @@
+name: Performance issue
+description: Performance issue in TAB or in server caused by TAB
+labels: ["Type: Performance"]
+body:
+  - type: input
+    attributes:
+      label: Server version
+      description: Version and type of used server software where TAB is installed.
+      placeholder: Spigot 1.18.1
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: TAB version
+      description: Full version in numbers, "latest" is not a version.
+      placeholder: 3.0.2
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Evidence
+      description: Any evidence proving the performance issue, such as output of /tab cpu or timings.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to reproduce (if known)
+      description: What to do in order to reproduce this issue
+      placeholder: |
+        Step 1: ..
+        Step 2: ..
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: Additional info
+      description: Any other info you want to provide.
+    validations:
+      required: false
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Let's make sure this report is valid
+      options:
+        - label: I am running latest version of the plugin
+          required: true
+        - label: I have included sufficient evidence of the issue
+          required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false
@@ -0,0 +1,29 @@
+name: Wiki change
+description: Change to text on a wiki page or adding a new section.
+labels: ["Type: Wiki change"]
+body:
+  - type: input
+    attributes:
+      label: Page link
+      description: Link to the page that should receive the change.
+      placeholder: https://github.com/NEZNAMY/TAB/wiki/Installation
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Current text (if applicable)
+      description: Current version of the text (if modifying), ignore in case of new section.
+      placeholder: |
+        Installation on Bukkit/Spigot/Paper is as simple as it can be. Just put the plugin into plugins folder and restart the server. You can also run `/plugman load tab` to load the plugin while server is running.
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: New text
+      description: What the text should be changed to / how should new section look
+      placeholder: |
+        Put the plugin into plugins folder and restart the server. In case you don't want to restart your server, loading with plugins like PlugMan is supported.
+    validations:
+      required: true
@@ -0,0 +1,45 @@
+name: Build
+on:
+  push:
+    branches:
+      - master
+      - v4
+  pull_request:
+    types: [opened, synchronize, reopened]
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3.3.0 #https://github.com/actions/checkout/releases
+        with:
+          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3.9.0 #https://github.com/actions/setup-java/releases
+        with:
+          distribution: 'temurin'
+          java-version: 17
+      - name: Cache SonarCloud packages
+        uses: actions/cache@v3.2.3 #https://github.com/actions/cache/releases
+        with:
+          path: ~/.sonar/cache
+          key: ${{ runner.os }}-sonar
+          restore-keys: ${{ runner.os }}-sonar
+      - name: Cache Gradle
+        uses: actions/cache@v3.2.3 #https://github.com/actions/cache/releases
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: "${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}"
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Build and analyze
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
+        run: ./gradlew clean build
+      - name: Upload a Build Artifact
+        uses: actions/upload-artifact@v3.1.2 #https://github.com/actions/upload-artifact/releases
+        with:
+          name: Jar
+          path: jar/build/libs/TAB-**.jar
@@ -1,8 +1,7 @@
 # Compiled class file
 *.class
-/bin/
-/target/
-/src/test/
+bin/
+target/

 # Log file
 *.log
@@ -31,8 +30,13 @@ hs_err_pid*
 .project

 # intellij
-/.idea/
+.idea/

 # other
-.gitattributes
-*.iml
+*.iml
+run/
+
+# Gradle
+.gradle/
+build/
+!gradle/wrapper/gradle-wrapper.jar
@@ -0,0 +1,9 @@
+If this plugin has helped you in any way, and you would like to return something back 
+to make the plugin even better, there is a lot of ways to contribute:  
+* Open a **pull request** containing a new feature or a bug fix, which you believe many users will benefit from.
+* Make detailed high-quality **bug reports**. The difference between a bug getting fixed in 1 week vs 1 hour 
+is in quality of the report (typically providing correct steps to reproduce that actually work).
+* Test **experimental builds**, which can be found in [GitHub Actions](https://github.com/NEZNAMY/TAB/actions) for problems of any kind including bugs. 
+This way you will help make the actual releases more stable / help get stable releases sooner.
+* Help improve the wiki by opening a [Wiki change issue](https://github.com/NEZNAMY/TAB/issues/new?assignees=&labels=Wiki&template=wiki_change.yml), 
+where you can improve existing descriptions, add information you found missing, fix typos / grammar mistakes or add more examples.
@@ -1,4 +1,4 @@
-Apache License
+                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

@@ -172,30 +172,3 @@ Apache License
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
@@ -1,47 +1,23 @@
-## Introduction  
-Here it is. After countless requests to go opensource, I did it to make those people quiet. It worked.  
-It's already been a year and I still can't see any positives of it. This way I just made it easier for everyone to make a plugin as good, so people can stop using it and switch to something better.  
-If you have a great argument why was making this open-source worth not only for those looking for premium features for free, please take your time and explain it to: Lionel#5648 (more names coming soon).  
-  
-  
-## Compiling
-Plugin can be compiled using maven. Once you've purchased the premium version, you can enable premium features by setting [this line to return true](https://github.com/NEZNAMY/TAB/blob/master/src/main/java/me/neznamy/tab/shared/TAB.java#L79) and apply your code improvements. Enabling it without purchasing the plugin may result in the features not working correctly.  
-**No support is provided for self-compiled jars, only for official compilations.** If you compiled it yourself, it is highly likely you modified something, which might be the reason why is the plugin not working. If you didn't modify anything, you can just get the plugin from official download places.
-  
-  
-## Links
-Free version  
-    Spigot (releases): https://www.spigotmc.org/resources/57806/  
-    Pre-releases https://github.com/NEZNAMY/TAB/releases  
-Premium version  
-    Polymart (releases): https://polymart.org/resource/484  
-    MC-Market (releases): https://www.mc-market.org/resources/14009/  
-    Pre-releases on discord for verified buyers  
-Bukkit bridge https://www.spigotmc.org/resources/83966/  
-Wiki https://github.com/NEZNAMY/TAB/wiki  
-Discord invite link: https://discord.gg/EaSvdk6  
-  
-  
-## Downloads
-Official release: https://www.spigotmc.org/resources/57806/  
-Pre-releases: https://github.com/NEZNAMY/TAB/releases  
-  
-  
-## Maven Repository
-```
-<repositories>
-  <repository>
-    <id>jitpack.io</id>
-    <url>https://jitpack.io</url>
-  </repository>
-</repositories>
+# About
+TAB aims to be a superior all-in-one minecraft plugin for displaying information that outperforms all 
+similar plugins in terms of features, performance and compatibility.  
+More information can be found at [Why TAB?](https://github.com/NEZNAMY/TAB/wiki/Why-TAB%3F) wiki page.

-<dependencies>
-  <!-- TAB -->
-  <dependency>
-    <groupId>com.github.NEZNAMY</groupId>
-    <artifactId>TAB-API</artifactId>
-    <version>2.8.10</version>
-  </dependency>
-</dependencies>
- ```
+# Compiling
+Compilation requires JDK 17 and up.  
+To compile the plugin, run `./gradlew build` from the terminal.  
+Once the plugin compiles, grab the jar from `/jar/build/libs/` folder.  
+The universal jar contains all modules for all supported platforms.
+
+# Documentation
+You can find everything about the plugin on the [Wiki](https://github.com/NEZNAMY/TAB/wiki). This includes a detailed description
+of all features, as well as information regarding compatibility or limitations of each feature.  
+
+# Issues
+The [Issues](https://github.com/NEZNAMY/TAB/issues) section is an issue tracker for all the kind of problems covered in issue templates.
+Please refrain from attempting to use it to receive help with your server, such issues will be closed immediately.  
+When opening an issue, provide as much information as possible. The difference between a bug getting fixed in 1 week vs 1 hour
+is in quality of the report. Bug reports where steps to reproduce are "idk" have no value and will not help to get the bug fixed at all.  
+
+# Contributing
+See [CONTRIBUTING.md](https://github.com/NEZNAMY/TAB/blob/master/CONTRIBUTING.md)
@@ -0,0 +1,2 @@
+# Security Policy
+If you found a security issue, send me a private message anywhere.
@@ -0,0 +1,7 @@
+dependencies {
+    compileOnlyApi("org.jetbrains:annotations:24.0.1")
+}
+
+tasks.javadoc {
+    enabled = project.hasProperty("enable-javadoc")
+}
@@ -0,0 +1,135 @@
+package me.neznamy.tab.api;
+
+import java.util.UUID;
+
+import lombok.NonNull;
+import lombok.Setter;
+import me.neznamy.tab.api.bossbar.BossBarManager;
+import me.neznamy.tab.api.event.EventBus;
+import me.neznamy.tab.api.placeholder.PlaceholderManager;
+import me.neznamy.tab.api.scoreboard.ScoreboardManager;
+import me.neznamy.tab.api.tablist.SortingManager;
+import me.neznamy.tab.api.tablist.HeaderFooterManager;
+import me.neznamy.tab.api.tablist.TabListFormatManager;
+import me.neznamy.tab.api.nametag.NameTagManager;
+import me.neznamy.tab.api.tablist.layout.LayoutManager;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * The primary API class to get instances of other API classes
+ */
+public abstract class TabAPI {
+
+    /** Instance of the API */
+    @Setter private static TabAPI instance;
+
+    /**
+     * Returns API instance. If instance was not set by the plugin, throws
+     * {@code IllegalStateException}. This is usually caused by shading the API
+     * into own project, which is not allowed. Another option is calling the method
+     * before plugin was able to load.
+     *
+     * @return  API instance
+     * @throws  IllegalStateException
+     *          If instance is {@code null}
+     */
+    public static @NotNull TabAPI getInstance() {
+        if (instance == null) throw new IllegalStateException("The API instance is null. This can have 2 possible causes: \n" +
+                "#1 - API was called before TAB was loaded. This means your plugin was loaded before TAB was. To make sure your " +
+                "plugin loads after TAB, add it as a depend or soft depend of your plugin.\n" +
+                "#2 - You shaded TAB's classes into your plugin, instead of only using them. This is not allowed. To verify this " +
+                "is your case, unzip your plugin and check for TAB's classes. If they are there, you will need to fix your compiler " +
+                "to not include them, such as scope provided for maven compilation.");
+        return instance;
+    }
+
+    /**
+     * Returns player object from given UUID
+     *
+     * @param   id
+     *          Player UUID
+     * @return  player object from given UUID
+     */
+    public abstract @Nullable TabPlayer getPlayer(@NonNull UUID id);
+
+    /**
+     * Returns player object from given name
+     *
+     * @param   name
+     *          Player name
+     * @return  player object from given name
+     */
+    public abstract @Nullable TabPlayer getPlayer(@NonNull String name);
+
+    /**
+     * Returns collection of all online players. Will return empty list if plugin is disabled (due to a broken configuration file for example).
+     *
+     * @return  collection of online players
+     */
+    public abstract @NotNull TabPlayer[] getOnlinePlayers();
+
+    /**
+     * Return BossBar manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  BossBar manager
+     */
+    public abstract @Nullable BossBarManager getBossBarManager();
+
+    /**
+     * Returns scoreboard manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  scoreboard manager
+     */
+    public abstract @Nullable ScoreboardManager getScoreboardManager();
+
+    /**
+     * Returns team manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  team manager
+     */
+    public abstract @Nullable NameTagManager getNameTagManager();
+
+    /**
+     * Returns header/footer manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  Header/footer manager
+     */
+    public abstract @Nullable HeaderFooterManager getHeaderFooterManager();
+
+    /**
+     * Returns PlaceholderManager instance
+     *
+     * @return  PlaceholderManager instance
+     */
+    public abstract @NotNull PlaceholderManager getPlaceholderManager();
+
+    /**
+     * Returns TabList name format manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  TabList name format manager
+     */
+    public abstract @Nullable TabListFormatManager getTabListFormatManager();
+
+    /**
+     * Returns Layout manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  Layout manager
+     */
+    public abstract @Nullable LayoutManager getLayoutManager();
+
+    /**
+     * Returns Sorting manager instance if at least one feature capable of sorting players is enabled.
+     * If not, returns {@code null}.
+     *
+     * @return  Sorting manager
+     */
+    public abstract @Nullable SortingManager getSortingManager();
+
+    /**
+     * Gets the event bus for registering listeners for TAB events.
+     *
+     * @return  the event bus
+     */
+    public abstract @Nullable EventBus getEventBus();
+}
@@ -0,0 +1,69 @@
+package me.neznamy.tab.api;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+/**
+ * An interface representing a player
+ */
+public interface TabPlayer {
+
+    /**
+     * Returns player's name
+     *
+     * @return  Player's name
+     */
+    @NotNull String getName();
+
+    /**
+     * Returns player's UUID
+     *
+     * @return  Player's UUID
+     */
+    @NotNull UUID getUniqueId();
+
+    /**
+     * Returns platform-specific entity
+     *
+     * @return  an instance of bukkit/bungee player depending on platform
+     */
+    @NotNull Object getPlayer();
+
+    /**
+     * Returns true once the player is successfully loaded (onJoin method ran through all methods)
+     *
+     * @return  {@code true} if player is fully loaded, {@code false} otherwise
+     */
+    boolean isLoaded();
+
+    /**
+     * Returns player's primary permission group. If group has been changed using
+     * {@link #setTemporaryGroup(String)}, returns that value. Otherwise, returns group
+     * detected by standard group assign logic
+     *
+     * @return  player's primary permission group
+     */
+    @NotNull String getGroup();
+
+    /**
+     * Temporarily overrides player's group and applies all changes coming from new group.
+     * This includes all properties and sorting, if used.
+     * Set to {@code null} to reset back.
+     *
+     * @param   group
+     *          New group to use
+     * @see     #hasTemporaryGroup()
+     */
+    void setTemporaryGroup(@Nullable String group);
+
+    /**
+     * Returns {@code true} if a temporary group was applied to the player using {@link #setTemporaryGroup(String)}.
+     * If no group was set, returns {@code false}
+     *
+     * @return  {@code true} if group is set, {@code false} if not
+     * @see     #setTemporaryGroup(String)
+     */
+    boolean hasTemporaryGroup();
+}
@@ -0,0 +1,9 @@
+package me.neznamy.tab.api.bossbar;
+
+/**
+ * An enum representing all available BossBar colors.
+ * Calling ordinal() will return color's network ID.
+ */
+public enum BarColor {
+    PINK, BLUE, RED, GREEN, YELLOW, PURPLE, WHITE
+}
@@ -0,0 +1,22 @@
+package me.neznamy.tab.api.bossbar;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * An enum representing all available BossBar styles.
+ * Calling ordinal() will return style's network ID.
+ * Style names are equal to NMS names.
+ */
+@AllArgsConstructor
+public enum BarStyle {
+
+    PROGRESS("SOLID"),
+    NOTCHED_6("SEGMENTED_6"),
+    NOTCHED_10("SEGMENTED_10"),
+    NOTCHED_12("SEGMENTED_12"),
+    NOTCHED_20("SEGMENTED_20");
+
+    /** Style's name used in Bukkit API */
+    @Getter private final String bukkitName;
+}
@@ -0,0 +1,203 @@
+package me.neznamy.tab.api.bossbar;
+
+import java.util.List;
+import java.util.UUID;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An interface representing a BossBar line.
+ * <p>
+ * For clients 1.8 and lower it uses wither, which only allows 1 bar 
+ * to be displayed at a time. Entity packets are not available on BungeeCord,
+ * where nothing will be displayed for these players.
+ * <p>
+ * For 1.9+ it uses the new BossBar feature, allowing configurable styles
+ * and colors, as well as display several bars at once. Limit of maximum 
+ * displayed BossBars depends on client resolution and GUI scale, up to
+ * 9 concurrent BossBars displayed at once.
+ */
+public interface BossBar {
+
+    /**
+     * Returns name of this BossBar. If it was defined in config, returns
+     * the name specified in config. If it was made using the API, returns
+     * randomly generated ID given to this BossBar when creating.
+     *
+     * @return  name of BossBar
+     */
+    @NotNull String getName();
+
+    /**
+     * Returns randomly generated uuid of this BossBar used internally to match
+     * the BossBar in client with packets or with Bukkit API BossBar instances.
+     *
+     * @return  uuid of this BossBar
+     */
+    @NotNull UUID getUniqueId();
+
+    /**
+     * Changes BossBar title to specified string, supporting placeholders.
+     * <p>
+     * If title contains new placeholders not used before, they are registered using
+     * standard registration logic and refreshed periodically. No need to call
+     * this method to try to keep placeholder values up to date.
+     * <p>
+     * If specified title is equal to the current one, nothing happens.
+     *
+     * @param   title
+     *          New title to display in this BossBar
+     */
+    void setTitle(@NonNull String title);
+
+    /**
+     * Changes BossBar progress to specified string, supporting placeholders.
+     * The string must be a string version of a float value, or a placeholder that
+     * outputs a float value with range 0-100.
+     * <p>
+     * If progress contains new placeholders not used before, they are registered using
+     * standard registration logic and refreshed periodically. No need to call
+     * this method to try to keep placeholder values up to date.
+     * <p>
+     * If specified progress is equal to the current one, nothing happens.
+     *
+     * @param   progress
+     *          New progress to use in this BossBar
+     */
+    void setProgress(@NonNull String progress);
+
+    /**
+     * Changes BossBar progress to specified value ranging from 0 to 100.
+     * <p>
+     * If specified progress is equal to the current one, nothing happens.
+     *
+     * @param   progress
+     *          New progress to use in this BossBar
+     */
+    void setProgress(float progress);
+
+    /**
+     * Changes BossBar color to specified string, supporting placeholders.
+     * The string must be a string version of one of the supported values,
+     * or a placeholder that outputs one of them.
+     * <p>
+     * If color contains new placeholders not used before, they are registered using
+     * standard registration logic and refreshed periodically. No need to call
+     * this method to try to keep placeholder values up to date.
+     * <p>
+     * If specified color is equal to the current one, nothing happens.
+     *
+     * @param   color
+     *          New color to use in this BossBar
+     */
+    void setColor(@NonNull String color);
+
+    /**
+     * Changes BossBar color to specified enum constant.
+     * <p>
+     * If specified color is equal to the current one, nothing happens.
+     *
+     * @param   color
+     *          New color to use in this BossBar
+     */
+    void setColor(@NonNull BarColor color);
+
+    /**
+     * Changes BossBar style to specified string, supporting placeholders.
+     * The string must be a string version of one of the supported values,
+     * or a placeholder that outputs one of them.
+     * <p>
+     * If style contains new placeholders not used before, they are registered using
+     * standard registration logic and refreshed periodically. No need to call
+     * this method to try to keep placeholder values up to date.
+     * <p>
+     * If specified style is equal to the current one, nothing happens.
+     *
+     * @param   style
+     *          New style to use in this BossBar
+     */
+    void setStyle(@NonNull String style);
+
+    /**
+     * Changes BossBar style to specified enum constant.
+     * <p>
+     * If specified style is equal to the current one, nothing happens.
+     *
+     * @param   style
+     *          New style to use in this BossBar
+     */
+    void setStyle(@NonNull BarStyle style);
+
+    /**
+     * Returns current title of the BossBar in raw format. If it contains placeholders,
+     * their raw identifiers are used in the result.
+     *
+     * @return  title of the BossBar
+     */
+    @NotNull String getTitle();
+
+    /**
+     * Returns progress of the BossBar as a string, which is either entered string
+     * containing placeholders or entered number converted to string
+     *
+     * @return  entered progress as a string
+     */
+    @NotNull String getProgress();
+
+    /**
+     * Returns color of the BossBar as a string, which is either entered string
+     * containing placeholders or entered enum value converted to string
+     *
+     * @return  entered color as a string
+     */
+    @NotNull String getColor();
+
+    /**
+     * Returns style of the BossBar as a string, which is either entered string
+     * containing placeholders or entered enum value converted to string
+     *
+     * @return  entered style as a string
+     */
+    @NotNull String getStyle();
+
+    /**
+     * Registers this BossBar to specified player.
+     * <p>
+     * If the player already sees this BossBar, nothing happens.
+     *
+     * @param   player
+     *          Player to register this BossBar to
+     */
+    void addPlayer(@NonNull TabPlayer player);
+
+    /**
+     * Unregisters this BossBar from specified player.
+     * <p>
+     * If the player does not see this BossBar, nothing happens.
+     *
+     * @param   player
+     *          Player to unregister this BossBar from
+     */
+    void removePlayer(@NonNull TabPlayer player);
+
+    /**
+     * Returns list of players who can see this BossBar.
+     * <p>
+     * The returned list can only be used to read. Writing
+     * will not work properly. For adding/removing players see {@link #addPlayer(TabPlayer)}
+     * and {@link #removePlayer(TabPlayer)}.
+     *
+     * @return  List of players seeing this BossBar
+     */
+    @NotNull List<TabPlayer> getPlayers();
+
+    /**
+     * Returns {@code true} if this boss bar is configured as announcement-only bar,
+     * {@code false} if not.
+     *
+     * @return  {@code true} if bar is announcement only, {@code false} if not
+     */
+    boolean isAnnouncementBar();
+}
@@ -0,0 +1,156 @@
+package me.neznamy.tab.api.bossbar;
+
+import java.util.List;
+import java.util.Map;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * An interface allowing work with BossBars such as creating, sending
+ * and toggling.
+ * <p>
+ * Instance can be obtained using {@link TabAPI#getBossBarManager()}.
+ * This requires the BossBar feature to be enabled in config, otherwise the method will
+ * return {@code null}.
+ */
+public interface BossBarManager {
+
+    /**
+     * Creates BossBar with specified parameters and registers it to BossBar manager,
+     * allowing to retrieve it later.
+     * 
+     * @param   title
+     *          Title to display, supports placeholders
+     * @param   progress
+     *          Progress to use. Must be between 0 and 100
+     * @param   color
+     *          Color to use
+     * @param   style
+     *          Style to use
+     * @return  The newly created BossBar
+     */
+    @NotNull BossBar createBossBar(@NonNull String title, float progress, @NonNull BarColor color, @NonNull BarStyle style);
+
+    /**
+     * Creates BossBar with specified parameters and registers it to BossBar manager,
+     * allowing to retrieve it later.
+     * 
+     * @param   title
+     *          Title to display, supports placeholders
+     * @param   progress
+     *          Progress to use. Must be a string version of a number, or
+     *          a placeholder that returns a number
+     * @param   color
+     *          Color to use. Must be a string version of one of enum constants, or
+     *          a placeholder that returns one of them
+     * @param   style
+     *          Style to use. Must be a string version of one of enum constants, or
+     *          a placeholder that returns one of them
+     * @return  The newly created BossBar
+     */
+    @NotNull BossBar createBossBar(@NonNull String title, @NonNull String progress, @NonNull String color, @NonNull String style);
+
+    /**
+     * Returns registered BossBar with given name. For BossBars from config it is the name
+     * they were created with, for API BossBars their randomly generated name, which can be
+     * retrieved using {@link me.neznamy.tab.api.bossbar.BossBar#getName()}.
+     * Returns {@code null} if no such BossBar exists.
+     * 
+     * @param   name
+     *          Name of registered BossBar
+     * @return  BossBar with specified name
+     */
+    @Nullable BossBar getBossBar(@NonNull String name);
+
+    /**
+     * Returns a map of all registered BossBars. This includes both BossBars from config
+     * and those registered via API.
+     * <p>
+     * Map key is BossBar's name available in {@link me.neznamy.tab.api.bossbar.BossBar#getName()},
+     * map value is the BossBar interface.
+     *
+     * @return  all registered BossBars
+     */
+    @NotNull Map<String, BossBar> getRegisteredBossBars();
+
+    /**
+     * Toggles BossBar for this player and sends toggle message if {@code sendToggleMessage} is true.
+     * 
+     * @param   player
+     *          Player to toggle BossBar for
+     * @param   sendToggleMessage
+     *          {@code true} if toggle message should be sent, {@code false} if not
+     * @see     #hasBossBarVisible(TabPlayer)
+     * @see     #setBossBarVisible(TabPlayer, boolean, boolean)
+     */
+    void toggleBossBar(@NonNull TabPlayer player, boolean sendToggleMessage);
+
+    /**
+     * Returns true if player can see BossBars, false if toggled via command or API.
+     * 
+     * @param   player
+     *          Player to check toggle status of
+     * @return  {@code true} if visible, {@code false} if disabled (toggled)
+     * @see     #toggleBossBar(TabPlayer, boolean)
+     * @see     #setBossBarVisible(TabPlayer, boolean, boolean)
+     */
+    boolean hasBossBarVisible(@NonNull TabPlayer player);
+
+    /**
+     * Sets BossBar visibility of player to set value. If value did not change, nothing happens.
+     * If visibility changed, toggle message is sent if {@code sendToggleMessage} is {@code true}.
+     * 
+     * @param   player
+     *          Player to set BossBar visibility of
+     * @param   visible
+     *          {@code true} if BossBar should be visible, {@code false} if not
+     * @param   sendToggleMessage
+     *          {@code true} if toggle message should be sent if value changed, {@code false} if not
+     * @see #toggleBossBar(TabPlayer, boolean)
+     * @see #hasBossBarVisible(TabPlayer)
+     */
+    void setBossBarVisible(@NonNull TabPlayer player, boolean visible, boolean sendToggleMessage);
+
+    /**
+     * Temporarily displays registered BossBar to player for specified amount of time in milliseconds.
+     *
+     * @param   player
+     *          Player to show BossBar to
+     * @param   bossBar
+     *          Name of registered BossBar to show
+     * @param   duration
+     *          In milliseconds for how long should BossBar be displayed
+     * @throws  IllegalArgumentException
+     *          if no BossBar with specified name exists
+     * @see     #announceBossBar(String, int)
+     * @see     #getAnnouncedBossBars()
+     */
+    void sendBossBarTemporarily(@NonNull TabPlayer player, @NonNull String bossBar, int duration);
+
+    /**
+     * Temporarily displays registered BossBar to all players for specified amount of time in milliseconds.
+     *
+     * @param   bossBar
+     *          Name of registered BossBar to show
+     * @param   duration
+     *          In milliseconds for how long should BossBar be displayed
+     * @throws  IllegalArgumentException
+     *          if no BossBar with specified name exists
+     * @see     #sendBossBarTemporarily(TabPlayer, String, int)
+     * @see     #getAnnouncedBossBars()
+     */
+    void announceBossBar(@NonNull String bossBar, int duration);
+
+    /**
+     * Returns list of BossBars which are currently being announced.
+     *
+     * @return  list of currently active BossBar announcements
+     * @see     #sendBossBarTemporarily(TabPlayer, String, int)
+     * @see     #announceBossBar(String, int)
+     */
+    @NotNull List<BossBar> getAnnouncedBossBars();
+}
@@ -0,0 +1,55 @@
+package me.neznamy.tab.api.event;
+
+import lombok.NonNull;
+
+/**
+ * The event bus. This is used to register event listeners/handlers for
+ * handling events that may be fired by TAB.
+ */
+public interface EventBus {
+
+    /**
+     * Scans the given listener for any method that is annotated with
+     * {@link Subscribe} and registers it as a listener to this event bus.
+     *
+     * <p>All methods in this class that are annotated with {@link Subscribe}
+     * must meet the following criteria:
+     * <ul>
+     *     <li>It must be <strong>public</strong>.</li>
+     *     <li>It must <strong>not</strong> be abstract.</li>
+     *     <li>It must have exactly <strong>one</strong> parameter.</li>
+     *     <li>Its single parameter must be <strong>an event</strong>.</li>
+     * </ul>
+     * If a method does not meet the above criteria, an exception <strong>will</strong>
+     * be thrown.
+     *
+     * @param listener the listener to register
+     * @throws RuntimeException if a method does not meet the criteria
+     */
+    void register(@NonNull Object listener);
+
+    /**
+     * Registers the given handler to this event bus.
+     *
+     * @param type the class type of the event
+     * @param handler the handler to register
+     * @param <E> the type of the event
+     */
+    <E extends TabEvent> void register(@NonNull Class<E> type, @NonNull EventHandler<E> handler);
+
+    /**
+     * Scans the given listener for any method that is annotated with
+     * {@link Subscribe} and unregisters it from this event bus.
+     *
+     * @param listener the listener to unregister
+     */
+    void unregister(@NonNull Object listener);
+
+    /**
+     * Unregisters the given handler from this event bus.
+     *
+     * @param handler the handler to unregister
+     * @param <E> the type of the event
+     */
+    <E extends TabEvent> void unregister(@NonNull EventHandler<E> handler);
+}
@@ -0,0 +1,18 @@
+package me.neznamy.tab.api.event;
+
+/**
+ * A handler for an event. This allows listening for events in a more
+ * functional style.
+ *
+ * @param <E> the type of event this handler handles
+ */
+@FunctionalInterface
+public interface EventHandler<E> {
+
+    /**
+     * Called when the given event is fired from an event bus.
+     *
+     * @param event the event to handle
+     */
+    void handle(E event);
+}
@@ -0,0 +1,14 @@
+package me.neznamy.tab.api.event;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Subscribes to a {@link TabEvent}.
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Subscribe {
+}
@@ -0,0 +1,10 @@
+package me.neznamy.tab.api.event;
+
+/**
+ * An event that may be fired by TAB when something occurs.
+ *
+ * <p>This is a marker interface. All events <strong>must</strong> implement this
+ * interface.
+ */
+public interface TabEvent {
+}
@@ -0,0 +1,26 @@
+package me.neznamy.tab.api.event.player;
+
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.api.event.TabEvent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Called when the player has been fully loaded by TAB.
+ */
+public interface PlayerLoadEvent extends TabEvent {
+
+    /**
+     * Gets the player that was loaded.
+     *
+     * @return  the player that was loaded
+     */
+    @NotNull TabPlayer getPlayer();
+
+    /**
+     * Returns {@code true} if player was loaded because they joined,
+     * {@code false} if the player was loaded because tab reload command was executed
+     *
+     * @return  {@code true} if player joined, {@code false} if plugin was reloaded
+     */
+    boolean isJoin();
+}
@@ -0,0 +1,48 @@
+package me.neznamy.tab.api.event.plugin;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.api.event.TabEvent;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * Called when an unknown placeholder is about to be registered.
+ * It defaults to a PlaceholderAPI implementation, but can be overridden.
+ */
+public interface PlaceholderRegisterEvent extends TabEvent {
+
+    /**
+     * Returns placeholder identifier starting and ending with {@code %}
+     *
+     * @return  placeholder identifier starting and ending with {@code %}
+     */
+    @NotNull String getIdentifier();
+
+    /**
+     * Sets placeholder to specified server placeholder implementation.
+     *
+     * @param   supplier
+     *          Placeholder replacer
+     */
+    void setServerPlaceholder(@NonNull Supplier<Object> supplier);
+
+    /**
+     * Sets placeholder to specified player placeholder implementation.
+     *
+     * @param   function
+     *          Placeholder replacer
+     */
+    void setPlayerPlaceholder(@NonNull Function<TabPlayer, Object> function);
+
+    /**
+     * Sets placeholder to specified relational placeholder implementation.
+     *
+     * @param   function
+     *          Placeholder replacer
+     */
+    void setRelationalPlaceholder(@NonNull BiFunction<TabPlayer, TabPlayer, Object> function);
+}
@@ -0,0 +1,9 @@
+package me.neznamy.tab.api.event.plugin;
+
+import me.neznamy.tab.api.event.TabEvent;
+
+/**
+ * Called when TAB is fully loaded.
+ */
+public interface TabLoadEvent extends TabEvent {
+}
@@ -0,0 +1,183 @@
+package me.neznamy.tab.api.nametag;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface for manipulating player name tags.
+ * <p>
+ * Instance can be obtained using {@link TabAPI#getNameTagManager()}.
+ * This requires the Team feature to be enabled in config, otherwise the method will
+ * return {@code null}.
+ */
+public interface NameTagManager {
+
+    /**
+     * Makes player's NameTag globally invisible
+     *
+     * @param   player
+     *          player to hide name tag of
+     * @see     #showNameTag(TabPlayer)
+     * @see     #hasHiddenNameTag(TabPlayer)
+     */
+    void hideNameTag(@NonNull TabPlayer player);
+
+    /**
+     * Hides player's NameTag for specified player until it's shown again
+     *
+     * @param   player
+     *          player to hide name tag of
+     * @param   viewer
+     *          player to hide name tag for
+     */
+    void hideNameTag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
+
+    /**
+     * Makes player's NameTag visible again
+     *
+     * @param   player
+     *          player to show name tag of
+     * @see     #hideNameTag(TabPlayer)
+     * @see     #hasHiddenNameTag(TabPlayer)
+     */
+    void showNameTag(@NonNull TabPlayer player);
+
+    /**
+     * Shows player's NameTag for specified viewer if it was hidden before
+     *
+     * @param   player
+     *          player to show name tag of
+     * @param   viewer
+     *          player to show NameTag back for
+     */
+    void showNameTag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
+
+    /**
+     * Return whether player has hidden NameTag or not
+     *
+     * @param   player
+     *          player to check name tag visibility status of
+     * @return  Whether player has hidden NameTag or not
+     * @see     #hideNameTag(TabPlayer)
+     * @see     #showNameTag(TabPlayer)
+     */
+    boolean hasHiddenNameTag(@NonNull TabPlayer player);
+
+    /**
+     * Returns true if NameTag is hidden for specified viewer, false if not
+     *
+     * @param   player
+     *          player to check visibility status of
+     * @param   viewer
+     *          player to check visibility status for
+     * @return  true if hidden, false if not
+     */
+    boolean hasHiddenNameTag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
+
+    /**
+     * Unregisters player's team and no longer handles it, as well as disables anti-override for teams.
+     * This can be resumed using resumeTeamHandling(). If team handling was paused already, nothing happens.
+     *
+     * @param   player
+     *          player to pause team handling of
+     */
+    void pauseTeamHandling(@NonNull TabPlayer player);
+
+    /**
+     * Resumes team handling if it was before paused using pauseTeamHandling(), if not, nothing happens
+     *
+     * @param   player
+     *          player to resume team handling of
+     */
+    void resumeTeamHandling(@NonNull TabPlayer player);
+
+    /**
+     * Returns true if team handling is paused for this player using pauseTeamHandling(), false if not, or
+     * it was resumed already using resumeTeamHandling
+     *
+     * @param   player
+     *          player to check handling status of
+     * @return  true if paused, false if not
+     */
+    boolean hasTeamHandlingPaused(@NonNull TabPlayer player);
+
+    /**
+     * Forces collision rule for the player. Setting it to null will remove forced value
+     *
+     * @param   player
+     *          player to set collision rule of
+     * @param   collision
+     *          forced collision rule
+     */
+    void setCollisionRule(@NonNull TabPlayer player, @Nullable Boolean collision);
+
+    /**
+     * Returns forced collision rule or null if collision is not forced using setCollisionRule
+     *
+     * @param   player
+     *          player to get forced collision of
+     * @return  forced value or null if not forced
+     */
+    @Nullable Boolean getCollisionRule(@NonNull TabPlayer player);
+
+    /**
+     * Changes player's prefix to provided value. Supports placeholders,
+     * as well as any supported RGB formats. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   prefix
+     *          new prefix value
+     * @see     #getCustomPrefix(TabPlayer)
+     * @see     #getOriginalPrefix(TabPlayer)
+     */
+    void setPrefix(@NonNull TabPlayer player, @Nullable String prefix);
+
+    /**
+     * Changes player's suffix to provided value. Supports placeholders,
+     * as well as any supported RGB formats. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   suffix
+     *          new suffix value
+     * @see     #getCustomSuffix(TabPlayer)
+     * @see     #getOriginalSuffix(TabPlayer)
+     */
+    void setSuffix(@NonNull TabPlayer player, @Nullable String suffix);
+
+    @Nullable String getCustomPrefix(@NonNull TabPlayer player);
+
+    @Nullable String getCustomSuffix(@NonNull TabPlayer player);
+
+    @NonNull String getOriginalPrefix(@NonNull TabPlayer player);
+
+    @NonNull String getOriginalSuffix(@NonNull TabPlayer player);
+
+    /**
+     * Toggles name tag visibility view on all players for specified player.
+     * On first call, name tags of all players will become invisible for specified
+     * player. On second call, they will become visible again.
+     *
+     * @param   player
+     *          player to toggle name tag visibility view for
+     * @param   sendToggleMessage
+     *          {@code true} if configured toggle message should be sent, {@code false} if not
+     */
+    void toggleNameTagVisibilityView(@NonNull TabPlayer player, boolean sendToggleMessage);
+
+    /**
+     * Returns {@code true} if player has hidden name tags by either calling
+     * {@link #toggleNameTagVisibilityView(TabPlayer, boolean)} or using a command,
+     * {@code false} if not.
+     *
+     * @param   player
+     *          player to check
+     * @return  {@code true} if hidden, {@code false} if not
+     */
+    boolean hasHiddenNameTagVisibilityView(@NonNull TabPlayer player);
+}
@@ -0,0 +1,128 @@
+package me.neznamy.tab.api.nametag;
+
+import java.util.List;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface for manipulating player name tags.
+ * <p>
+ * Instance can be obtained using {@link TabAPI#getNameTagManager()} and then casting it.
+ * This requires both Team and Unlimited name tag features to be enabled in config, otherwise the method will
+ * return {@code null} or not be an instance of this class.
+ */
+public interface UnlimitedNameTagManager extends NameTagManager {
+
+    /**
+     * Disables armor stands of specified player and displays vanilla name tags instead.
+     *
+     * @param   player
+     *          Player to disable armor stands of
+     * @see     #enableArmorStands(TabPlayer)
+     * @see     #hasDisabledArmorStands(TabPlayer)
+     */
+    void disableArmorStands(@NonNull TabPlayer player);
+
+    /**
+     * Enabled back armor stands of player, who was disabled previously using
+     * {@link #disableArmorStands(TabPlayer)}.
+     *
+     * @param   player
+     *          Player to enable back
+     * @see     #disableArmorStands(TabPlayer)
+     * @see     #hasDisabledArmorStands(TabPlayer)
+     */
+    void enableArmorStands(@NonNull TabPlayer player);
+
+    /**
+     * Returns {@code true} if player has armor stands disabled using
+     * {@link #disableArmorStands(TabPlayer)}, {@code false} otherwise.
+     *
+     * @param   player
+     *          Player to check
+     * @return  {@code true} if disabled, {@code false} if not.
+     * @see     #disableArmorStands(TabPlayer)
+     * @see     #enableArmorStands(TabPlayer)
+     */
+    boolean hasDisabledArmorStands(@NonNull TabPlayer player);
+
+    /**
+     * Changes name to specified value. Set to {@code null} to
+     * reset back to original value.
+     *
+     * @param   player
+     *          Player to change name of
+     * @param   customName
+     *          New name, or {@code null} to reset to original value
+     */
+    void setName(@NonNull TabPlayer player, @Nullable String customName);
+
+    /**
+     * Changes line to specified value. Set to {@code null} to reset back to original value.
+     *
+     * @param   player
+     *          Player to change line of
+     * @param   line
+     *          Name of defined line
+     * @param   value
+     *          Value to use, or {@code null} to reset back to original value
+     * @see     #getDefinedLines()
+     */
+    void setLine(@NonNull TabPlayer player, @NonNull String line, @Nullable String value);
+
+    /**
+     * Returns custom name value set using {@link #setName(TabPlayer, String)}.
+     *
+     * @param   player
+     *          Player to check
+     * @return  Custom name set previously or {@code null} if not set
+     * @see     #setName(TabPlayer, String)
+     */
+    @Nullable String getCustomName(@NonNull TabPlayer player);
+
+    /**
+     * Returns custom line value set using {@link #setLine(TabPlayer, String, String)}.
+     *
+     * @param   player
+     *          Player to check
+     * @param   line
+     *          Defined line
+     * @return  Custom name set previously or {@code null} if not set
+     * @see     #setName(TabPlayer, String)
+     * @see     #getDefinedLines()
+     */
+    @Nullable String getCustomLineValue(@NonNull TabPlayer player, @NonNull String line);
+
+    /**
+     * Returns original name value configured in files.
+     *
+     * @param   player
+     *          Player to check
+     * @return  Original configured name
+     * @see     #setName(TabPlayer, String)
+     */
+    @NotNull String getOriginalName(@NonNull TabPlayer player);
+
+    /**
+     * Returns original line value configured in files.
+     *
+     * @param   player
+     *          Player to check
+     * @param   line
+     *          Line name
+     * @return  Original configured line
+     * @see     #setLine(TabPlayer, String, String)
+     */
+    @NotNull String getOriginalLineValue(@NonNull TabPlayer player, @NonNull String line);
+
+    /**
+     * Returns list of all defined lines in config, both static and dynamic lines.
+     *
+     * @return  List of all defined lines in config
+     */
+    @NotNull List<String> getDefinedLines();
+}
@@ -0,0 +1,23 @@
+package me.neznamy.tab.api.placeholder;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An interface representing some kind of placeholder
+ */
+public interface Placeholder {
+
+    /**
+     * Returns refresh interval of this placeholder
+     *
+     * @return  refresh interval of this placeholder
+     */
+    int getRefresh();
+
+    /**
+     * Returns placeholder's identifier
+     *
+     * @return  placeholder's identifier
+     */
+    @NotNull String getIdentifier();
+}
@@ -0,0 +1,92 @@
+package me.neznamy.tab.api.placeholder;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * An interface allowing placeholder registration. Instance can be
+ * obtained using {@link TabAPI#getPlaceholderManager()}
+ */
+public interface PlaceholderManager {
+
+    /**
+     * Registers a server placeholder (placeholder with same output for all players)
+     *
+     * @param   identifier
+     *          Placeholder identifier
+     * @param   refresh
+     *          Refresh interval
+     * @param   supplier
+     *          Supplier for placeholder output
+     * @return  Registered placeholder for further use
+     * @throws  IllegalArgumentException
+     *          If {@code identifier} does not start and end with {@code %} or
+     *          {@code refresh} is not divisible by 50
+     */
+    @NotNull ServerPlaceholder registerServerPlaceholder(@NonNull String identifier, int refresh, @NonNull Supplier<Object> supplier);
+
+    /**
+     * Registers a player placeholder (placeholder different output per player)
+     *
+     * @param   identifier
+     *          Placeholder identifier
+     * @param   refresh
+     *          Refresh interval
+     * @param   function
+     *          Function for placeholder output
+     * @return  Registered placeholder for further use
+     * @throws  IllegalArgumentException
+     *          If {@code identifier} does not start and end with {@code %} or
+     *          {@code refresh} is not divisible by 50
+     */
+    @NotNull PlayerPlaceholder registerPlayerPlaceholder(@NonNull String identifier, int refresh, @NonNull Function<TabPlayer, Object> function);
+
+    /**
+     * Registers a relational placeholder (placeholder with output different for each player duo)
+     *
+     * @param   identifier
+     *          Placeholder identifier
+     * @param   refresh
+     *          Refresh interval
+     * @param   function
+     *          Function for placeholder output
+     * @return  Registered placeholder for further use
+     * @throws  IllegalArgumentException
+     *          If {@code identifier} does not start and end with {@code %},
+     *          does not start with {@code %rel_} or
+     *          {@code refresh} is not divisible by 50
+     */
+    @NotNull RelationalPlaceholder registerRelationalPlaceholder(@NonNull String identifier, int refresh, @NonNull BiFunction<TabPlayer, TabPlayer, Object> function);
+
+    /**
+     * Returns placeholder from specified identifier. If it does not exist, it is registered
+     * as a PlaceholderAPI placeholder and returned.
+     *
+     * @param   identifier
+     *          Placeholder identifier
+     * @return  Placeholder with specified identifier
+     */
+    @NotNull Placeholder getPlaceholder(@NonNull String identifier);
+
+    /**
+     * Unregisters placeholder and makes plugin no longer refresh it.
+     *
+     * @param   placeholder
+     *          Placeholder to unregister
+     */
+    void unregisterPlaceholder(@NonNull Placeholder placeholder);
+
+    /**
+     * Unregisters placeholder and makes plugin no longer refresh it.
+     *
+     * @param   identifier
+     *          identifier of placeholder to unregister
+     */
+    void unregisterPlaceholder(@NonNull String identifier);
+}
@@ -0,0 +1,30 @@
+package me.neznamy.tab.api.placeholder;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for player placeholders (placeholders returning different value for each player)
+ */
+public interface PlayerPlaceholder extends Placeholder {
+
+    /**
+     * Force-updates placeholder value. It will still be overridden by periodic refresh later,
+     * so this is (only) useful for force an update when value is supposed to change, and you have
+     * a high refresh interval set.
+     *
+     * @param   player
+     *          Player to update value for
+     * @param   value
+     *          New value
+     */
+    void updateValue(@NonNull TabPlayer player, @NonNull Object value);
+
+    /**
+     * Force-updates placeholder value using previously provided update function.
+     *
+     * @param   player
+     *          Player to update value for
+     */
+    void update(@NonNull TabPlayer player);
+}
@@ -0,0 +1,34 @@
+package me.neznamy.tab.api.placeholder;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * An interface for relational placeholders (returning different value for each player duo)
+ */
+public interface RelationalPlaceholder extends Placeholder {
+
+    /**
+     * Force-updates placeholder value. It will still be overridden by periodic refresh later,
+     * so this is (only) useful for force an update when value is supposed to change, and you have
+     * a high refresh interval set.
+     *
+     * @param   viewer
+     *          Placeholder viewer
+     * @param   target
+     *          Placeholder target
+     * @param   value
+     *          New value
+     */
+    void updateValue(@NonNull TabPlayer viewer, @NonNull TabPlayer target, @NonNull Object value);
+
+    /**
+     * Force-updates placeholder value using previously provided update function.
+     *
+     * @param   viewer
+     *          Placeholder viewer
+     * @param   target
+     *          Placeholder target
+     */
+    void update(@NonNull TabPlayer viewer, @NonNull TabPlayer target);
+}
@@ -0,0 +1,24 @@
+package me.neznamy.tab.api.placeholder;
+
+import lombok.NonNull;
+
+/**
+ * An interface for server placeholders (returning same value for all players)
+ */
+public interface ServerPlaceholder extends Placeholder {
+
+    /**
+     * Force-updates placeholder value. It will still be overridden by periodic refresh later,
+     * so this is (only) useful for force an update when value is supposed to change, and you have
+     * a high refresh interval set.
+     *
+     * @param   value
+     *          New value
+     */
+    void updateValue(@NonNull Object value);
+
+    /**
+     * Force-updates placeholder value using previously provided update function.
+     */
+    void update();
+}
@@ -0,0 +1,32 @@
+package me.neznamy.tab.api.scoreboard;
+
+import lombok.NonNull;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An interface allowing to work with a line of
+ * text in scoreboard.
+ *
+ */
+public interface Line {
+
+    /**
+     * Returns configured raw text of this line. Placeholders
+     * remain in raw format.
+     * 
+     * @return  raw text of this line
+     */
+    @NotNull String getText();
+    
+    /**
+     * Changes text to new value. Supports placeholders, which are
+     * automatically registered if needed and refreshed periodically
+     * based on configuration. No need to call this method to try to
+     * keep placeholders up to date. If value is identical to previous 
+     * one, nothing happens.
+     * 
+     * @param   text
+     *          Raw text to display in the line
+     */
+    void setText(@NonNull String text);
+}
@@ -0,0 +1,90 @@
+package me.neznamy.tab.api.scoreboard;
+
+import lombok.NonNull;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * An interface allowing to work with scoreboard, such as adding players,
+ * removing players and changing lines. New instance can be created using
+ * {@link ScoreboardManager#createScoreboard(String, String, List)},
+ * for scoreboards from config {@link ScoreboardManager#getRegisteredScoreboards()}.
+ */
+public interface Scoreboard {
+
+    /**
+     * Returns internal name of this scoreboard. Name is defined in registration,
+     * scoreboards from config use name they were defined with. This value is
+     * used internally and in /tab announce scoreboard command.
+     * 
+     * @return  custom name of this scoreboard
+     */
+    @NotNull String getName();
+
+    /**
+     * Returns raw title of this scoreboard. Placeholders stay in their
+     * raw format.
+     * 
+     * @return  scoreboard title
+     * @see     #setTitle(String)
+     */
+    @NotNull String getTitle();
+
+    /**
+     * Sets title to specified value. Placeholders are refreshed automatically
+     * with refresh intervals defined in config. No need to call this method
+     * to try to keep placeholders up to date. Supports RGB codes using any of 
+     * the supported formats.
+     * <p>
+     * Length is limited to 32 characters on &lt;1.13. If the limit is exceeded,
+     * text will be cut to 32 characters.
+     * <p>
+     * Calling this method with same title as before will not do anything.
+     * 
+     * @param   title
+     *          New title to use with placeholder support
+     * @see     #getTitle()
+     */
+    void setTitle(@NonNull String title);
+
+    /**
+     * Returns list of lines in this scoreboard in the order they appear
+     * in game (first line is on top). This list should only be used for reading,
+     * for adding/removing lines see {@link #addLine(String)} and {@link #removeLine(int)}.
+     * 
+     * @return  list of lines in this scoreboard
+     * @see     #addLine(String)
+     * @see     #removeLine(int)
+     */
+    @NotNull List<Line> getLines();
+
+    /**
+     * Adds line with specified text on the bottom of scoreboard. Supports
+     * placeholders, which will automatically be refreshed.
+     * 
+     * @param   text
+     *          Text to display
+     * @see     #getLines()
+     * @see     #removeLine(int)
+     */
+    void addLine(@NonNull String text);
+
+    /**
+     * Removes line with specified index. Index starts at {@code 0} and ends at 
+     * {@link #getLines()}.size()-1.
+     * 
+     * @param   index
+     *          Index of line to remove, starting at 0
+     * @throws  IndexOutOfBoundsException
+     *          if the index is out of range (index &lt; 0 || index &gt;= {@link #getLines()}.size())
+     * @see     #getLines()
+     * @see     #addLine(String)
+     */
+    void removeLine(int index);
+
+    /**
+     * Unregisters this scoreboard from all players who can see it.
+     */
+    void unregister();
+}
@@ -0,0 +1,168 @@
+package me.neznamy.tab.api.scoreboard;
+
+import java.util.List;
+import java.util.Map;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Interface allowing work with scoreboards, such as creating,
+ * sending, toggling and modifying.
+ * <p>
+ * Instance can be obtained using {@link me.neznamy.tab.api.TabAPI#getScoreboardManager()}.
+ * This requires the scoreboard feature to be enabled in config,
+ * the method will return {@code null} otherwise.
+ */
+public interface ScoreboardManager {
+
+    /**
+     * Creates new scoreboard, registers and returns it. {@code name}
+     * is internal name of the scoreboard, which it will be registered
+     * with and further work where scoreboard name is used allowed.
+     * <p>
+     * Scoreboard {@code title} is limited to 32 characters on &lt;1.13. If needed,
+     * it will be cut to 32 character for those players (after replacing 
+     * placeholders). RGB is supported using any of the supported formats.
+     * Placeholders are supported.
+     * <p>
+     * {@code lines} will display in the same order as contained in the list.
+     * Client can only see up to 15 lines at a time, however you can define
+     * more, if some of them only consist of placeholder that might be empty.
+     * 
+     * @param   name
+     *          Internal name of the scoreboard
+     * @param   title
+     *          The scoreboard title
+     * @param   lines
+     *          Lines of text in scoreboard (supports placeholders)
+     * @return  The new scoreboard with given parameters
+     * @throws  NullPointerException
+     *          if {@code name} or {@code lines} is {@code null}
+     */
+    @NotNull Scoreboard createScoreboard(@NonNull String name, @NonNull String title, @NonNull List<String> lines);
+    
+    /**
+     * Returns map of registered scoreboards via config and API.
+     * Map key is name of scoreboard, which is defined either in config
+     * or using {@link #createScoreboard(String, String, List)}.
+     * Map value is reference to the actual scoreboard.
+     * 
+     * @return  map of registered scoreboards
+     */
+    @NotNull Map<String, Scoreboard> getRegisteredScoreboards();
+    
+    /**
+     * Displays scoreboard to defined player. This will disable all display
+     * condition checks until the scoreboard is unregistered using 
+     * {@link #resetScoreboard(TabPlayer)}. If the player already sees
+     * this scoreboard, nothing will happen.
+     * 
+     * @param   player
+     *          Player to send scoreboard to
+     * @param   scoreboard
+     *          Scoreboard to display
+     * @throws  NullPointerException
+     *          if {@code player} or {@code scoreboard} is {@code null}
+     * @see     #hasCustomScoreboard(TabPlayer)
+     * @see     #resetScoreboard(TabPlayer)
+     */
+    void showScoreboard(@NonNull TabPlayer player, @NonNull Scoreboard scoreboard);
+    
+    /**
+     * Returns {@code true} if player has custom scoreboard set using
+     * {@link #showScoreboard(TabPlayer, Scoreboard)}, {@code false} if not.
+     * 
+     * @param   player
+     *          Player to check
+     * @return  {@code true} if player has custom scoreboard set using API,
+     *          {@code false} if not
+     * @see      #showScoreboard(TabPlayer, Scoreboard)
+     * @see     #resetScoreboard(TabPlayer)
+     */
+    boolean hasCustomScoreboard(@NonNull TabPlayer player);
+    
+    /**
+     * Hides custom scoreboard sent using {@link #showScoreboard(TabPlayer, Scoreboard)}
+     * and re-enables internal display logic with conditions. If player does not
+     * have any forced scoreboard, nothing happens.
+     * 
+     * @param   player
+     *          Player to hide custom scoreboard from
+     * @see     #showScoreboard(TabPlayer, Scoreboard)
+     * @see     #hasCustomScoreboard(TabPlayer)
+     */
+    void resetScoreboard(@NonNull TabPlayer player);
+    
+    /**
+     * Returns {@code true} if player has scoreboard enabled, {@code false} 
+     * if disabled (toggled) using either toggle command, 
+     * {@link #toggleScoreboard(TabPlayer, boolean)} or
+     * {@link #setScoreboardVisible(TabPlayer, boolean, boolean)}.
+     * 
+     * @param   player
+     *          Player to get visibility status of
+     * @return  {@code true} if visible, {@code false} if disabled
+     * @see     #setScoreboardVisible(TabPlayer, boolean, boolean)
+     * @see     #toggleScoreboard(TabPlayer, boolean)
+     */
+    boolean hasScoreboardVisible(@NonNull TabPlayer player);
+    
+    /**
+     * Sets scoreboard visibility of player to defined value. If visibility status
+     * is same as player had before, nothing happens. If this call changes
+     * visibility, scoreboard is toggled. If {@code sendToggleMessage} is {@code true},
+     * toggle message defined in configuration is sent.
+     * 
+     * @param   player
+     *          Player to set visibility for
+     * @param   visible
+     *          New visibility status
+     * @param   sendToggleMessage
+     *          whether to send toggle message if status changed or not
+     * @see     #toggleScoreboard(TabPlayer, boolean)
+     * @see     #hasScoreboardVisible(TabPlayer)
+     */
+    void setScoreboardVisible(@NonNull TabPlayer player, boolean visible, boolean sendToggleMessage);
+    
+    /**
+     * Toggles scoreboard for specified player. If player had scoreboard visible,
+     * hides it. If hidden, shows it. If {@code sendToggleMessage} is {@code true},
+     * toggle message defined in configuration is sent.
+     * 
+     * @param   player
+     *          Player to toggle scoreboard for
+     * @param   sendToggleMessage
+     *          Whether to send toggle message or not
+     * @see     #hasScoreboardVisible(TabPlayer)
+     * @see     #setScoreboardVisible(TabPlayer, boolean, boolean)
+     */
+    void toggleScoreboard(@NonNull TabPlayer player, boolean sendToggleMessage);
+    
+    /**
+     * Temporarily displays scoreboard to all players for specified amount of 
+     * time (in milliseconds). Scoreboard name is either defined in config, or 
+     * through API in {@link #createScoreboard(String, String, List)}.
+     * 
+     * @param   scoreboard
+     *          Scoreboard from config or registered via API
+     * @param   duration
+     *          Duration in milliseconds
+     * @throws  IllegalArgumentException
+     *          if no scoreboard was found with such name or {@code duration}
+     *          is &lt; 0.
+     */
+    void announceScoreboard(@NonNull String scoreboard, int duration);
+
+    /**
+     * Returns player's currently displayed scoreboard. This can be either with
+     * configuration, overridden with commands or the API. Will return {@code null}
+     * if player does not see any scoreboard due to not meeting any display condition.
+     *
+     * @param   player
+     *          player to get active scoreboard of
+     * @return  player's active scoreboard or {@code null} if player has no scoreboard
+     */
+    @NotNull Scoreboard getActiveScoreboard(@NonNull TabPlayer player);
+}
@@ -0,0 +1,57 @@
+package me.neznamy.tab.api.tablist;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface allowing to send header/footer to players.
+ * <p>
+ * Instance can be obtained using {@link TabAPI#getHeaderFooterManager()}.
+ * This requires the Header/footer feature to be enabled in config, otherwise
+ * the method will return {@code null}.
+ */
+public interface HeaderFooterManager {
+
+    /**
+     * Sets raw value of header to specified value. This overrides plugin
+     * configuration until reset is called. Has full placeholder support
+     * and will send update packet whenever a placeholder used inside
+     * changes its value. Use {@code null} to reset value back to original.
+     *
+     * @param   player
+     *          Player to set header for
+     * @param   header
+     *          Raw header value
+     */
+    void setHeader(@NonNull TabPlayer player, @Nullable String header);
+
+    /**
+     * Sets raw value of footer to specified value. This overrides plugin
+     * configuration until reset is called. Has full placeholder support
+     * and will send update packet whenever a placeholder used inside
+     * changes its value. Use {@code null} to reset value back to original.
+     *
+     * @param   player
+     *          Player to set header for
+     * @param   footer
+     *          Raw footer value
+     */
+    void setFooter(@NonNull TabPlayer player, @Nullable String footer);
+
+    /**
+     * Sets raw value of header and footer to specified values. This overrides plugin
+     * configuration until reset is called. Has full placeholder support
+     * and will send update packet whenever a placeholder used inside
+     * changes its value. Use {@code null} to reset value back to original.
+     *
+     * @param   player
+     *          Player to set header for
+     * @param   header
+     *          Raw header value
+     * @param   footer
+     *          Raw footer value
+     */
+    void setHeaderAndFooter(@NonNull TabPlayer player, @Nullable String header, @Nullable String footer);
+}
@@ -0,0 +1,38 @@
+package me.neznamy.tab.api.tablist;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface SortingManager {
+
+    /**
+     * Forces new team name for the player until this method is called again with null argument and
+     * performs all actions to change player's team name
+     *
+     * @param   player
+     *          player to set team name of
+     * @param   teamName
+     *          forced team name
+     */
+    void forceTeamName(@NonNull TabPlayer player, @Nullable String teamName);
+
+    /**
+     * Returns forced team name of player or null if not forced
+     *
+     * @param   player
+     *          player to check forced team name of
+     * @return  forced team name of player or null if not forced
+     */
+    @Nullable String getForcedTeamName(@NonNull TabPlayer player);
+
+    /**
+     * Returns original team name of the player set by the plugin.
+     *
+     * @param   player
+     *          Player to get team name of
+     * @return  Player's team name based on configuration.
+     */
+    @NotNull String getOriginalTeamName(@NonNull TabPlayer player);
+}
@@ -0,0 +1,132 @@
+package me.neznamy.tab.api.tablist;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * An interface allowing to modify TabList display names
+ * of players.
+ * <p>
+ * Instance can be obtained using {@link TabAPI#getTabListFormatManager()}.
+ * This requires the feature to be enabled in config, otherwise the method will
+ * return {@code null}.
+ */
+public interface TabListFormatManager {
+
+    /**
+     * Changes player's prefix to provided value. Supports placeholders,
+     * as well as any supported RGB formats. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   prefix
+     *          new prefix value
+     * @see     #getCustomPrefix(TabPlayer)
+     * @see     #getOriginalPrefix(TabPlayer)
+     */
+    void setPrefix(@NonNull TabPlayer player, @Nullable String prefix);
+
+    /**
+     * Changes player's name to provided value. Supports placeholders,
+     * as well as any supported RGB formats. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   customName
+     *          new customName value
+     * @see     #getCustomName(TabPlayer)
+     * @see     #getOriginalName(TabPlayer)
+     */
+    void setName(@NonNull TabPlayer player, @Nullable String customName);
+
+    /**
+     * Changes player's suffix to provided value. Supports placeholders,
+     * as well as any supported RGB formats. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   suffix
+     *          new suffix value
+     * @see     #getCustomSuffix(TabPlayer)
+     * @see     #getOriginalSuffix(TabPlayer)
+     */
+    void setSuffix(@NonNull TabPlayer player, @Nullable String suffix);
+
+    /**
+     * Returns prefix assigned using {@link #setPrefix(TabPlayer, String)} method.
+     * If the method was not used, {@code null} is returned.
+     *
+     * @param   player
+     *          player to get custom prefix of
+     * @return  player's custom prefix or {@code null} if not defined
+     * @see     #setPrefix(TabPlayer, String)
+     * @see     #getOriginalPrefix(TabPlayer)
+     */
+    @Nullable String getCustomPrefix(@NonNull TabPlayer player);
+
+    /**
+     * Returns custom name assigned using {@link #setName(TabPlayer, String)} method.
+     * If the method was not used, {@code null} is returned.
+     *
+     * @param   player
+     *          player to get custom name of
+     * @return  player's custom name or {@code null} if not defined
+     * @see     #setName(TabPlayer, String)
+     * @see     #getOriginalName(TabPlayer)
+     */
+    @Nullable String getCustomName(@NonNull TabPlayer player);
+
+    /**
+     * Returns suffix assigned using {@link #setSuffix(TabPlayer, String)} method.
+     * If the method was not used, {@code null} is returned.
+     *
+     * @param   player
+     *          player to get custom suffix of
+     * @return  player's custom suffix or {@code null} if not defined
+     * @see     #setSuffix(TabPlayer, String)
+     * @see     #getOriginalSuffix(TabPlayer)
+     */
+    @Nullable String getCustomSuffix(@NonNull TabPlayer player);
+
+    /**
+     * Returns player's original prefix applied using plugin's internal logic.
+     * This value is not affected by API calls in any way.
+     *
+     * @param   player
+     *          player to get original prefix of
+     * @return  player's original prefix
+     * @see     #setPrefix(TabPlayer, String)
+     * @see     #getCustomPrefix(TabPlayer)
+     */
+    @NotNull String getOriginalPrefix(@NonNull TabPlayer player);
+
+    /**
+     * Returns player's original name applied using plugin's internal logic.
+     * This value is not affected by API calls in any way.
+     *
+     * @param   player
+     *          player to get original name of
+     * @return  player's original name
+     * @see     #setName(TabPlayer, String)
+     * @see     #getCustomName(TabPlayer)
+     */
+    @NotNull String getOriginalName(@NonNull TabPlayer player);
+
+    /**
+     * Returns player's original suffix applied using plugin's internal logic.
+     * This value is not affected by API calls in any way.
+     *
+     * @param   player
+     *          player to get original suffix of
+     * @return  player's original suffix
+     * @see     #setSuffix(TabPlayer, String)
+     * @see     #getCustomSuffix(TabPlayer)
+     */
+    @NotNull String getOriginalSuffix(@NonNull TabPlayer player);
+}
@@ -0,0 +1,78 @@
+package me.neznamy.tab.api.tablist.layout;
+
+import lombok.NonNull;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface representing a layout.
+ */
+public interface Layout {
+
+    /**
+     * Returns name of the layout.
+     *
+     * @return  name of the layout
+     */
+    @NotNull String getName();
+
+    /**
+     * Adds fixed slot with specified parameters
+     *
+     * @param   slot
+     *          Slot (1-80)
+     * @param   text
+     *          Text to display
+     */
+    void addFixedSlot(int slot, @NonNull String text);
+
+    /**
+     * Adds fixed slot with specified parameters
+     *
+     * @param   slot
+     *          Slot (1-80)
+     * @param   text
+     *          Text to display
+     * @param   skin
+     *          Skin definition like in config
+     */
+    void addFixedSlot(int slot, @NonNull String text, @NonNull String skin);
+
+    /**
+     * Adds fixed slot with specified parameters
+     *
+     * @param   slot
+     *          Slot (1-80)
+     * @param   text
+     *          Text to display
+     * @param   ping
+     *          Slot's ping
+     */
+    void addFixedSlot(int slot, @NonNull String text, int ping);
+
+    /**
+     * Adds fixed slot with specified parameters
+     *
+     * @param   slot
+     *          Slot (1-80)
+     * @param   text
+     *          Text to display
+     * @param   skin
+     *          Skin definition like in config
+     * @param   ping
+     *          Slot's ping
+     */
+    void addFixedSlot(int slot, @NonNull String text, @NonNull String skin, int ping);
+
+    /**
+     * Adds a player group.
+     *
+     * @param   condition
+     *          Condition that must be met for player to appear in the group.
+     *          May be null for no requirement. Syntax is like in config -
+     *          either condition name or short format.
+     * @param   slots
+     *          Slots for this player group
+     */
+    void addGroup(@Nullable String condition, int[] slots);
+}
@@ -0,0 +1,44 @@
+package me.neznamy.tab.api.tablist.layout;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface for working with layouts. Instance can be obtained using
+ * {@link TabAPI#getLayoutManager()}. If the feature is disabled in
+ * config, it will return {@code null}.
+ */
+public interface LayoutManager {
+
+    /**
+     * Creates new layout
+     *
+     * @param   name
+     *          Unique layout name
+     * @return  Created layout
+     */
+    Layout createNewLayout(String name);
+
+    /**
+     * Sends layout to player. Set to {@code null} to make player not see
+     * any layout, but default TabList instead.
+     *
+     * @param   player
+     *          Player to send layout to
+     * @param   layout
+     *          Layout to send
+     * @see     #resetLayout(TabPlayer)
+     */
+    void sendLayout(@NonNull TabPlayer player, @Nullable Layout layout);
+
+    /**
+     * Reset layout back to original one based on configuration.
+     *
+     * @param   player
+     *          Player to reset layout for
+     * @see     #sendLayout(TabPlayer, Layout)
+     */
+    void resetLayout(@NonNull TabPlayer player);
+}
@@ -0,0 +1,9 @@
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    implementation("com.github.johnrengelman:shadow:8.1.1")
+    implementation("io.freefair.gradle:lombok-plugin:8.0.1")
+    implementation("fabric-loom:fabric-loom.gradle.plugin:1.1-SNAPSHOT")
+}
@@ -0,0 +1,9 @@
+rootProject.name = "build-logic"
+
+dependencyResolutionManagement {
+    repositories {
+        maven("https://maven.fabricmc.net/")
+        gradlePluginPortal()
+        mavenCentral()
+    }
+}
@@ -0,0 +1,36 @@
+import org.apache.tools.ant.filters.ReplaceTokens
+
+plugins {
+    `java-library`
+    id("io.freefair.lombok")
+}
+
+tasks {
+    processResources {
+        filter<ReplaceTokens>("tokens" to mapOf(
+            "id" to rootProject.ext.get("id")!!.toString(),
+            "name" to rootProject.name,
+            "version" to project.version,
+            "description" to project.description,
+            "website" to rootProject.ext.get("website")!!.toString(),
+            "author" to rootProject.ext.get("author")!!.toString()
+        ))
+    }
+    javadoc {
+        // This saves a decent bit of processing power on slow machines
+        enabled = false
+        options.encoding = Charsets.UTF_8.name()
+        (options as StandardJavadocDocletOptions).addStringOption("Xdoclint:none", "-quiet")
+    }
+    compileJava {
+        options.encoding = Charsets.UTF_8.name()
+        options.release.set(8)
+        options.compilerArgs.addAll(listOf("-nowarn", "-Xlint:-unchecked", "-Xlint:-deprecation"))
+    }
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(17))
+    }
+}
@@ -0,0 +1,15 @@
+plugins {
+    id("tab.standard-conventions")
+    id("com.github.johnrengelman.shadow")
+}
+
+tasks {
+    shadowJar {
+        archiveFileName.set("TAB-${project.name}-${project.version}.jar")
+        relocate("org.bstats", "me.neznamy.tab.libs.org.bstats")
+        relocate("org.json.simple", "me.neznamy.tab.libs.org.json.simple")
+        relocate("net.kyori.event", "me.neznamy.tab.libs.net.kyori.event")
+        relocate("me.neznamy.yamlassist", "me.neznamy.tab.libs.me.neznamy.yamlassist")
+        relocate("org.yaml.snakeyaml", "me.neznamy.tab.libs.org.yaml.snakeyaml")
+    }
+}
@@ -0,0 +1,25 @@
+plugins {
+    id("tab.base-conventions")
+    `maven-publish`
+}
+
+java {
+    withSourcesJar()
+    withJavadocJar()
+}
+
+publishing {
+    repositories {
+        maven {
+            name = "krypton"
+            url = uri("https://repo.kryptonmc.org/releases")
+            credentials(PasswordCredentials::class)
+        }
+    }
+    publications.create<MavenPublication>("mavenJava") {
+        groupId = rootProject.group as String
+        artifactId = "tab-${project.name}"
+        version = rootProject.version as String
+        from(components["java"])
+    }
+}
@@ -0,0 +1,36 @@
+plugins {
+    id("tab.parent")
+}
+
+allprojects {
+    group = "me.neznamy"
+    version = "4.0.3-SNAPSHOT"
+    description = "An all-in-one solution that works"
+
+    ext.set("id", "tab")
+    ext.set("website", "https://github.com/NEZNAMY/TAB")
+    ext.set("author", "NEZNAMY")
+}
+
+val platforms = setOf(
+    projects.bukkit,
+    projects.bungeecord,
+    projects.krypton,
+    projects.velocity,
+    projects.sponge7,
+    projects.sponge8,
+    projects.fabric
+).map { it.dependencyProject }
+
+val special = setOf(
+    projects.api,
+    projects.shared
+).map { it.dependencyProject }
+
+subprojects {
+    when (this) {
+        in platforms -> plugins.apply("tab.platform-conventions")
+        in special -> plugins.apply("tab.standard-conventions")
+        else -> plugins.apply("tab.base-conventions")
+    }
+}
@@ -0,0 +1,8 @@
+dependencies {
+    implementation(projects.shared)
+    implementation("org.bstats:bstats-bukkit:3.0.1")
+    compileOnly("org.purpurmc.purpur:purpur-api:1.16.5-R0.1-SNAPSHOT")
+    compileOnly("me.clip:placeholderapi:2.11.2")
+    compileOnly("com.mojang:authlib:1.5.25")
+    compileOnly("com.github.MilkBowl:VaultAPI:1.7")
+}
@@ -0,0 +1,43 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import me.neznamy.tab.shared.platform.EventListener;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+/**
+ * The core for bukkit forwarding events into all enabled features
+ */
+public class BukkitEventListener extends EventListener<Player> implements Listener {
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onQuit(PlayerQuitEvent e) {
+        quit(e.getPlayer().getUniqueId());
+    }
+
+    @EventHandler(priority = EventPriority.LOW)
+    public void onJoin(PlayerJoinEvent e) {
+        join(e.getPlayer());
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onWorldChange(PlayerChangedWorldEvent e) {
+        worldChange(e.getPlayer().getUniqueId(), e.getPlayer().getWorld().getName());
+    }
+
+    @EventHandler
+    public void onCommand(PlayerCommandPreprocessEvent e) {
+        if (command(e.getPlayer().getUniqueId(), e.getMessage())) e.setCancelled(true);
+    }
+
+    @Override
+    public TabPlayer createPlayer(Player player) {
+        return new BukkitTabPlayer(player);
+    }
+}
@@ -0,0 +1,153 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import com.mojang.authlib.GameProfile;
+import io.netty.channel.Channel;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.features.nametags.NameTag;
+import me.neznamy.tab.shared.platform.TabList;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.features.injection.NettyPipelineInjector;
+import me.neznamy.tab.shared.features.sorting.Sorting;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Pipeline injection for bukkit
+ */
+public class BukkitPipelineInjector extends NettyPipelineInjector {
+
+    /**
+     * Constructs new instance
+     */
+    public BukkitPipelineInjector() {
+        super("packet_handler");
+    }
+
+    @Override
+    protected Channel getChannel(@NotNull TabPlayer player) {
+        BukkitTabPlayer bukkit = (BukkitTabPlayer) player;
+        NMSStorage nms = NMSStorage.getInstance();
+        try {
+            if (nms.CHANNEL != null) return (Channel) nms.CHANNEL.get(nms.NETWORK_MANAGER.get(bukkit.getPlayerConnection()));
+        } catch (IllegalAccessException exception) {
+            TAB.getInstance().getErrorManager().printError("Failed to get channel of " + bukkit.getName(), exception);
+        }
+        return null;
+    }
+
+    @Override
+    @SneakyThrows
+    public void onDisplayObjective(@NotNull TabPlayer player, @NotNull Object packet) {
+        TAB.getInstance().getFeatureManager().onDisplayObjective(player,
+                PacketScoreboard.DisplayObjective_POSITION.getInt(packet),
+                (String) PacketScoreboard.DisplayObjective_OBJECTIVE_NAME.get(packet));
+    }
+
+    @Override
+    @SneakyThrows
+    public void onObjective(@NotNull TabPlayer player, @NotNull Object packet) {
+        TAB.getInstance().getFeatureManager().onObjective(player,
+                PacketScoreboard.Objective_METHOD.getInt(packet),
+                (String) PacketScoreboard.Objective_OBJECTIVE_NAME.get(packet));
+    }
+
+    @Override
+    public boolean isDisplayObjective(@NotNull Object packet) {
+        return PacketScoreboard.DisplayObjectiveClass.isInstance(packet);
+    }
+
+    @Override
+    public boolean isObjective(@NotNull Object packet) {
+        return PacketScoreboard.ObjectivePacketClass.isInstance(packet);
+    }
+
+    @Override
+    public boolean isTeam(@NotNull Object packet) {
+        return PacketScoreboard.TeamPacketClass.isInstance(packet);
+    }
+
+    @Override
+    public boolean isPlayerInfo(@NotNull Object packet) {
+        return BukkitTabList.PacketPlayOutPlayerInfoClass.isInstance(packet);
+    }
+
+    @Override
+    @SneakyThrows
+    public void onPlayerInfo(@NotNull TabPlayer receiver, @NotNull Object packet) {
+        NMSStorage nms = NMSStorage.getInstance();
+        List<String> actions;
+        if (BukkitTabList.ClientboundPlayerInfoRemovePacket != null) {
+            //1.19.3+
+            actions = ((EnumSet<?>)BukkitTabList.ACTION.get(packet)).stream().map(Enum::name).collect(Collectors.toList());
+        } else {
+            //1.19.2-
+            actions = Collections.singletonList(BukkitTabList.ACTION.get(packet).toString());
+        }
+        List<Object> updatedList = new ArrayList<>();
+        for (Object nmsData : (List<?>) BukkitTabList.PLAYERS.get(packet)) {
+            GameProfile profile = (GameProfile) BukkitTabList.PlayerInfoData_getProfile.invoke(nmsData);
+            Object displayName = null;
+            if (actions.contains(TabList.Action.UPDATE_DISPLAY_NAME.name()) || actions.contains(TabList.Action.ADD_PLAYER.name())) {
+                displayName = BukkitTabList.PlayerInfoData_DisplayName.get(nmsData);
+                IChatBaseComponent newDisplayName = TAB.getInstance().getFeatureManager().onDisplayNameChange(receiver, profile.getId());
+                if (newDisplayName != null) displayName = nms.toNMSComponent(newDisplayName, receiver.getVersion());
+                if (!nms.is1_19_3Plus()) BukkitTabList.PlayerInfoData_DisplayName.set(nmsData, displayName);
+            }
+            if (nms.is1_19_3Plus()) {
+                // 1.19.3 is using records, which do not allow changing final fields, need to rewrite the list entirely
+                updatedList.add(BukkitTabList.newPlayerInfoData.newInstance(
+                        profile.getId(),
+                        profile,
+                        BukkitTabList.PlayerInfoData_Listed.getBoolean(nmsData),
+                        BukkitTabList.PlayerInfoData_Latency.getInt(nmsData),
+                        BukkitTabList.PlayerInfoData_GameMode.get(nmsData),
+                        displayName,
+                        BukkitTabList.PlayerInfoData_RemoteChatSession.get(nmsData)));
+            }
+        }
+        if (nms.is1_19_3Plus()) {
+            BukkitTabList.PLAYERS.set(packet, updatedList);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    @SneakyThrows
+    public void modifyPlayers(@NotNull Object packetPlayOutScoreboardTeam) {
+        if (TAB.getInstance().getNameTagManager() == null) return;
+        int action = PacketScoreboard.TeamPacket_ACTION.getInt(packetPlayOutScoreboardTeam);
+        if (action == 1 || action == 2 || action == 4) return;
+        Collection<String> players = (Collection<String>) PacketScoreboard.TeamPacket_PLAYERS.get(packetPlayOutScoreboardTeam);
+        String teamName = (String) PacketScoreboard.TeamPacket_NAME.get(packetPlayOutScoreboardTeam);
+        if (players == null) return;
+        //creating a new list to prevent NoSuchFieldException in minecraft packet encoder when a player is removed
+        Collection<String> newList = new ArrayList<>();
+        for (String entry : players) {
+            TabPlayer p = TAB.getInstance().getPlayer(entry);
+            if (p == null) {
+                newList.add(entry);
+                continue;
+            }
+            Sorting sorting = TAB.getInstance().getFeatureManager().getFeature(TabConstants.Feature.SORTING);
+            String expectedTeam = sorting.getShortTeamName(p);
+            if (expectedTeam == null) {
+                newList.add(entry);
+                continue;
+            }
+            if (!((NameTag)TAB.getInstance().getNameTagManager()).getDisableChecker().isDisabledPlayer(p) &&
+                    !TAB.getInstance().getNameTagManager().hasTeamHandlingPaused(p) && !teamName.equals(expectedTeam)) {
+                logTeamOverride(teamName, p.getName(), expectedTeam);
+            } else {
+                newList.add(entry);
+            }
+        }
+        PacketScoreboard.TeamPacket_PLAYERS.set(packetPlayOutScoreboardTeam, newList);
+    }
+}
@@ -0,0 +1,82 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.api.placeholder.PlaceholderManager;
+import me.neznamy.tab.shared.placeholders.UniversalPlaceholderRegistry;
+import net.milkbowl.vault.chat.Chat;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/**
+ * Bukkit registry to register bukkit-only and universal placeholders
+ */
+public class BukkitPlaceholderRegistry extends UniversalPlaceholderRegistry {
+
+    private Chat chat;
+
+    /** NMS server to get TPS from on spigot */
+    private Object server;
+
+    /** TPS field*/
+    private Field recentTps;
+
+    /** Detection for presence of Paper's TPS getter */
+    private Method paperTps;
+
+    /** Detection for presence of Paper's MSPT getter */
+    private Method paperMspt;
+
+    /**
+     * Constructs new instance and loads hooks
+     */
+    public BukkitPlaceholderRegistry() {
+        try {
+            server = Bukkit.getServer().getClass().getMethod("getServer").invoke(Bukkit.getServer());
+            recentTps = server.getClass().getField("recentTps");
+        } catch (ReflectiveOperationException e) {
+            //not spigot
+        }
+        try { paperTps = Bukkit.class.getMethod("getTPS"); } catch (NoSuchMethodException ignored) {}
+        try { paperMspt = Bukkit.class.getMethod("getAverageTickTime"); } catch (NoSuchMethodException ignored) {}
+        if (Bukkit.getPluginManager().isPluginEnabled("Vault")) {
+            RegisteredServiceProvider<Chat> rspChat = Bukkit.getServicesManager().getRegistration(Chat.class);
+            if (rspChat != null) chat = rspChat.getProvider();
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public void registerPlaceholders(@NotNull PlaceholderManager manager) {
+        manager.registerPlayerPlaceholder(TabConstants.Placeholder.DISPLAY_NAME, 500, p -> ((Player) p.getPlayer()).getDisplayName());
+        if (paperTps != null) {
+            manager.registerServerPlaceholder(TabConstants.Placeholder.TPS, 1000, () -> formatTPS(Bukkit.getTPS()[0]));
+        } else if (recentTps != null) {
+            manager.registerServerPlaceholder(TabConstants.Placeholder.TPS, 1000, () -> {
+                try {
+                    return formatTPS(((double[]) recentTps.get(server))[0]);
+                } catch (IllegalAccessException e) {
+                    return -1;
+                }
+            });
+        } else {
+            manager.registerServerPlaceholder(TabConstants.Placeholder.TPS, -1, () -> -1);
+        }
+        if (paperMspt != null) {
+            manager.registerServerPlaceholder(TabConstants.Placeholder.MSPT, 1000, () -> format(Bukkit.getAverageTickTime()));
+        }
+        manager.registerPlayerPlaceholder(TabConstants.Placeholder.HEALTH, 100, p -> (int) Math.ceil(((Player) p.getPlayer()).getHealth()));
+        if (chat != null) {
+            manager.registerPlayerPlaceholder("%vault-prefix%", 1000, p -> chat.getPlayerPrefix((Player) p.getPlayer()));
+            manager.registerPlayerPlaceholder("%vault-suffix%", 1000, p -> chat.getPlayerSuffix((Player) p.getPlayer()));
+        } else {
+            manager.registerServerPlaceholder("%vault-prefix%", -1, () -> "");
+            manager.registerServerPlaceholder("%vault-suffix%", -1, () -> "");
+        }
+        super.registerPlaceholders(manager);
+    }
+}
@@ -0,0 +1,84 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import me.neznamy.tab.platforms.bukkit.platform.BukkitPlatform;
+import me.neznamy.tab.platforms.bukkit.platform.FoliaPlatform;
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.*;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
+import org.bukkit.Bukkit;
+import org.bukkit.command.*;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/**
+ * Main class for Bukkit platform
+ */
+public class BukkitTAB extends JavaPlugin {
+
+    @Override
+    public void onEnable() {
+        String version = Bukkit.getBukkitVersion().split("-")[0];
+        String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+        Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("[TAB] Server version: " + version + " (" + serverPackage + ")"));
+        if (!isVersionSupported()) {
+            Bukkit.getPluginManager().disablePlugin(this);
+            return;
+        }
+        BukkitPlatform platform = ReflectionUtils.classExists("io.papermc.paper.threadedregions.RegionizedServer") ?
+                new FoliaPlatform(this) : new BukkitPlatform(this);
+        TAB.setInstance(new TAB(platform, ProtocolVersion.fromFriendlyName(version), getDataFolder()));
+        if (TAB.getInstance().getServerVersion() == ProtocolVersion.UNKNOWN_SERVER_VERSION) {
+            Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] Unknown server version: " + Bukkit.getBukkitVersion() + "! Plugin may not work correctly."));
+        }
+        Bukkit.getPluginManager().registerEvents(new BukkitEventListener(), this);
+        TAB.getInstance().load();
+        Metrics metrics = new Metrics(this, 5304);
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.UNLIMITED_NAME_TAG_MODE_ENABLED, () -> TAB.getInstance().getFeatureManager().isFeatureEnabled(TabConstants.Feature.UNLIMITED_NAME_TAGS) ? "Yes" : "No"));
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.PLACEHOLDER_API, () -> platform.isPlaceholderAPI() ? "Yes" : "No"));
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.PERMISSION_SYSTEM, () -> TAB.getInstance().getGroupManager().getPermissionPlugin()));
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.SERVER_VERSION, () -> "1." + TAB.getInstance().getServerVersion().getMinorVersion() + ".x"));
+        PluginCommand cmd = Bukkit.getPluginCommand(TabConstants.COMMAND_BACKEND);
+        if (cmd == null) return;
+        BukkitTabCommand command = new BukkitTabCommand();
+        cmd.setExecutor(command);
+        cmd.setTabCompleter(command);
+    }
+
+    @Override
+    public void onDisable() {
+        //null check due to compatibility check making instance not get set on unsupported versions
+        if (TAB.getInstance() != null) TAB.getInstance().unload();
+    }
+    
+    /**
+     * Initializes all used NMS classes, constructors, fields and methods.
+     * Returns {@code true} if everything went successfully,
+     * {@code false} if anything went wrong.
+     *
+     * @return  {@code true} if server version is compatible, {@code false} if not
+     */
+    private boolean isVersionSupported() {
+        try {
+            long time = System.currentTimeMillis();
+            String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+            int minorVersion = Integer.parseInt(serverPackage.split("_")[1]);
+            NMSStorage.setInstance(minorVersion >= 17 ? new BukkitModernNMSStorage() : new BukkitLegacyNMSStorage());
+            Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("[TAB] Loaded NMS hook in " + (System.currentTimeMillis()-time) + "ms"));
+            return true;
+        } catch (Exception ex) {
+            if (ProtocolVersion.fromFriendlyName(Bukkit.getBukkitVersion().split("-")[0]) == ProtocolVersion.UNKNOWN_SERVER_VERSION) {
+                Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] Your server version is not compatible. " +
+                        "This plugin version was made for " + ProtocolVersion.values()[ProtocolVersion.values().length-1].getFriendlyName() +
+                        " - " + ProtocolVersion.values()[3].getFriendlyName() + ". Disabling."));
+            } else {
+                Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] A compatibility issue " +
+                        "with your server was found. Unless you are running some really weird server software, this is a bug."));
+            }
+            return false;
+        }
+    }
+}
@@ -0,0 +1,48 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Command handler for /tab command
+ */
+public class BukkitTabCommand implements CommandExecutor, TabCompleter {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
+        if (TAB.getInstance().isPluginDisabled()) {
+            for (String message : TAB.getInstance().getDisabledCommand().execute(args, sender.hasPermission(TabConstants.Permission.COMMAND_RELOAD), sender.hasPermission(TabConstants.Permission.COMMAND_ALL))) {
+                sender.sendMessage(EnumChatFormat.color(message));
+            }
+        } else {
+            TabPlayer p = null;
+            if (sender instanceof Player) {
+                p = TAB.getInstance().getPlayer(((Player)sender).getUniqueId());
+                if (p == null) return true; //player not loaded correctly
+            }
+            TAB.getInstance().getCommand().execute(p, args);
+        }
+        return false;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, String[] args) {
+        TabPlayer p = null;
+        if (sender instanceof Player) {
+            p = TAB.getInstance().getPlayer(((Player)sender).getUniqueId());
+            if (p == null) return new ArrayList<>(); //player not loaded correctly
+        }
+        return TAB.getInstance().getCommand().complete(p, args);
+    }
+}
@@ -0,0 +1,201 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.TabList;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.*;
+
+/**
+ * TabList which support modifying many entries at once
+ * for significantly better performance. For 1.7 players,
+ * ViaVersion properly splits the packet into multiple, so
+ * we don't need to worry about that here.
+ * <p>
+ * This class does not support server versions of 1.7 and
+ * below, because of the massive differences in tab list
+ * and packet fields.
+ */
+@RequiredArgsConstructor
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class BukkitTabList implements TabList {
+
+    // NMS Fields
+    public static Class<?> PacketPlayOutPlayerListHeaderFooterClass;
+    public static Constructor<?> newPacketPlayOutPlayerListHeaderFooter;
+    public static Field HEADER;
+    public static Field FOOTER;
+
+    public static Class<?> PacketPlayOutPlayerInfoClass;
+    public static Constructor<?> newPacketPlayOutPlayerInfo;
+    public static Field ACTION;
+    public static Field PLAYERS;
+    public static Class<Enum> EnumPlayerInfoActionClass;
+    public static Class<Enum> EnumGamemodeClass;
+    public static Class<?> ClientboundPlayerInfoRemovePacket;
+    public static Class<?> RemoteChatSession$Data;
+    public static Constructor<?> newClientboundPlayerInfoRemovePacket;
+
+    public static Class<?> PlayerInfoDataClass;
+    public static Constructor<?> newPlayerInfoData;
+    public static Method PlayerInfoData_getProfile;
+    public static Field PlayerInfoData_Latency;
+    public static Field PlayerInfoData_GameMode;
+    public static Field PlayerInfoData_DisplayName;
+    public static Field PlayerInfoData_Listed;
+    public static Field PlayerInfoData_RemoteChatSession;
+
+    /** Player this TabList belongs to */
+    private final BukkitTabPlayer player;
+
+    public static void load(NMSStorage nms) throws NoSuchMethodException {
+        if (nms.getMinorVersion() >= 17) {
+            newPacketPlayOutPlayerListHeaderFooter = PacketPlayOutPlayerListHeaderFooterClass.getConstructor(nms.IChatBaseComponent, nms.IChatBaseComponent);
+        } else {
+            newPacketPlayOutPlayerListHeaderFooter = PacketPlayOutPlayerListHeaderFooterClass.getConstructor();
+            HEADER = ReflectionUtils.getFields(PacketPlayOutPlayerListHeaderFooterClass, nms.IChatBaseComponent).get(0);
+            FOOTER = ReflectionUtils.getFields(PacketPlayOutPlayerListHeaderFooterClass, nms.IChatBaseComponent).get(1);
+        }
+        if (nms.is1_19_3Plus()) {
+            newClientboundPlayerInfoRemovePacket = ClientboundPlayerInfoRemovePacket.getConstructor(List.class);
+            newPacketPlayOutPlayerInfo = PacketPlayOutPlayerInfoClass.getConstructor(EnumSet.class, Collection.class);
+            ACTION = ReflectionUtils.getOnlyField(PacketPlayOutPlayerInfoClass, EnumSet.class);
+        } else {
+            newPacketPlayOutPlayerInfo = PacketPlayOutPlayerInfoClass.getConstructor(EnumPlayerInfoActionClass, Array.newInstance(nms.EntityPlayer, 0).getClass());
+            ACTION = ReflectionUtils.getOnlyField(PacketPlayOutPlayerInfoClass, EnumPlayerInfoActionClass);
+        }
+        PLAYERS = ReflectionUtils.getOnlyField(PacketPlayOutPlayerInfoClass, List.class);
+        newPlayerInfoData = ReflectionUtils.getOnlyConstructor(PlayerInfoDataClass);
+        PlayerInfoData_getProfile = ReflectionUtils.getOnlyMethod(PlayerInfoDataClass, GameProfile.class);
+        PlayerInfoData_Latency = ReflectionUtils.getOnlyField(PlayerInfoDataClass, int.class);
+        PlayerInfoData_GameMode = ReflectionUtils.getOnlyField(PlayerInfoDataClass, EnumGamemodeClass);
+        PlayerInfoData_DisplayName = ReflectionUtils.getOnlyField(PlayerInfoDataClass, nms.IChatBaseComponent);
+        if (nms.is1_19_3Plus()) {
+            PlayerInfoData_Listed = ReflectionUtils.getOnlyField(PlayerInfoDataClass, boolean.class);
+            PlayerInfoData_RemoteChatSession = ReflectionUtils.getOnlyField(PlayerInfoDataClass, RemoteChatSession$Data);
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public void removeEntry(@NotNull UUID entry) {
+        if (ClientboundPlayerInfoRemovePacket != null) {
+            //1.19.3+
+            player.sendPacket(newClientboundPlayerInfoRemovePacket.newInstance(Collections.singletonList(entry)));
+        } else {
+            //1.19.2-
+            player.sendPacket(createPacket(Action.REMOVE_PLAYER, new Entry.Builder(entry).build(), player.getVersion()));
+        }
+    }
+
+    @Override
+    public void updateDisplayName(@NotNull UUID entry, @Nullable IChatBaseComponent displayName) {
+        player.sendPacket(createPacket(Action.UPDATE_DISPLAY_NAME,
+                new Entry.Builder(entry).displayName(displayName).build(), player.getVersion())
+        );
+    }
+
+    @Override
+    public void updateLatency(@NotNull UUID entry, int latency) {
+        player.sendPacket(createPacket(Action.UPDATE_LATENCY,
+                new Entry.Builder(entry).latency(latency).build(), player.getVersion())
+        );
+    }
+
+    @Override
+    public void updateGameMode(@NotNull UUID entry, int gameMode) {
+        player.sendPacket(createPacket(Action.UPDATE_GAME_MODE,
+                new Entry.Builder(entry).gameMode(gameMode).build(), player.getVersion())
+        );
+    }
+
+    @Override
+    public void addEntry(@NotNull Entry entry) {
+        player.sendPacket(createPacket(Action.ADD_PLAYER, entry, player.getVersion()));
+    }
+
+    @Override
+    @SneakyThrows
+    public void setPlayerListHeaderFooter(@NotNull IChatBaseComponent header, @NotNull IChatBaseComponent footer) {
+        if (PacketPlayOutPlayerListHeaderFooterClass == null) return;
+        NMSStorage nms = NMSStorage.getInstance();
+        Object packet;
+        if (nms.getMinorVersion() >= 17) {
+            packet = newPacketPlayOutPlayerListHeaderFooter.newInstance(
+                    nms.toNMSComponent(header, player.getVersion()), nms.toNMSComponent(footer, player.getVersion()));
+        } else {
+            packet = newPacketPlayOutPlayerListHeaderFooter.newInstance();
+            HEADER.set(packet, nms.toNMSComponent(header, player.getVersion()));
+            FOOTER.set(packet, nms.toNMSComponent(footer, player.getVersion()));
+        }
+        player.sendPacket(packet);
+    }
+
+    @SneakyThrows
+    private Object createPacket(TabList.Action action, TabList.Entry entry, ProtocolVersion clientVersion) {
+        NMSStorage nms = NMSStorage.getInstance();
+        if (nms.getMinorVersion() < 8) return null;
+        Object packet;
+        List<Object> players = new ArrayList<>();
+        if (NMSStorage.getInstance().is1_19_3Plus()) {
+            EnumSet<?> actions;
+            if (action == TabList.Action.ADD_PLAYER) {
+                actions = EnumSet.allOf(EnumPlayerInfoActionClass);
+            } else {
+                actions = EnumSet.of(Enum.valueOf(EnumPlayerInfoActionClass, action.name()));
+            }
+            packet = newPacketPlayOutPlayerInfo.newInstance(actions, Collections.emptyList());
+            GameProfile profile = new GameProfile(entry.getUniqueId(), entry.getName());
+            if (entry.getSkin() != null) profile.getProperties().put(TabList.TEXTURES_PROPERTY,
+                    new Property(TabList.TEXTURES_PROPERTY, entry.getSkin().getValue(), entry.getSkin().getSignature()));
+            players.add(newPlayerInfoData.newInstance(
+                    entry.getUniqueId(),
+                    profile,
+                    true,
+                    entry.getLatency(),
+                    int2GameMode(entry.getGameMode()),
+                    entry.getDisplayName() == null ? null : nms.toNMSComponent(entry.getDisplayName(), clientVersion),
+                    null
+            ));
+        } else {
+            packet = newPacketPlayOutPlayerInfo.newInstance(Enum.valueOf(EnumPlayerInfoActionClass, action.name()),
+                    Array.newInstance(NMSStorage.getInstance().EntityPlayer, 0));
+            GameProfile profile = new GameProfile(entry.getUniqueId(), entry.getName());
+            if (entry.getSkin() != null) profile.getProperties().put(TabList.TEXTURES_PROPERTY,
+                    new Property(TabList.TEXTURES_PROPERTY, entry.getSkin().getValue(), entry.getSkin().getSignature()));
+            List<Object> parameters = new ArrayList<>();
+            if (newPlayerInfoData.getParameterTypes()[0] == PacketPlayOutPlayerInfoClass) {
+                parameters.add(packet);
+            }
+            parameters.add(profile);
+            parameters.add(entry.getLatency());
+            parameters.add(int2GameMode(entry.getGameMode()));
+            parameters.add(entry.getDisplayName() == null ? null : nms.toNMSComponent(entry.getDisplayName(), clientVersion));
+            if (nms.getMinorVersion() >= 19) parameters.add(null);
+            players.add(newPlayerInfoData.newInstance(parameters.toArray()));
+        }
+        PLAYERS.set(packet, players);
+        return packet;
+    }
+
+    private Object int2GameMode(int gameMode) {
+        switch (gameMode) {
+            case 1: return Enum.valueOf(EnumGamemodeClass, "CREATIVE");
+            case 2: return Enum.valueOf(EnumGamemodeClass, "ADVENTURE");
+            case 3: return Enum.valueOf(EnumGamemodeClass, "SPECTATOR");
+            default: return Enum.valueOf(EnumGamemodeClass, "SURVIVAL");
+        }
+    }
+}
@@ -0,0 +1,179 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import lombok.Getter;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.platform.BukkitPlatform;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+import me.neznamy.tab.shared.chat.rgb.RGBUtils;
+import me.neznamy.tab.shared.hook.ViaVersionHook;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.TabList;
+import me.neznamy.tab.platforms.bukkit.bossbar.EntityBossBar;
+import me.neznamy.tab.platforms.bukkit.bossbar.BukkitBossBar;
+import me.neznamy.tab.platforms.bukkit.bossbar.ViaBossBar;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.*;
+import me.neznamy.tab.shared.platform.Scoreboard;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.backend.BackendTabPlayer;
+import me.neznamy.tab.shared.backend.EntityData;
+import me.neznamy.tab.shared.backend.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.potion.PotionEffectType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.UUID;
+
+/**
+ * TabPlayer implementation for Bukkit platform
+ */
+@SuppressWarnings("deprecation")
+@Getter
+public class BukkitTabPlayer extends BackendTabPlayer {
+
+    /** Player's NMS handle (EntityPlayer), preloading for speed */
+    private final Object handle;
+
+    /** Player's connection for sending packets, preloading for speed */
+    private final Object playerConnection;
+
+    private final Scoreboard<BukkitTabPlayer> scoreboard = new PacketScoreboard(this);
+    private final TabList tabList = new BukkitTabList(this);
+    private final BossBar bossBar = TAB.getInstance().getServerVersion().getMinorVersion() >= 9 ?
+            new BukkitBossBar(this) : getVersion().getMinorVersion() >= 9 ? new ViaBossBar(this) : new EntityBossBar(this);
+
+    /**
+     * Constructs new instance with given bukkit player and protocol version
+     *
+     * @param   p
+     *          bukkit player
+     */
+    @SneakyThrows
+    public BukkitTabPlayer(Player p) {
+        super(p, p.getUniqueId(), p.getName(), TAB.getInstance().getConfiguration().getServerName(),
+                p.getWorld().getName(), ViaVersionHook.getInstance().getPlayerVersion(p.getUniqueId(), p.getName()));
+        handle = NMSStorage.getInstance().getHandle.invoke(player);
+        playerConnection = NMSStorage.getInstance().PLAYER_CONNECTION.get(handle);
+    }
+
+    @Override
+    public boolean hasPermission(@NotNull String permission) {
+        return getPlayer().hasPermission(permission);
+    }
+
+    @Override
+    public int getPing() {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 17) {
+            return getPlayer().getPing();
+        }
+        try {
+            return NMSStorage.getInstance().PING.getInt(handle);
+        } catch (IllegalAccessException e) {
+            return -1;
+        }
+    }
+
+    @SneakyThrows
+    public void sendPacket(@Nullable Object nmsPacket) {
+        if (nmsPacket == null || !getPlayer().isOnline()) return;
+        NMSStorage.getInstance().sendPacket.invoke(playerConnection, nmsPacket);
+    }
+
+    @Override
+    public void sendMessage(@NotNull IChatBaseComponent message) {
+        getPlayer().sendMessage(RGBUtils.getInstance().convertToBukkitFormat(message.toFlatText(),
+                getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16));
+    }
+
+    @Override
+    public boolean hasInvisibilityPotion() {
+        return getPlayer().hasPotionEffect(PotionEffectType.INVISIBILITY);
+    }
+
+    @Override
+    public boolean isDisguised() {
+        try {
+            if (!((BukkitPlatform)TAB.getInstance().getPlatform()).isLibsDisguisesEnabled()) return false;
+            return (boolean) Class.forName("me.libraryaddict.disguise.DisguiseAPI").getMethod("isDisguised", Entity.class).invoke(null, getPlayer());
+        } catch (LinkageError | ReflectiveOperationException e) {
+            //java.lang.NoClassDefFoundError: Could not initialize class me.libraryaddict.disguise.DisguiseAPI
+            TAB.getInstance().getErrorManager().printError("Failed to check disguise status using LibsDisguises", e);
+            ((BukkitPlatform)TAB.getInstance().getPlatform()).setLibsDisguisesEnabled(false);
+            return false;
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public TabList.Skin getSkin() {
+        Collection<Property> col = ((GameProfile)NMSStorage.getInstance().getProfile.invoke(handle)).getProperties().get(TabList.TEXTURES_PROPERTY);
+        if (col.isEmpty()) return null; //offline mode
+        Property property = col.iterator().next();
+        return new TabList.Skin(property.getValue(), property.getSignature());
+    }
+
+    @Override
+    public @NotNull Player getPlayer() {
+        return (Player) player;
+    }
+
+    @Override
+    public boolean isOnline() {
+        return getPlayer().isOnline();
+    }
+
+    @Override
+    public boolean isVanished() {
+        return getPlayer().getMetadata("vanished").stream().anyMatch(MetadataValue::asBoolean);
+    }
+
+    @Override
+    public int getGamemode() {
+        return getPlayer().getGameMode().getValue();
+    }
+
+    @Override
+    public void spawnEntity(int entityId, @NotNull UUID id, @NotNull Object entityType, @NotNull Location location, @NotNull EntityData data) {
+        sendPacket(PacketPlayOutSpawnEntityLivingStorage.build(entityId, id, entityType, location, data));
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 15) {
+            updateEntityMetadata(entityId, data);
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public void updateEntityMetadata(int entityId, @NotNull EntityData data) {
+        if (PacketPlayOutEntityMetadataStorage.CONSTRUCTOR.getParameterCount() == 2) {
+            //1.19.3+
+            sendPacket(PacketPlayOutEntityMetadataStorage.CONSTRUCTOR.newInstance(entityId, DataWatcher.packDirty.invoke(data.build())));
+        } else {
+            sendPacket(PacketPlayOutEntityMetadataStorage.CONSTRUCTOR.newInstance(entityId, data.build(), true));
+        }
+    }
+
+    @Override
+    public void teleportEntity(int entityId, @NotNull Location location) {
+        sendPacket(PacketPlayOutEntityTeleportStorage.build(entityId, location));
+    }
+
+    @Override
+    @SneakyThrows
+    public void destroyEntities(int... entities) {
+        if (PacketPlayOutEntityDestroyStorage.CONSTRUCTOR.getParameterTypes()[0] != int.class) {
+            sendPacket(PacketPlayOutEntityDestroyStorage.CONSTRUCTOR.newInstance(new Object[]{entities}));
+        } else {
+            //1.17.0 Mojank
+            for (int entity : entities) {
+                sendPacket(PacketPlayOutEntityDestroyStorage.CONSTRUCTOR.newInstance(entity));
+            }
+        }
+    }
+}
@@ -0,0 +1,68 @@
+package me.neznamy.tab.platforms.bukkit.bossbar;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.shared.chat.rgb.RGBUtils;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.shared.TAB;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * BossBar for 1.9+ servers where Bukkit API is used. If ViaVersion is used
+ * to allow 1.8 players, it will handle the entity and teleporting by itself.
+ */
+@RequiredArgsConstructor
+public class BukkitBossBar implements BossBar {
+
+    /** Player this handler belongs to */
+    private final BukkitTabPlayer player;
+
+    /** Bukkit BossBars the player can currently see */
+    private final Map<UUID, org.bukkit.boss.BossBar> bossBars = new HashMap<>();
+
+    @Override
+    public void create(@NotNull UUID id, @NotNull String title, float progress, @NotNull BarColor color, @NotNull BarStyle style) {
+        if (bossBars.containsKey(id)) return;
+        org.bukkit.boss.BossBar bar = Bukkit.createBossBar(
+                RGBUtils.getInstance().convertToBukkitFormat(title,
+                        player.getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16),
+                org.bukkit.boss.BarColor.valueOf(color.name()),
+                org.bukkit.boss.BarStyle.valueOf(style.getBukkitName()));
+        bar.setProgress(progress);
+        bar.addPlayer(player.getPlayer());
+        bossBars.put(id, bar);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull String title) {
+        bossBars.get(id).setTitle(RGBUtils.getInstance().convertToBukkitFormat(title,
+                player.getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, float progress) {
+        bossBars.get(id).setProgress(progress);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarStyle style) {
+        bossBars.get(id).setStyle(org.bukkit.boss.BarStyle.valueOf(style.getBukkitName()));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarColor color) {
+        bossBars.get(id).setColor(org.bukkit.boss.BarColor.valueOf(color.name()));
+    }
+
+    @Override
+    public void remove(@NotNull UUID id) {
+        bossBars.remove(id).removePlayer(player.getPlayer());
+    }
+}
@@ -0,0 +1,64 @@
+package me.neznamy.tab.platforms.bukkit.bossbar;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.shared.backend.Location;
+import org.bukkit.entity.EntityType;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+/**
+ * BossBar using wither entity for <1.9 players on <1.9 servers.
+ * Additional logic, such as teleporting the entity must be done
+ * separately, as this class does not handle it.
+ */
+@RequiredArgsConstructor
+public class EntityBossBar implements BossBar {
+
+    /** Player this handler belongs to */
+    private final BukkitTabPlayer player;
+
+    @Override
+    public void create(@NotNull UUID id, @NotNull String title, float progress, @NotNull BarColor color, @NotNull BarStyle style) {
+        DataWatcher w = new DataWatcher();
+        float health = 300*progress;
+        if (health == 0) health = 1;
+        w.getHelper().setHealth(health);
+        w.getHelper().setCustomName(title, player.getVersion());
+        w.getHelper().setEntityFlags((byte) 32);
+        w.getHelper().setWitherInvulnerableTime(880); // Magic number
+        player.spawnEntity(id.hashCode(), new UUID(0, 0), EntityType.WITHER, new Location(0, 0, 0, 0, 0), w);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull String title) {
+        DataWatcher w = new DataWatcher();
+        w.getHelper().setCustomName(title, player.getVersion());
+        player.updateEntityMetadata(id.hashCode(), w);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, float progress) {
+        DataWatcher w = new DataWatcher();
+        float health = 300*progress;
+        if (health == 0) health = 1;
+        w.getHelper().setHealth(health);
+        player.updateEntityMetadata(id.hashCode(), w);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarStyle style) {/*Added in 1.9*/}
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarColor color) {/*Added in 1.9*/}
+
+    @Override
+    public void remove(@NotNull UUID id) {
+        player.destroyEntities(id.hashCode());
+    }
+}
@@ -0,0 +1,67 @@
+package me.neznamy.tab.platforms.bukkit.bossbar;
+
+import com.viaversion.viaversion.api.Via;
+import com.viaversion.viaversion.api.legacy.bossbar.BossColor;
+import com.viaversion.viaversion.api.legacy.bossbar.BossStyle;
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+import me.neznamy.tab.shared.chat.rgb.RGBUtils;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Handler for 1.9+ players on 1.8 server using ViaVersion API.
+ */
+@RequiredArgsConstructor
+public class ViaBossBar implements BossBar {
+
+    /** Player this handler belongs to */
+    private final BukkitTabPlayer player;
+
+    /** ViaVersion BossBars this 1.9+ player can see on 1.8 server */
+    private final Map<UUID, com.viaversion.viaversion.api.legacy.bossbar.BossBar> viaBossBars = new HashMap<>();
+
+    @Override
+    public void create(@NotNull UUID id, @NotNull String title, float progress, @NotNull BarColor color, @NotNull BarStyle style) {
+        if (viaBossBars.containsKey(id)) return;
+        com.viaversion.viaversion.api.legacy.bossbar.BossBar bar = Via.getAPI().legacyAPI().createLegacyBossBar(
+                RGBUtils.getInstance().convertToBukkitFormat(title, player.getVersion().getMinorVersion() >= 16),
+                progress,
+                BossColor.valueOf(color.name()),
+                BossStyle.valueOf(style.getBukkitName()));
+        viaBossBars.put(id, bar);
+        bar.addPlayer(player.getPlayer().getUniqueId());
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull String title) {
+        viaBossBars.get(id).setTitle(RGBUtils.getInstance().convertToBukkitFormat(title,
+                player.getVersion().getMinorVersion() >= 16));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, float progress) {
+        viaBossBars.get(id).setHealth(progress);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarStyle style) {
+        viaBossBars.get(id).setStyle(BossStyle.valueOf(style.getBukkitName()));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarColor color) {
+        viaBossBars.get(id).setColor(BossColor.valueOf(color.name()));
+    }
+
+    @Override
+    public void remove(@NotNull UUID id) {
+        viaBossBars.remove(id).removePlayer(player.getPlayer().getUniqueId());
+    }
+}
@@ -0,0 +1,199 @@
+package me.neznamy.tab.platforms.bukkit.features;
+
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.platform.BukkitPlatform;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import me.neznamy.tab.shared.features.types.PacketSendListener;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.PacketPlayOutEntityDestroyStorage;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.PacketPlayOutEntityTeleportStorage;
+import me.neznamy.tab.shared.backend.BackendTabPlayer;
+import me.neznamy.tab.shared.backend.EntityData;
+import me.neznamy.tab.shared.backend.features.unlimitedtags.BackendNameTagX;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Pose;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.event.player.PlayerToggleSneakEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * The core class for unlimited NameTag mode on Bukkit
+ */
+public class BukkitNameTagX extends BackendNameTagX implements Listener, PacketSendListener {
+
+    /** Reference to NMS storage for quick access */
+    private final NMSStorage nms = NMSStorage.getInstance();
+
+    public BukkitNameTagX(@NotNull JavaPlugin plugin) {
+        Bukkit.getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onSneak(PlayerToggleSneakEvent e) {
+        TabPlayer p = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
+        if (p == null || isPlayerDisabled(p)) return;
+        TAB.getInstance().getCPUManager().runMeasuredTask(featureName, TabConstants.CpuUsageCategory.PLAYER_SNEAK,
+                () -> getArmorStandManager(p).sneak(e.isSneaking()));
+    }
+
+    @EventHandler
+    public void onRespawn(PlayerRespawnEvent e) {
+        TabPlayer respawned = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
+        if (respawned == null || isPlayerDisabled(respawned)) return;
+        TAB.getInstance().getCPUManager().runMeasuredTask(featureName, TabConstants.CpuUsageCategory.PLAYER_RESPAWN,
+                () -> getArmorStandManager(respawned).teleport());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    @SneakyThrows
+    public void onPacketSend(@NotNull TabPlayer receiver, @NotNull Object packet) {
+        if (receiver.getVersion().getMinorVersion() < 8) return;
+        if (!receiver.isLoaded() || getDisableChecker().isDisabledPlayer(receiver) || getUnlimitedDisableChecker().isDisabledPlayer(receiver)) return;
+        if (nms.PacketPlayOutEntity.isInstance(packet) && !nms.PacketPlayOutEntityLook.isInstance(packet)) { //ignoring head rotation only packets
+            packetListener.onEntityMove((BackendTabPlayer) receiver, nms.PacketPlayOutEntity_ENTITYID.getInt(packet));
+        } else if (PacketPlayOutEntityTeleportStorage.CLASS.isInstance(packet)) {
+            packetListener.onEntityMove((BackendTabPlayer) receiver, PacketPlayOutEntityTeleportStorage.ENTITY_ID.getInt(packet));
+        } else if (nms.PacketPlayOutNamedEntitySpawn.isInstance(packet)) {
+            packetListener.onEntitySpawn((BackendTabPlayer) receiver, nms.PacketPlayOutNamedEntitySpawn_ENTITYID.getInt(packet));
+        } else if (PacketPlayOutEntityDestroyStorage.CLASS.isInstance(packet)) {
+            if (nms.getMinorVersion() >= 17) {
+                Object entities = PacketPlayOutEntityDestroyStorage.ENTITIES.get(packet);
+                if (entities instanceof List) {
+                    packetListener.onEntityDestroy((BackendTabPlayer) receiver, (List<Integer>) entities);
+                } else {
+                    //1.17.0
+                    packetListener.onEntityDestroy((BackendTabPlayer) receiver, (int) entities);
+                }
+            } else {
+                packetListener.onEntityDestroy((BackendTabPlayer) receiver, (int[]) PacketPlayOutEntityDestroyStorage.ENTITIES.get(packet));
+            }
+        }
+    }
+
+    @Override
+    public double getDistance(@NotNull TabPlayer player1, @NotNull TabPlayer player2) {
+        Location loc1 = ((Player) player1.getPlayer()).getLocation();
+        Location loc2 = ((Player) player2.getPlayer()).getLocation();
+        return Math.sqrt(Math.pow(loc1.getX()-loc2.getX(), 2) + Math.pow(loc1.getZ()-loc2.getZ(), 2));
+    }
+
+    @Override
+    public boolean areInSameWorld(@NotNull TabPlayer player1, @NotNull TabPlayer player2) {
+        return ((Player) player1.getPlayer()).getWorld() == ((Player) player2.getPlayer()).getWorld();
+    }
+
+    @Override
+    public boolean canSee(@NotNull TabPlayer viewer, @NotNull TabPlayer target) {
+        return ((Player)viewer.getPlayer()).canSee((Player) target.getPlayer());
+    }
+
+    @Override
+    public void unregisterListener() {
+        HandlerList.unregisterAll(this);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public @NotNull List<Integer> getPassengers(@NotNull Object entity) {
+        Entity vehicle = (Entity) entity;
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 11) {
+            return vehicle.getPassengers().stream().map(Entity::getEntityId).collect(Collectors.toList());
+        } else {
+            if (vehicle.getPassenger() != null) {
+                return Collections.singletonList(vehicle.getPassenger().getEntityId());
+            } else {
+                return Collections.emptyList();
+            }
+        }
+    }
+
+    @Override
+    public @Nullable Object getVehicle(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).getVehicle();
+    }
+
+    @Override
+    public int getEntityId(@NotNull Object entity) {
+        return ((Entity)entity).getEntityId();
+    }
+
+    @Override
+    public @NotNull String getEntityType(@NotNull Object entity) {
+        return ((Entity) entity).getType().toString().toLowerCase();
+    }
+
+    @Override
+    public boolean isSneaking(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).isSneaking();
+    }
+
+    @Override
+    public boolean isSwimming(@NotNull TabPlayer player) {
+        Player p = (Player) player.getPlayer();
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 14 && p.getPose() == Pose.SWIMMING) return true;
+        return TAB.getInstance().getServerVersion().getMinorVersion() == 13 && p.isSwimming();
+    }
+
+    @Override
+    public boolean isGliding(@NotNull TabPlayer player) {
+        return TAB.getInstance().getServerVersion().getMinorVersion() >= 9 && ((Player)player.getPlayer()).isGliding();
+    }
+
+    @Override
+    public boolean isSleeping(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).isSleeping();
+    }
+
+    @Override
+    public @NotNull Object getArmorStandType() {
+        return EntityType.ARMOR_STAND;
+    }
+
+    @Override
+    public double getX(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).getLocation().getX();
+    }
+
+    @Override
+    public double getY(@NotNull Object entity) {
+        return ((Entity)entity).getLocation().getY();
+    }
+
+    @Override
+    public double getZ(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).getLocation().getZ();
+    }
+
+    @Override
+    public EntityData createDataWatcher(@NotNull TabPlayer viewer, byte flags, @NotNull String displayName, boolean nameVisible) {
+        DataWatcher datawatcher = new DataWatcher();
+        datawatcher.getHelper().setEntityFlags(flags);
+        datawatcher.getHelper().setCustomName(displayName, viewer.getVersion());
+        datawatcher.getHelper().setCustomNameVisible(nameVisible);
+        datawatcher.getHelper().setArmorStandFlags((byte)16);
+        return datawatcher;
+    }
+
+    @Override
+    public void runInEntityScheduler(Object entity, Runnable task) {
+        ((BukkitPlatform)TAB.getInstance().getPlatform()).runEntityTask((Entity) entity, task);
+    }
+}
@@ -0,0 +1,60 @@
+package me.neznamy.tab.platforms.bukkit.features;
+
+import lombok.Getter;
+import me.clip.placeholderapi.PlaceholderAPI;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import me.neznamy.tab.shared.placeholders.expansion.TabExpansion;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/**
+ * TAB's expansion for PlaceholderAPI
+ */
+@Getter
+public class BukkitTabExpansion extends PlaceholderExpansion implements TabExpansion {
+
+    /** Map holding all values for all players for easy and high-performance access */
+    private final WeakHashMap<Player, Map<String, String>> values = new WeakHashMap<>();
+
+    private final String author = TabConstants.PLUGIN_AUTHOR;
+    private final String identifier = TabConstants.PLUGIN_ID;
+    private final String version = TabConstants.PLUGIN_VERSION;
+
+    @Override
+    public boolean persist() {
+        return true;
+    }
+
+    @Override
+    public String onPlaceholderRequest(@Nullable Player player, @NotNull String identifier) {
+        if (identifier.startsWith("replace_")) {
+            String text = "%" + identifier.substring(8) + "%";
+            String textBefore;
+            do {
+                textBefore = text;
+                for (String placeholder : TAB.getInstance().getPlaceholderManager().detectPlaceholders(text)) {
+                    text = text.replace(placeholder, TAB.getInstance().getPlaceholderManager().findReplacement(placeholder,
+                            PlaceholderAPI.setPlaceholders(player, placeholder)));
+                }
+            } while (!textBefore.equals(text));
+            return text;
+        }
+        if (identifier.startsWith("placeholder_")) {
+            TAB.getInstance().getPlaceholderManager().addUsedPlaceholder("%" + identifier.substring(12) + "%", TAB.getInstance().getPlaceholderManager());
+        }
+        return values.get(player).get(identifier);
+    }
+
+    @Override
+    public void setValue(@NotNull TabPlayer player, @NotNull String key, @NotNull String value) {
+        values.computeIfAbsent((Player) player.getPlayer(), p -> new HashMap<>()).put(key, value);
+    }
+}
@@ -0,0 +1,112 @@
+package me.neznamy.tab.platforms.bukkit.features;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.shared.features.types.Loadable;
+import me.neznamy.tab.shared.features.types.UnLoadable;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import me.neznamy.tab.shared.features.types.TabFeature;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.TAB;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Per-world-PlayerList feature handler
+ */
+@SuppressWarnings("deprecation")
+@RequiredArgsConstructor
+public class PerWorldPlayerList extends TabFeature implements Listener, Loadable, UnLoadable {
+
+    /** Config options */
+    private final boolean allowBypass = TAB.getInstance().getConfig().getBoolean("per-world-playerlist.allow-bypass-permission", false);
+    private final List<String> ignoredWorlds = TAB.getInstance().getConfig().getStringList("per-world-playerlist.ignore-effect-in-worlds", Arrays.asList("ignored_world", "build"));
+    private final Map<String, List<String>> sharedWorlds = TAB.getInstance().getConfig().getConfigurationSection("per-world-playerlist.shared-playerlist-world-groups");
+
+    /** Plugin reference*/
+    @NotNull private final JavaPlugin plugin;
+
+    @Getter private final String featureName = "Per world PlayerList";
+
+    @Override
+    public void load() {
+        Bukkit.getOnlinePlayers().forEach(this::checkPlayer);
+        Bukkit.getPluginManager().registerEvents(this, plugin);
+    }
+
+    @Override
+    public void unload() {
+        for (Player p : Bukkit.getOnlinePlayers()) {
+            for (Player pl : Bukkit.getOnlinePlayers()) {
+                p.showPlayer(pl);
+            }
+        }
+        HandlerList.unregisterAll(this);
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent e) {
+        long time = System.nanoTime();
+        checkPlayer(e.getPlayer());
+        TAB.getInstance().getCPUManager().addTime(featureName, TabConstants.CpuUsageCategory.PLAYER_JOIN, System.nanoTime()-time);
+    }
+
+    @EventHandler
+    public void onWorldChange(PlayerChangedWorldEvent e) {
+        long time = System.nanoTime();
+        checkPlayer(e.getPlayer());
+        TAB.getInstance().getCPUManager().addTime(featureName, TabConstants.CpuUsageCategory.WORLD_SWITCH, System.nanoTime()-time);
+    }
+
+    /**
+     * Performs visibility check on the player. Shows players this player should see and does not,
+     * hides players the player should not see, shows the player to those who should see player and hides
+     * from those, who should not see.
+     *
+     * @param   p
+     *          Player to update
+     */
+    private void checkPlayer(@NotNull Player p) {
+        for (Player all : Bukkit.getOnlinePlayers()) {
+            if (all == p) continue;
+            if (!shouldSee(p, all) && p.canSee(all)) p.hidePlayer(all);
+            if (shouldSee(p, all) && !p.canSee(all)) p.showPlayer(all);
+            if (!shouldSee(all, p) && all.canSee(p)) all.hidePlayer(p);
+            if (shouldSee(all, p) && !all.canSee(p)) all.showPlayer(p);
+        }
+    }
+
+    /**
+     * Returns {@code true} if viewer should see target player, {@code false} if not.
+     * @param   viewer
+     *          Player viewing the TabList
+     * @param   target
+     *          Target displayed in the TabList
+     * @return  {@code true} if viewer should see target, {@code false} if not.
+     */
+    private boolean shouldSee(@NotNull Player viewer, @NotNull Player target) {
+        if (target == viewer) return true;
+        if ((allowBypass && viewer.hasPermission(TabConstants.Permission.PER_WORLD_PLAYERLIST_BYPASS)) || ignoredWorlds.contains(viewer.getWorld().getName())) return true;
+        String viewerWorldGroup = viewer.getWorld().getName() + "-default"; //preventing unwanted behavior when some group is called exactly like a world
+        String targetWorldGroup = target.getWorld().getName() + "-default";
+        for (Entry<String, List<String>> group : sharedWorlds.entrySet()) {
+            if (group.getValue() != null) {
+                if (group.getValue().contains(viewer.getWorld().getName())) viewerWorldGroup = group.getKey();
+                if (group.getValue().contains(target.getWorld().getName())) targetWorldGroup = group.getKey();
+            }
+        }
+        return viewerWorldGroup.equals(targetWorldGroup);
+    }
+}
@@ -0,0 +1,83 @@
+package me.neznamy.tab.platforms.bukkit.features;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import me.neznamy.tab.api.bossbar.BossBar;
+import me.neznamy.tab.shared.features.types.WorldSwitchListener;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.backend.BackendTabPlayer;
+import me.neznamy.tab.shared.features.bossbar.BossBarManagerImpl;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An additional class with additional code for &lt;1.9 servers due to an entity being required
+ */
+@RequiredArgsConstructor
+public class WitherBossBar extends BossBarManagerImpl implements Listener, WorldSwitchListener {
+
+    /** Distance of the Wither in blocks */
+    private static final int WITHER_DISTANCE = 60;
+
+    /** Reference to plugin for registering listener */
+    private final @NotNull JavaPlugin plugin;
+
+    @Override
+    public void load() {
+        Bukkit.getPluginManager().registerEvents(this, plugin);
+        //when MC is on fullscreen, BossBar disappears after 1 second of not being seen
+        //when in a small window, it's about 100ms
+        TAB.getInstance().getCPUManager().startRepeatingMeasuredTask(100,
+                featureName, TabConstants.CpuUsageCategory.TELEPORTING_WITHER, this::teleport);
+        super.load();
+        teleport();
+    }
+
+    /**
+     * Updates Wither location for all online players
+     */
+    private void teleport() {
+        for (TabPlayer p : TAB.getInstance().getOnlinePlayers()) {
+            if (p.getVersion().getMinorVersion() > 8) continue; //sending VV packets to those
+            for (BossBar line : getRegisteredBossBars().values()) {
+                if (!line.getPlayers().contains(p)) continue;
+                Location loc = ((Player) p.getPlayer()).getEyeLocation().add(((Player) p.getPlayer()).getEyeLocation().getDirection().normalize().multiply(WITHER_DISTANCE));
+                if (loc.getY() < 1) loc.setY(1);
+                ((BackendTabPlayer)p).teleportEntity(line.getUniqueId().hashCode(), new me.neznamy.tab.shared.backend.Location(loc.getX(), loc.getY(), loc.getZ(), 0, 0));
+            }
+        }
+    }
+    
+    @Override
+    public void unload() {
+        super.unload();
+        HandlerList.unregisterAll(this);
+    }
+    
+    /**
+     * Respawning wither as respawn screen destroys all entities in client
+     */
+    @EventHandler
+    public void onRespawn(PlayerRespawnEvent e) {
+        TabPlayer player = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
+        if (player == null) return;
+        TAB.getInstance().getCPUManager().runMeasuredTask(featureName, TabConstants.CpuUsageCategory.PLAYER_RESPAWN,
+                () -> detectBossBarsAndSend(player));
+    }
+
+    @Override
+    public void onWorldChange(@NotNull TabPlayer p, @NotNull String from, @NotNull String to) {
+        for (BossBar line : lineValues) {
+            line.removePlayer(p);
+        }
+        detectBossBarsAndSend(p);
+    }
+}
@@ -0,0 +1,89 @@
+package me.neznamy.tab.platforms.bukkit.nms.datawatcher;
+
+import lombok.Getter;
+import lombok.SneakyThrows;
+import lombok.ToString;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.backend.EntityData;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A class representing the n.m.s.DataWatcher class to make work with it much easier
+ */
+@ToString
+public class DataWatcher implements EntityData {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    private static Constructor<?> CONSTRUCTOR;
+    private static Method REGISTER;
+    public static Method markDirty;
+    public static Method packDirty;
+    
+    /** Watched data */
+    private final Map<Integer, DataWatcherItem> dataValues = new HashMap<>();
+
+    /** Helper for easier data write */
+    @Getter private final DataWatcherHelper helper = new DataWatcherHelper(this);
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @param   nms
+     *          NMS storage reference
+     */
+    public static void load(NMSStorage nms) throws NoSuchMethodException {
+        CONSTRUCTOR = ReflectionUtils.getOnlyConstructor(CLASS);
+        if (nms.getMinorVersion() >= 9) {
+            REGISTER = ReflectionUtils.getMethod(CLASS, new String[]{"register", "a"}, DataWatcherObject.CLASS, Object.class); // {Bukkit, Bukkit 1.18+}
+        } else {
+            REGISTER = ReflectionUtils.getMethod(CLASS, new String[]{"func_75682_a", "a"}, int.class, Object.class); // {Thermos 1.7.10, Bukkit}
+        }
+        if (nms.getMinorVersion() >= 19) {
+            packDirty = CLASS.getMethod("b");
+        }
+        if (nms.is1_19_3Plus()) {
+            markDirty = ReflectionUtils.getOnlyMethod(CLASS, void.class, DataWatcherObject.CLASS);
+        }
+    }
+    
+    /**
+     * Sets value into data values
+     *
+     * @param   type
+     *          type of value
+     * @param   value
+     *          value
+     */
+    public void setValue(@NotNull DataWatcherObject type, @NotNull Object value) {
+        dataValues.put(type.getPosition(), new DataWatcherItem(type, value));
+    }
+
+    /**
+     * Converts the class into an instance of NMS.DataWatcher
+     *
+     * @return  an instance of NMS.DataWatcher with same data
+     */
+    @SneakyThrows
+    public @NotNull Object build() {
+        NMSStorage nms = NMSStorage.getInstance();
+        Object nmsWatcher;
+        if (CONSTRUCTOR.getParameterCount() == 1) { //1.7+
+            nmsWatcher = CONSTRUCTOR.newInstance(new Object[] {null});
+        } else {
+            nmsWatcher = CONSTRUCTOR.newInstance();
+        }
+        for (DataWatcherItem item : dataValues.values()) {
+            Object nmsObject = item.getType().build();
+            REGISTER.invoke(nmsWatcher, nmsObject, item.getValue());
+            if (nms.is1_19_3Plus()) markDirty.invoke(nmsWatcher, nmsObject);
+        }
+        return nmsWatcher;
+    }
+}
@@ -0,0 +1,160 @@
+package me.neznamy.tab.platforms.bukkit.nms.datawatcher;
+
+import lombok.AllArgsConstructor;
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.TAB;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+
+/**
+ * A class to help to assign DataWatcher items as positions often change per-version
+ */
+@AllArgsConstructor
+public class DataWatcherHelper {
+
+    /** NMS Fields */
+    public static Class<?> DataWatcherRegistry;
+    public static Class<?> DataWatcherSerializer;
+    public static Object DataWatcherSerializer_BYTE;
+    public static Object DataWatcherSerializer_FLOAT;
+    public static Object DataWatcherSerializer_STRING;
+    public static Object DataWatcherSerializer_OPTIONAL_COMPONENT;
+    public static Object DataWatcherSerializer_BOOLEAN;
+
+    /** Instance fields */
+    private final int armorStandFlagsPosition = getArmorStandFlagsPosition();
+    @NotNull private final DataWatcher data;
+
+    /**
+     * Returns armor stand flags position based on server version
+     *
+     * @return  armor stand flags position based on server version
+     */
+    private int getArmorStandFlagsPosition() {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 17) {
+            //1.17.x, 1.18.x, 1.19.x
+            return 15;
+        } else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 15) {
+            //1.15.x, 1.16.x
+            return 14;
+        } else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 14) {
+            //1.14.x
+            return 13;
+        } else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 10) {
+            //1.10.x - 1.13.x
+            return 11;
+        } else {
+            //1.8.x - 1.9.x
+            return 10;
+        }
+    }
+
+    public static void load(NMSStorage nms) throws NoSuchFieldException, IllegalAccessException {
+        if (nms.getMinorVersion() < 9) return;
+        DataWatcherSerializer_BYTE = DataWatcherRegistry.getDeclaredField("a").get(null);
+        DataWatcherSerializer_FLOAT = DataWatcherRegistry.getDeclaredField("c").get(null);
+        DataWatcherSerializer_STRING = DataWatcherRegistry.getDeclaredField("d").get(null);
+        if (nms.is1_19_3Plus()) {
+            DataWatcherSerializer_OPTIONAL_COMPONENT = DataWatcherRegistry.getDeclaredField("g").get(null);
+            if (nms.is1_19_4Plus()) {
+                DataWatcherSerializer_BOOLEAN = DataWatcherRegistry.getDeclaredField("k").get(null);
+            } else {
+                DataWatcherSerializer_BOOLEAN = DataWatcherRegistry.getDeclaredField("j").get(null);
+            }
+        } else {
+            if (nms.getMinorVersion() >= 13) {
+                DataWatcherSerializer_OPTIONAL_COMPONENT = DataWatcherRegistry.getDeclaredField("f").get(null);
+                DataWatcherSerializer_BOOLEAN = DataWatcherRegistry.getDeclaredField("i").get(null);
+            } else {
+                DataWatcherSerializer_BOOLEAN = DataWatcherRegistry.getDeclaredField("h").get(null);
+            }
+        }
+    }
+
+    /**
+     * Writes entity byte flags
+     *
+     * @param   flags
+     *          flags to write
+     */
+    public void setEntityFlags(byte flags) {
+        data.setValue(new DataWatcherObject(0, DataWatcherSerializer_BYTE), flags);
+    }
+
+    /**
+     * Writes entity custom name with position based on server version and value depending on client version (RGB or not)
+     *
+     * @param   customName
+     *          target custom name
+     * @param   clientVersion
+     *          client version
+     */
+    public void setCustomName(@NotNull String customName, @NotNull ProtocolVersion clientVersion) {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 13) {
+            data.setValue(new DataWatcherObject(2, DataWatcherSerializer_OPTIONAL_COMPONENT),
+                    Optional.ofNullable(NMSStorage.getInstance().toNMSComponent(IChatBaseComponent.optimizedComponent(customName), clientVersion)));
+        } else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 8) {
+            data.setValue(new DataWatcherObject(2, DataWatcherSerializer_STRING), customName);
+        } else {
+            //name length is limited to 64 characters on <1.8
+            String cutName = (customName.length() > 64 ? customName.substring(0, 64) : customName);
+            if (TAB.getInstance().getServerVersion().getMinorVersion() >= 6) {
+                data.setValue(new DataWatcherObject(10, null), cutName);
+            } else {
+                data.setValue(new DataWatcherObject(5, null), cutName);
+            }
+        }
+    }
+
+    /**
+     * Writes custom name visibility boolean
+     *
+     * @param   visible
+     *          if visible or not
+     */
+    public void setCustomNameVisible(boolean visible) {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 9) {
+            data.setValue(new DataWatcherObject(3, DataWatcherSerializer_BOOLEAN), visible);
+        } else {
+            data.setValue(new DataWatcherObject(3, null), (byte)(visible?1:0));
+        }
+    }
+
+    /**
+     * Writes entity health
+     *
+     * @param   health
+     *          health of entity
+     */
+    public void setHealth(float health) {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 6) {
+            data.setValue(new DataWatcherObject(6, DataWatcherSerializer_FLOAT), health);
+        } else {
+            data.setValue(new DataWatcherObject(16, null), (int)health);
+        }
+    }
+
+    /**
+     * Writes armor stand flags
+     *
+     * @param   flags
+     *          flags to write
+     */
+    public void setArmorStandFlags(byte flags) {
+        data.setValue(new DataWatcherObject(armorStandFlagsPosition, DataWatcherSerializer_BYTE), flags);
+    }
+
+    /**
+     * Writes wither invulnerable time
+     * @param   time
+     *          Time, apparently
+     */
+    public void setWitherInvulnerableTime(int time) {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() > 8)
+            throw new UnsupportedOperationException("Not supported on 1.9+");
+        data.setValue(new DataWatcherObject(20, null), time);
+    }
+}
@@ -0,0 +1,39 @@
+package me.neznamy.tab.platforms.bukkit.nms.datawatcher;
+
+import lombok.Data;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Field;
+
+/**
+ * Class representing NMS Data Watcher Item
+ */
+@Data
+public class DataWatcherItem {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Field TYPE;
+    public static Field VALUE;
+
+    /** Instance fields */
+    @NotNull private final DataWatcherObject type;
+    @NotNull private final Object value;
+
+    /**
+     * Loads all required Fields
+     *
+     * @param   nms
+     *          NMS storage reference
+     */
+    public static void load(NMSStorage nms) {
+        VALUE = ReflectionUtils.getFields(CLASS, Object.class).get(0);
+        if (nms.getMinorVersion() >= 9) {
+            TYPE = ReflectionUtils.getOnlyField(CLASS, DataWatcherObject.CLASS);
+        } else {
+            TYPE = ReflectionUtils.getFields(CLASS, int.class).get(1);
+        }
+    }
+}
@@ -0,0 +1,54 @@
+package me.neznamy.tab.platforms.bukkit.nms.datawatcher;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
+/**
+ * A class representing the n.m.s.DataWatcherObject class to make work with it much easier
+ */
+@Data @AllArgsConstructor
+public class DataWatcherObject {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+    public static Field SLOT;
+    public static Field SERIALIZER;
+    
+    /** Instance fields */
+    private final int position;
+    @Nullable private final Object serializer;
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load() throws NoSuchMethodException {
+        CONSTRUCTOR = CLASS.getConstructor(int.class, DataWatcherHelper.DataWatcherSerializer);
+        SLOT = ReflectionUtils.getOnlyField(CLASS, int.class);
+        SERIALIZER = ReflectionUtils.getOnlyField(CLASS, DataWatcherHelper.DataWatcherSerializer);
+    }
+
+    /**
+     * Converts the object into NMS object
+     *
+     * @return  NMS object
+     */
+    @SneakyThrows
+    public Object build() {
+        if (NMSStorage.getInstance().getMinorVersion() >= 9) {
+            return DataWatcherObject.CONSTRUCTOR.newInstance(position, serializer);
+        } else {
+            return position;
+        }
+    }
+}
@@ -0,0 +1,109 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.nms;
+
+import me.neznamy.tab.platforms.bukkit.BukkitTabList;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherHelper;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherItem;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherObject;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.*;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+/**
+ * NMS loader for Minecraft 1.5.2 - 1.16.5 using Bukkit mapping.
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class BukkitLegacyNMSStorage extends NMSStorage {
+
+    /**
+     * Returns class with given potential names in same order
+     *
+     * @param   names
+     *          possible class names
+     * @return  class for specified names
+     * @throws  ClassNotFoundException
+     *          if class does not exist
+     */
+    private Class<?> getLegacyClass(@NotNull String... names) throws ClassNotFoundException {
+        for (String name : names) {
+            try {
+                return getLegacyClass(name);
+            } catch (ClassNotFoundException e) {
+                //not the first class name in array
+            }
+        }
+        throw new ClassNotFoundException("No class found with possible names " + Arrays.toString(names));
+    }
+
+    /**
+     * Returns class from given name. Supports modded servers, such as Thermos.
+     *
+     * @param   name
+     *          class name
+     * @return  class from given name
+     * @throws  ClassNotFoundException
+     *          if class was not found
+     */
+    public Class<?> getLegacyClass(@NotNull String name) throws ClassNotFoundException {
+        try {
+            return getClass().getClassLoader().loadClass("net.minecraft.server." + serverPackage + "." + name);
+        } catch (NullPointerException e) {
+            // nested class not found
+            throw new ClassNotFoundException(name);
+        }
+    }
+
+    @Override
+    public void loadClasses() throws ClassNotFoundException {
+        EntityHuman = getLegacyClass("EntityHuman");
+        World = getLegacyClass("World");
+        Packet = getLegacyClass("Packet");
+        EnumChatFormat = (Class<Enum>) getLegacyClass("EnumChatFormat");
+        EntityPlayer = getLegacyClass("EntityPlayer");
+        Entity = getLegacyClass("Entity");
+        EntityLiving = getLegacyClass("EntityLiving");
+        PlayerConnection = getLegacyClass("PlayerConnection");
+        NetworkManager = getLegacyClass("NetworkManager");
+        DataWatcher.CLASS = getLegacyClass("DataWatcher");
+        DataWatcherItem.CLASS = getLegacyClass("DataWatcher$Item", "DataWatcher$WatchableObject", "WatchableObject");
+        PacketPlayOutSpawnEntityLivingStorage.CLASS = getLegacyClass("PacketPlayOutSpawnEntityLiving", "Packet24MobSpawn");
+        PacketPlayOutEntityTeleportStorage.CLASS = getLegacyClass("PacketPlayOutEntityTeleport", "Packet34EntityTeleport");
+        PacketPlayOutEntity = getLegacyClass("PacketPlayOutEntity", "Packet30Entity");
+        PacketPlayOutEntityDestroyStorage.CLASS = getLegacyClass("PacketPlayOutEntityDestroy", "Packet29DestroyEntity");
+        PacketPlayOutEntityLook = getLegacyClass("PacketPlayOutEntity$PacketPlayOutEntityLook", "PacketPlayOutEntityLook", "Packet32EntityLook");
+        PacketPlayOutEntityMetadataStorage.CLASS = getLegacyClass("PacketPlayOutEntityMetadata", "Packet40EntityMetadata");
+        PacketPlayOutNamedEntitySpawn = getLegacyClass("PacketPlayOutNamedEntitySpawn", "Packet20NamedEntitySpawn");
+        PacketScoreboard.DisplayObjectiveClass = getLegacyClass("PacketPlayOutScoreboardDisplayObjective", "Packet208SetScoreboardDisplayObjective");
+        PacketScoreboard.ObjectivePacketClass = getLegacyClass("PacketPlayOutScoreboardObjective", "Packet206SetScoreboardObjective");
+        PacketScoreboard.TeamPacketClass = getLegacyClass("PacketPlayOutScoreboardTeam", "Packet209SetScoreboardTeam");
+        PacketScoreboard.ScorePacketClass = getLegacyClass("PacketPlayOutScoreboardScore", "Packet207SetScoreboardScore");
+        PacketScoreboard.Scoreboard = getLegacyClass("Scoreboard");
+        PacketScoreboard.ScoreboardObjective = getLegacyClass("ScoreboardObjective");
+        PacketScoreboard.ScoreboardScoreClass = getLegacyClass("ScoreboardScore");
+        PacketScoreboard.IScoreboardCriteria = getLegacyClass("IScoreboardCriteria", "IObjective"); // 1.5.1+, 1.5
+        PacketScoreboard.ScoreboardTeam = getLegacyClass("ScoreboardTeam");
+        if (minorVersion >= 7) {
+            IChatBaseComponent = getLegacyClass("IChatBaseComponent");
+            ChatSerializer = getLegacyClass("IChatBaseComponent$ChatSerializer", "ChatSerializer");
+        }
+        if (minorVersion >= 8) {
+            BukkitTabList.PacketPlayOutPlayerListHeaderFooterClass = getLegacyClass("PacketPlayOutPlayerListHeaderFooter");
+            EntityArmorStand = getLegacyClass("EntityArmorStand");
+            BukkitTabList.PacketPlayOutPlayerInfoClass = getLegacyClass("PacketPlayOutPlayerInfo");
+            BukkitTabList.EnumPlayerInfoActionClass = (Class<Enum>) getLegacyClass("PacketPlayOutPlayerInfo$EnumPlayerInfoAction", "EnumPlayerInfoAction");
+            BukkitTabList.PlayerInfoDataClass = getLegacyClass("PacketPlayOutPlayerInfo$PlayerInfoData", "PlayerInfoData");
+            BukkitTabList.EnumGamemodeClass = (Class<Enum>) getLegacyClass("EnumGamemode", "WorldSettings$EnumGamemode");
+            PacketScoreboard.EnumScoreboardHealthDisplay = (Class<Enum>) getLegacyClass("IScoreboardCriteria$EnumScoreboardHealthDisplay", "EnumScoreboardHealthDisplay");
+            PacketScoreboard.EnumScoreboardAction = (Class<Enum>) getLegacyClass("ScoreboardServer$Action", "PacketPlayOutScoreboardScore$EnumScoreboardAction", "EnumScoreboardAction");
+            PacketScoreboard.EnumNameTagVisibility = (Class<Enum>) getLegacyClass("ScoreboardTeamBase$EnumNameTagVisibility", "EnumNameTagVisibility");
+        }
+        if (minorVersion >= 9) {
+            DataWatcherObject.CLASS = getLegacyClass("DataWatcherObject");
+            DataWatcherHelper.DataWatcherRegistry = getLegacyClass("DataWatcherRegistry");
+            DataWatcherHelper.DataWatcherSerializer = getLegacyClass("DataWatcherSerializer");
+            PacketScoreboard.EnumTeamPush = (Class<Enum>) getLegacyClass("ScoreboardTeamBase$EnumTeamPush");
+        }
+    }
+}
@@ -0,0 +1,72 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.nms;
+
+import me.neznamy.tab.platforms.bukkit.BukkitTabList;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherHelper;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherItem;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherObject;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.*;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+
+/**
+ * NMS loader for minecraft 1.17+ using Mojang packaging and bukkit names.
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class BukkitModernNMSStorage extends NMSStorage {
+
+    @Override
+    public void loadClasses() throws ClassNotFoundException {
+        ChatSerializer = Class.forName("net.minecraft.network.chat.IChatBaseComponent$ChatSerializer");
+        World = Class.forName("net.minecraft.world.level.World");
+        EntityArmorStand = Class.forName("net.minecraft.world.entity.decoration.EntityArmorStand");
+        EntityHuman = Class.forName("net.minecraft.world.entity.player.EntityHuman");
+        NetworkManager = Class.forName("net.minecraft.network.NetworkManager");
+        IChatBaseComponent = Class.forName("net.minecraft.network.chat.IChatBaseComponent");
+        Packet = Class.forName("net.minecraft.network.protocol.Packet");
+        EnumChatFormat = (Class<Enum>) Class.forName("net.minecraft.EnumChatFormat");
+        EntityPlayer = Class.forName("net.minecraft.server.level.EntityPlayer");
+        Entity = Class.forName("net.minecraft.world.entity.Entity");
+        EntityLiving = Class.forName("net.minecraft.world.entity.EntityLiving");
+        PlayerConnection = Class.forName("net.minecraft.server.network.PlayerConnection");
+        BukkitTabList.PacketPlayOutPlayerListHeaderFooterClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutPlayerListHeaderFooter");
+        PacketScoreboard.DisplayObjectiveClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardDisplayObjective");
+        PacketScoreboard.ObjectivePacketClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardObjective");
+        PacketScoreboard.Scoreboard = Class.forName("net.minecraft.world.scores.Scoreboard");
+        PacketScoreboard.ScorePacketClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardScore");
+        PacketScoreboard.ScoreboardObjective = Class.forName("net.minecraft.world.scores.ScoreboardObjective");
+        PacketScoreboard.ScoreboardScoreClass = Class.forName("net.minecraft.world.scores.ScoreboardScore");
+        PacketScoreboard.IScoreboardCriteria = Class.forName("net.minecraft.world.scores.criteria.IScoreboardCriteria");
+        PacketScoreboard.EnumScoreboardHealthDisplay = (Class<Enum>) Class.forName("net.minecraft.world.scores.criteria.IScoreboardCriteria$EnumScoreboardHealthDisplay");
+        PacketScoreboard.EnumScoreboardAction = (Class<Enum>) Class.forName("net.minecraft.server.ScoreboardServer$Action");
+        PacketScoreboard.TeamPacketClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardTeam");
+        PacketScoreboard.ScoreboardTeam = Class.forName("net.minecraft.world.scores.ScoreboardTeam");
+        PacketScoreboard.EnumNameTagVisibility = (Class<Enum>) Class.forName("net.minecraft.world.scores.ScoreboardTeamBase$EnumNameTagVisibility");
+        PacketScoreboard.EnumTeamPush = (Class<Enum>) Class.forName("net.minecraft.world.scores.ScoreboardTeamBase$EnumTeamPush");
+        DataWatcher.CLASS = Class.forName("net.minecraft.network.syncher.DataWatcher");
+        DataWatcherItem.CLASS = Class.forName("net.minecraft.network.syncher.DataWatcher$Item");
+        DataWatcherObject.CLASS = Class.forName("net.minecraft.network.syncher.DataWatcherObject");
+        DataWatcherHelper.DataWatcherRegistry = Class.forName("net.minecraft.network.syncher.DataWatcherRegistry");
+        DataWatcherHelper.DataWatcherSerializer = Class.forName("net.minecraft.network.syncher.DataWatcherSerializer");
+        PacketPlayOutEntityTeleportStorage.CLASS = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntityTeleport");
+        PacketPlayOutEntity = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntity");
+        PacketPlayOutEntityDestroyStorage.CLASS = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntityDestroy");
+        PacketPlayOutEntityLook = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntity$PacketPlayOutEntityLook");
+        PacketPlayOutEntityMetadataStorage.CLASS = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntityMetadata");
+        PacketPlayOutNamedEntitySpawn = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutNamedEntitySpawn");
+        BukkitTabList.EnumGamemodeClass = (Class<Enum>) Class.forName("net.minecraft.world.level.EnumGamemode");
+        PacketPlayOutSpawnEntityLivingStorage.Vec3D = Class.forName("net.minecraft.world.phys.Vec3D");
+        PacketPlayOutSpawnEntityLivingStorage.EntityTypes = Class.forName("net.minecraft.world.entity.EntityTypes");
+        PacketPlayOutSpawnEntityLivingStorage.CLASS = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutSpawnEntity");
+        if (is1_19_3Plus()) {
+            BukkitTabList.ClientboundPlayerInfoRemovePacket = Class.forName("net.minecraft.network.protocol.game.ClientboundPlayerInfoRemovePacket");
+            BukkitTabList.PacketPlayOutPlayerInfoClass = Class.forName("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket");
+            BukkitTabList.EnumPlayerInfoActionClass = (Class<Enum>) Class.forName("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket$a");
+            BukkitTabList.PlayerInfoDataClass = Class.forName("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket$b");
+            BukkitTabList.RemoteChatSession$Data = Class.forName("net.minecraft.network.chat.RemoteChatSession$a");
+        } else {
+            BukkitTabList.PacketPlayOutPlayerInfoClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo");
+            BukkitTabList.EnumPlayerInfoActionClass = (Class<Enum>) Class.forName("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo$EnumPlayerInfoAction");
+            BukkitTabList.PlayerInfoDataClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo$PlayerInfoData");
+        }
+    }
+}
@@ -0,0 +1,159 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.nms;
+
+import com.mojang.authlib.GameProfile;
+import io.netty.channel.Channel;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.BukkitTabList;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherHelper;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.util.ComponentCache;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherItem;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherObject;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.*;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/**
+ * Class holding all NMS classes, methods, fields and constructors used by TAB.
+ */
+@SuppressWarnings("rawtypes")
+public abstract class NMSStorage {
+
+    /** Instance of this class */
+    @Getter @Setter private static NMSStorage instance;
+
+    /** Server's NMS/CraftBukkit package */
+    @Getter protected final String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+
+    /** Server's minor version */
+    @Getter protected final int minorVersion = Integer.parseInt(serverPackage.split("_")[1]);
+
+    /** Flag determining whether the server version is at least 1.19.3 or not */
+    @Getter private final boolean is1_19_3Plus = ReflectionUtils.classExists("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket");
+    @Getter private final boolean is1_19_4Plus = is1_19_3Plus && !serverPackage.equals("v1_19_R2");
+
+    /** Basic universal values */
+    protected Class<?> Packet;
+    protected Class<?> NetworkManager;
+    protected Class<?> EntityArmorStand;
+    protected Class<?> World;
+    public Class<Enum> EnumChatFormat;
+    public Class<?> EntityPlayer;
+    protected Class<?> EntityHuman;
+    public Class<?> Entity;
+    public Class<?> EntityLiving;
+    protected Class<?> PlayerConnection;
+
+    // Ping field for 1.5.2 - 1.16.5, 1.17+ has Player#getPing()
+    public Field PING;
+
+    public Field PLAYER_CONNECTION;
+    public Field NETWORK_MANAGER;
+    public Field CHANNEL;
+    public Method getHandle;
+    public Method sendPacket;
+    public Method getProfile;
+
+    /** Chat components */
+    public Class<?> IChatBaseComponent;
+    protected Class<?> ChatSerializer;
+    public Method ChatSerializer_DESERIALIZE;
+
+    /** Other entity packets */
+    public Class<?> PacketPlayOutEntity;
+    public Field PacketPlayOutEntity_ENTITYID;
+
+    public Class<?> PacketPlayOutEntityLook;
+
+    public Class<?> PacketPlayOutNamedEntitySpawn;
+    public Field PacketPlayOutNamedEntitySpawn_ENTITYID;
+
+    public Object dummyEntity;
+
+    private final ComponentCache<IChatBaseComponent, Object> componentCache = new ComponentCache<>(10000,
+            (component, clientVersion) -> ChatSerializer_DESERIALIZE.invoke(null, component.toString(clientVersion)));
+
+    /**
+     * Constructs new instance and attempts to load all fields, methods and constructors.
+     */
+    @SneakyThrows
+    public NMSStorage() {
+        ProtocolVersion.UNKNOWN_SERVER_VERSION.setMinorVersion(minorVersion); //fixing compatibility with forks that set version field value to "Unknown"
+        loadClasses();
+        if (minorVersion >= 7) {
+            NETWORK_MANAGER = ReflectionUtils.getOnlyField(PlayerConnection, NetworkManager);
+            sendPacket = ReflectionUtils.getMethods(PlayerConnection, void.class, Packet).get(0);
+        } else {
+            sendPacket = ReflectionUtils.getMethod(PlayerConnection, new String[]{"sendPacket"}, Packet);
+        }
+        if (minorVersion >= 8) {
+            ChatSerializer_DESERIALIZE = ChatSerializer.getMethod("a", String.class);
+            CHANNEL = ReflectionUtils.getOnlyField(NetworkManager, Channel.class);
+            try {
+                getProfile = ReflectionUtils.getOnlyMethod(EntityHuman, GameProfile.class);
+            } catch (IllegalStateException catServer) {
+                getProfile = EntityHuman.getMethod("getProfile");
+            }
+            Constructor<?> newEntityArmorStand = EntityArmorStand.getConstructor(World, double.class, double.class, double.class);
+            Method World_getHandle = Class.forName("org.bukkit.craftbukkit." + serverPackage + ".CraftWorld").getMethod("getHandle");
+            dummyEntity = newEntityArmorStand.newInstance(World_getHandle.invoke(Bukkit.getWorlds().get(0)), 0, 0, 0);
+            BukkitTabList.load(this);
+        }
+        if (minorVersion >= 9) {
+            DataWatcherObject.load();
+        }
+        PLAYER_CONNECTION = ReflectionUtils.getOnlyField(EntityPlayer, PlayerConnection);
+        getHandle = Class.forName("org.bukkit.craftbukkit." + serverPackage + ".entity.CraftPlayer").getMethod("getHandle");
+        DataWatcher.load(this);
+        DataWatcherItem.load(this);
+        DataWatcherHelper.load(this);
+        PacketPlayOutEntityDestroyStorage.load();
+        PacketPlayOutEntityMetadataStorage.load(this);
+        PacketPlayOutEntityTeleportStorage.load(this);
+        PacketPlayOutSpawnEntityLivingStorage.load(this);
+        PacketScoreboard.load(this);
+        PacketPlayOutEntity_ENTITYID = ReflectionUtils.getFields(PacketPlayOutEntity, int.class).get(0);
+        PacketPlayOutNamedEntitySpawn_ENTITYID = ReflectionUtils.getFields(PacketPlayOutNamedEntitySpawn, int.class).get(0);
+        if (minorVersion < 17) {
+            try {
+                (PING = EntityPlayer.getDeclaredField("ping")).setAccessible(true); // 1.5.2 - 1.16.5
+            } catch (NoSuchFieldException e) {
+                (PING = EntityPlayer.getDeclaredField("field_71138_i")).setAccessible(true); // 1.7.10 Thermos
+            }
+        }
+    }
+
+    /**
+     * Loads all classes used by the plugin
+     *
+     * @throws  ClassNotFoundException
+     *          If a class was not found
+     */
+    public abstract void loadClasses() throws ClassNotFoundException;
+
+    /**
+     * Converts TAB's IChatBaseComponent into minecraft's component using String deserialization.
+     * If the requested component is found in cache, it is returned. If not, it is created, added into cache and returned.
+     * If {@code component} is {@code null}, returns {@code null}
+     *
+     * @param   component
+     *          component to convert
+     * @param   clientVersion
+     *          client version used to decide RGB conversion
+     * @return  converted component or {@code null} if {@code component} is {@code null}
+     */
+    public @Nullable Object toNMSComponent(@NotNull IChatBaseComponent component, @NotNull ProtocolVersion clientVersion) {
+        return componentCache.get(component, clientVersion);
+    }
+}
@@ -0,0 +1,33 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.packet;
+
+import me.neznamy.tab.shared.util.ReflectionUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
+/**
+ * Custom class for holding data used in PacketPlayOutEntityDestroy minecraft packet.
+ */
+public class PacketPlayOutEntityDestroyStorage {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+    public static Field ENTITIES;
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load() throws NoSuchMethodException {
+        ENTITIES = ReflectionUtils.getOnlyField(CLASS);
+        try {
+            CONSTRUCTOR = CLASS.getConstructor(int[].class);
+        } catch (NoSuchMethodException e) {
+            //1.17.0
+            CONSTRUCTOR = CLASS.getConstructor(int.class);
+        }
+    }
+}
@@ -0,0 +1,33 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.packet;
+
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+
+import java.lang.reflect.Constructor;
+import java.util.List;
+
+/**
+ * Custom class for holding data used in PacketPlayOutEntityMetadata minecraft packet.
+ */
+public class PacketPlayOutEntityMetadataStorage {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @param   nms
+     *          NMS storage reference
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load(NMSStorage nms) throws NoSuchMethodException {
+        if (nms.is1_19_3Plus()) {
+            CONSTRUCTOR = CLASS.getConstructor(int.class, List.class);
+        } else {
+            CONSTRUCTOR = CLASS.getConstructor(int.class, DataWatcher.CLASS, boolean.class);
+        }
+    }
+}
@@ -0,0 +1,87 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.packet;
+
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.backend.Location;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
+/**
+ * Custom class for holding data used in PacketPlayOutEntityTeleport minecraft packet.
+ */
+public class PacketPlayOutEntityTeleportStorage {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+    public static Field ENTITY_ID;
+    public static Field X;
+    public static Field Y;
+    public static Field Z;
+    public static Field YAW;
+    public static Field PITCH;
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @param   nms
+     *          NMS storage reference
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load(NMSStorage nms) throws NoSuchMethodException {
+        ENTITY_ID = ReflectionUtils.getFields(CLASS, int.class).get(0);
+        YAW = ReflectionUtils.getFields(CLASS, byte.class).get(0);
+        PITCH = ReflectionUtils.getFields(CLASS, byte.class).get(1);
+        if (nms.getMinorVersion() >= 17) {
+            CONSTRUCTOR = CLASS.getConstructor(nms.Entity);
+        } else {
+            CONSTRUCTOR = CLASS.getConstructor();
+        }
+        if (nms.getMinorVersion() >= 9) {
+            X = ReflectionUtils.getFields(CLASS, double.class).get(0);
+            Y = ReflectionUtils.getFields(CLASS, double.class).get(1);
+            Z = ReflectionUtils.getFields(CLASS, double.class).get(2);
+        } else {
+            X = ReflectionUtils.getFields(CLASS, int.class).get(1);
+            Y = ReflectionUtils.getFields(CLASS, int.class).get(2);
+            Z = ReflectionUtils.getFields(CLASS, int.class).get(3);
+        }
+    }
+
+    /**
+     * Converts this class into NMS packet
+     *
+     * @return  NMS packet
+     */
+    @SneakyThrows
+    public static Object build(int entityId, Location location) {
+        NMSStorage nms = NMSStorage.getInstance();
+        Object nmsPacket;
+        if (nms.getMinorVersion() >= 17) {
+            nmsPacket = CONSTRUCTOR.newInstance(nms.dummyEntity);
+        } else {
+            nmsPacket = CONSTRUCTOR.newInstance();
+        }
+        ENTITY_ID.set(nmsPacket, entityId);
+        if (nms.getMinorVersion() >= 9) {
+            X.set(nmsPacket, location.getX());
+            Y.set(nmsPacket, location.getY());
+            Z.set(nmsPacket, location.getZ());
+        } else {
+            X.set(nmsPacket, floor(location.getX()*32));
+            Y.set(nmsPacket, floor(location.getY()*32));
+            Z.set(nmsPacket, floor(location.getZ()*32));
+        }
+        YAW.set(nmsPacket, (byte) (location.getYaw()/360*256));
+        PITCH.set(nmsPacket, (byte) (location.getPitch()/360*256));
+        return nmsPacket;
+    }
+
+    private static int floor(double paramDouble) {
+        int i = (int)paramDouble;
+        return paramDouble < i ? i - 1 : i;
+    }
+}
@@ -0,0 +1,131 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.packet;
+
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.backend.EntityData;
+import me.neznamy.tab.shared.backend.Location;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.bukkit.entity.EntityType;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.util.EnumMap;
+import java.util.UUID;
+
+/**
+ * Custom class for holding data used in PacketPlayOutSpawnEntityLiving minecraft packet.
+ */
+public class PacketPlayOutSpawnEntityLivingStorage {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+
+    /** 1.17+ */
+    public static Class<?> Vec3D;
+    public static Class<?> EntityTypes;
+    public static Object Vec3D_Empty;
+    public static Object EntityTypes_ARMOR_STAND;
+
+    /** 1.16.5- */
+    public static Field ENTITY_ID;
+    public static Field ENTITY_TYPE;
+    public static Field YAW;
+    public static Field PITCH;
+    public static Field UUID;
+    public static Field X;
+    public static Field Y;
+    public static Field Z;
+    public static Field DATA_WATCHER;
+    public static final EnumMap<EntityType, Integer> entityIds = new EnumMap<>(EntityType.class);
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @param   nms
+     *          NMS storage reference
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load(NMSStorage nms) throws NoSuchMethodException, IllegalAccessException, NoSuchFieldException {
+        int minorVersion = nms.getMinorVersion();
+        if (minorVersion >= 13) {
+            entityIds.put(EntityType.ARMOR_STAND, 1);
+        } else {
+            entityIds.put(EntityType.WITHER, 64);
+            if (minorVersion >= 8) {
+                entityIds.put(EntityType.ARMOR_STAND, 30);
+            }
+        }
+
+        if (minorVersion >= 19) {
+            EntityTypes_ARMOR_STAND = EntityTypes.getDeclaredField("d").get(null);
+            CONSTRUCTOR = CLASS.getConstructor(int.class, UUID.class, double.class, double.class, double.class, float.class, float.class, EntityTypes, int.class, Vec3D, double.class);
+            Vec3D_Empty = ReflectionUtils.getOnlyField(Vec3D, Vec3D).get(null);
+        } else if (minorVersion >= 17) {
+            EntityTypes_ARMOR_STAND = EntityTypes.getDeclaredField("c").get(null);
+            CONSTRUCTOR = CLASS.getConstructor(int.class, UUID.class, double.class, double.class, double.class, float.class, float.class, EntityTypes, int.class, Vec3D);
+            Vec3D_Empty = ReflectionUtils.getOnlyField(Vec3D, Vec3D).get(null);
+        } else {
+            CONSTRUCTOR = CLASS.getConstructor();
+            ENTITY_ID = ReflectionUtils.getFields(CLASS, int.class).get(0);
+            YAW = ReflectionUtils.getFields(CLASS, byte.class).get(0);
+            PITCH = ReflectionUtils.getFields(CLASS, byte.class).get(1);
+            if (minorVersion >= 9) {
+                UUID = ReflectionUtils.getOnlyField(CLASS, UUID.class);
+                X = ReflectionUtils.getFields(CLASS, double.class).get(0);
+                Y = ReflectionUtils.getFields(CLASS, double.class).get(1);
+                Z = ReflectionUtils.getFields(CLASS, double.class).get(2);
+            } else {
+                X = ReflectionUtils.getFields(CLASS, int.class).get(2);
+                Y = ReflectionUtils.getFields(CLASS, int.class).get(3);
+                Z = ReflectionUtils.getFields(CLASS, int.class).get(4);
+            }
+            ENTITY_TYPE = ReflectionUtils.getFields(CLASS, int.class).get(1);
+            if (minorVersion <= 14) {
+                DATA_WATCHER = ReflectionUtils.getOnlyField(CLASS, DataWatcher.CLASS);
+            }
+        }
+    }
+
+    /**
+     * Converts this class into NMS packet
+     *
+     * @return  NMS packet
+     */
+    @SneakyThrows
+    public static Object build(int id, UUID uuid, Object entityType, Location l, EntityData data) {
+        int minorVersion = NMSStorage.getInstance().getMinorVersion();
+        if (minorVersion >= 19) {
+            return CONSTRUCTOR.newInstance(id, uuid, l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch(), EntityTypes_ARMOR_STAND, 0, Vec3D_Empty, 0d);
+        }
+        if (minorVersion >= 17) {
+            return CONSTRUCTOR.newInstance(id, uuid, l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch(), EntityTypes_ARMOR_STAND, 0, Vec3D_Empty);
+        }
+        Object nmsPacket = CONSTRUCTOR.newInstance();
+        ENTITY_ID.set(nmsPacket, id);
+        YAW.set(nmsPacket, (byte)(l.getYaw() * 256.0f / 360.0f));
+        PITCH.set(nmsPacket, (byte)(l.getPitch() * 256.0f / 360.0f));
+        if (minorVersion <= 14) {
+            DATA_WATCHER.set(nmsPacket, data.build());
+        }
+        if (minorVersion >= 9) {
+            UUID.set(nmsPacket, uuid);
+            X.set(nmsPacket, l.getX());
+            Y.set(nmsPacket, l.getY());
+            Z.set(nmsPacket, l.getZ());
+        } else {
+            X.set(nmsPacket, floor(l.getX()*32));
+            Y.set(nmsPacket, floor(l.getY()*32));
+            Z.set(nmsPacket, floor(l.getZ()*32));
+        }
+        ENTITY_TYPE.set(nmsPacket, entityIds.get((EntityType) entityType));
+        return nmsPacket;
+    }
+
+    private static int floor(double paramDouble) {
+        int i = (int)paramDouble;
+        return paramDouble < i ? i - 1 : i;
+    }
+}
@@ -0,0 +1,176 @@
+package me.neznamy.tab.platforms.bukkit.platform;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import lombok.SneakyThrows;
+import me.clip.placeholderapi.PlaceholderAPI;
+import me.neznamy.tab.platforms.bukkit.BukkitPipelineInjector;
+import me.neznamy.tab.platforms.bukkit.BukkitPlaceholderRegistry;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.shared.GroupManager;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.chat.rgb.RGBUtils;
+import me.neznamy.tab.shared.features.injection.PipelineInjector;
+import me.neznamy.tab.shared.features.types.TabFeature;
+import me.neznamy.tab.platforms.bukkit.features.BukkitTabExpansion;
+import me.neznamy.tab.platforms.bukkit.features.PerWorldPlayerList;
+import me.neznamy.tab.platforms.bukkit.features.WitherBossBar;
+import me.neznamy.tab.platforms.bukkit.features.BukkitNameTagX;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.backend.BackendPlatform;
+import me.neznamy.tab.shared.features.PlaceholderManagerImpl;
+import me.neznamy.tab.shared.features.bossbar.BossBarManagerImpl;
+import me.neznamy.tab.shared.features.nametags.NameTag;
+import me.neznamy.tab.shared.hook.LuckPermsHook;
+import me.neznamy.tab.shared.placeholders.PlayerPlaceholderImpl;
+import me.neznamy.tab.shared.placeholders.expansion.EmptyTabExpansion;
+import me.neznamy.tab.shared.placeholders.expansion.TabExpansion;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+
+/**
+ * Implementation of Platform interface for Bukkit platform
+ */
+@RequiredArgsConstructor
+@Getter
+public class BukkitPlatform implements BackendPlatform {
+
+    /** Plugin instance for registering tasks and events */
+    private final JavaPlugin plugin;
+
+    /** Variables checking presence of other plugins to hook into */
+    private final boolean placeholderAPI = ReflectionUtils.classExists("me.clip.placeholderapi.PlaceholderAPI");
+    @Setter private boolean libsDisguisesEnabled = ReflectionUtils.classExists("me.libraryaddict.disguise.DisguiseAPI");
+
+    public @NotNull BossBarManagerImpl getLegacyBossBar() {
+        return new WitherBossBar(plugin);
+    }
+
+    @Override
+    public void loadPlayers() {
+        for (Player p : getOnlinePlayers()) {
+            TAB.getInstance().addPlayer(new BukkitTabPlayer(p));
+        }
+    }
+
+    @Override
+    public void registerPlaceholders() {
+        new BukkitPlaceholderRegistry().registerPlaceholders(TAB.getInstance().getPlaceholderManager());
+    }
+
+    @Override
+    public @Nullable PipelineInjector createPipelineInjector() {
+        return NMSStorage.getInstance().getMinorVersion() >= 8 ? new BukkitPipelineInjector() : null;
+    }
+
+    @Override
+    public @NotNull NameTag getUnlimitedNameTags() {
+        return new BukkitNameTagX(plugin);
+    }
+
+    @Override
+    public @NotNull TabExpansion createTabExpansion() {
+        if (placeholderAPI) {
+            BukkitTabExpansion expansion = new BukkitTabExpansion();
+            expansion.register();
+            return expansion;
+        }
+        return new EmptyTabExpansion();
+    }
+
+    @Override
+    public @Nullable TabFeature getPerWorldPlayerList() {
+        return new PerWorldPlayerList(plugin);
+    }
+
+    /**
+     * Returns online players from Bukkit API
+     *
+     * @return  online players from Bukkit API
+     */
+    @SuppressWarnings("unchecked")
+    @SneakyThrows
+    private @NotNull Player[] getOnlinePlayers() {
+        Object players = Bukkit.class.getMethod("getOnlinePlayers").invoke(null);
+        if (players instanceof Player[]) {
+            //1.7-
+            return (Player[]) players;
+        } else {
+            //1.8+
+            return ((Collection<Player>)players).toArray(new Player[0]);
+        }
+    }
+
+    @Override
+    public void registerUnknownPlaceholder(@NotNull String identifier) {
+        PlaceholderManagerImpl pl = TAB.getInstance().getPlaceholderManager();
+        int refresh = pl.getRefreshInterval(identifier);
+        if (identifier.startsWith("%rel_")) {
+            //relational placeholder
+            TAB.getInstance().getPlaceholderManager().registerRelationalPlaceholder(identifier, pl.getRefreshInterval(identifier), (viewer, target) ->
+                    placeholderAPI ? PlaceholderAPI.setRelationalPlaceholders((Player) viewer.getPlayer(), (Player) target.getPlayer(), identifier) : identifier);
+        } else if (identifier.startsWith("%sync:")) {
+            registerSyncPlaceholder(identifier, refresh);
+        } else if (identifier.startsWith("%server_")) {
+            TAB.getInstance().getPlaceholderManager().registerServerPlaceholder(identifier, refresh, () ->
+                    placeholderAPI ? PlaceholderAPI.setPlaceholders(null, identifier) : identifier);
+        } else {
+            TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder(identifier, refresh, p ->
+                    placeholderAPI ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), identifier) : identifier);
+        }
+    }
+
+    public void registerSyncPlaceholder(String identifier, int refresh) {
+        String syncedPlaceholder = "%" + identifier.substring(6);
+        PlayerPlaceholderImpl[] ppl = new PlayerPlaceholderImpl[1];
+        ppl[0] = TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder(identifier, refresh, p -> {
+            Bukkit.getScheduler().runTask(plugin, () -> {
+                long time = System.nanoTime();
+                ppl[0].updateValue(p, placeholderAPI ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), syncedPlaceholder) : identifier);
+                TAB.getInstance().getCPUManager().addPlaceholderTime(identifier, System.nanoTime()-time);
+            });
+            return null;
+        });
+    }
+
+    @Override
+    public void sendConsoleMessage(@NotNull IChatBaseComponent message) {
+        Bukkit.getConsoleSender().sendMessage("[TAB] " + RGBUtils.getInstance().convertToBukkitFormat(message.toFlatText(),
+                TAB.getInstance().getServerVersion().getMinorVersion() >= 16));
+    }
+
+    @Override
+    public String getServerVersionInfo() {
+        return "[Bukkit] " + Bukkit.getName() + " - " + Bukkit.getBukkitVersion().split("-")[0] + " (" + NMSStorage.getInstance().getServerPackage() + ")";
+    }
+
+    @Override
+    @NotNull public GroupManager detectPermissionPlugin() {
+        if (LuckPermsHook.getInstance().isInstalled()) {
+            return new GroupManager("LuckPerms", LuckPermsHook.getInstance().getGroupFunction());
+        }
+        if (Bukkit.getPluginManager().isPluginEnabled("Vault")) {
+            RegisteredServiceProvider<Permission> provider = Bukkit.getServicesManager().getRegistration(Permission.class);
+            if (provider != null && !provider.getProvider().getName().equals("SuperPerms")) {
+                return new GroupManager(provider.getProvider().getName(), p -> provider.getProvider().getPrimaryGroup((Player) p.getPlayer()));
+            }
+        }
+        return new GroupManager("None", p -> TabConstants.NO_GROUP);
+    }
+
+    public void runEntityTask(Entity entity, Runnable task) {
+        task.run();
+    }
+}
@@ -0,0 +1,88 @@
+package me.neznamy.tab.platforms.bukkit.platform;
+
+import lombok.SneakyThrows;
+import me.clip.placeholderapi.PlaceholderAPI;
+import me.neznamy.tab.platforms.bukkit.features.PerWorldPlayerList;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.placeholders.PlayerPlaceholderImpl;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.function.Consumer;
+
+/**
+ * Platform override for Folia
+ */
+public class FoliaPlatform extends BukkitPlatform {
+
+    public FoliaPlatform(JavaPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public void loadPlayers() {
+        super.loadPlayers();
+
+        // Values are never updated in the API, warn users
+        TAB.getInstance().sendConsoleMessage("&cFolia never updates MSPT and TPS values in the API, making " +
+                "%mspt% and %tps% return the default values (0 and 20).", true);
+
+        // Folia never calls PlayerChangedWorldEvent, this is a workaround
+        TAB.getInstance().getCPUManager().startRepeatingMeasuredTask(100, "Folia compatibility", "Refreshing world", () -> {
+            for (TabPlayer player : TAB.getInstance().getOnlinePlayers()) {
+                String bukkitWorld = ((Player)player.getPlayer()).getWorld().getName();
+                if (!player.getWorld().equals(bukkitWorld)) {
+                    TAB.getInstance().getFeatureManager().onWorldChange(player.getUniqueId(), bukkitWorld);
+                    PerWorldPlayerList pwp = TAB.getInstance().getFeatureManager().getFeature(TabConstants.Feature.PER_WORLD_PLAYER_LIST);
+                    if (pwp != null) {
+                        runSync((Entity) player.getPlayer(), () -> pwp.onWorldChange(new PlayerChangedWorldEvent((Player) player.getPlayer(), ((Player) player.getPlayer()).getWorld())));
+                    }
+                }
+            }
+        });
+    }
+
+    @Override
+    public void registerSyncPlaceholder(String identifier, int refresh) {
+        String syncedPlaceholder = "%" + identifier.substring(6);
+        PlayerPlaceholderImpl[] ppl = new PlayerPlaceholderImpl[1];
+        ppl[0] = TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder(identifier, refresh, p -> {
+            runSync((Entity) p.getPlayer(), () -> {
+                long time = System.nanoTime();
+                String output = isPlaceholderAPI() ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), syncedPlaceholder) : identifier;
+                TAB.getInstance().getCPUManager().addPlaceholderTime(identifier, System.nanoTime()-time);
+                TAB.getInstance().getCPUManager().runTask(() -> ppl[0].updateValue(p, output)); // To ensure player is loaded
+            });
+            return null;
+        });
+    }
+
+    /**
+     * Runs task using player's entity scheduler. It's using reflection, because
+     * Folia uses Java 17 while TAB maintains Java 8 compatibility for compatibility
+     * with MC versions older than their player base.
+     *
+     * @param   entity
+     *          entity to run task for
+     * @param   task
+     *          Task to run
+     */
+    @SneakyThrows
+    @SuppressWarnings("JavaReflectionMemberAccess")
+    private void runSync(Entity entity, Runnable task) {
+        Object entityScheduler = Entity.class.getMethod("getScheduler").invoke(entity);
+        Consumer<?> consumer = $ -> task.run(); // Reflection and lambdas don't go together
+        entityScheduler.getClass().getMethod("run", Plugin.class, Consumer.class, Runnable.class)
+                .invoke(entityScheduler, getPlugin(), consumer, null);
+    }
+
+    @Override
+    public void runEntityTask(Entity entity, Runnable task) {
+        runSync(entity, task);
+    }
+}
@@ -0,0 +1,312 @@
+package me.neznamy.tab.platforms.bukkit.scoreboard;
+
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.Scoreboard;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Scoreboard implementation for Bukkit, which uses packets
+ * to send scoreboards. While md_5 keeps saying that you don't
+ * need packets for scoreboards in every single spigot update,
+ * this is not true. It may seem that way at first, but after
+ * investigating, fatal problems are found:<p>
+ * #1 - Limitations on legacy versions are forced in the API.
+ *      While this may not seem like a problem, it enforces those
+ *      limits even for 1.13+ players (if using ViaVersion).<p>
+ * #2 - Modern versions no longer have any limits, but md_5
+ *      decided to add some random limits for absolutely no reason
+ *      at all. Scoreboard title received a random 128 characters
+ *      limit including color codes. Together with the almighty bukkit
+ *      RGB format using 14 characters for 1 color code, this makes
+ *      gradients just impossible to use. Team prefix/suffix also
+ *      received a 64 characters limit (excluding color codes at least),
+ *      however that might not be enough for displaying a line of text
+ *      in sidebar, which would require splitting the text into prefix
+ *      and suffix, which is just begging for bugs to be introduced.<p>
+ * #3 - Other plugins can decide to put players into their own
+ *      scoreboard, automatically destroying all visuals made by the
+ *      plugin. They might also put all players into the same scoreboard,
+ *      making per-player view of teams, especially sidebar not working.<p>
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class PacketScoreboard extends Scoreboard<BukkitTabPlayer> {
+
+    private static NMSStorage nms;
+
+    public static Class<?> Scoreboard;
+    public static Class<?> IScoreboardCriteria;
+    private static Object emptyScoreboard;
+    private static Field IScoreboardCriteria_self;
+
+    // PacketPlayOutScoreboardDisplayObjective
+    public static Class<?> DisplayObjectiveClass;
+    private static Constructor<?> newDisplayObjective;
+    public static Field DisplayObjective_POSITION;
+    public static Field DisplayObjective_OBJECTIVE_NAME;
+
+    // PacketPlayOutScoreboardScore
+    public static Class<?> ScorePacketClass;
+    public static Class<?> ScoreboardScoreClass;
+    public static Class<Enum> EnumScoreboardAction;
+    private static Constructor<?> newScorePacket_1_13;
+    private static Constructor<?> newScorePacket_String;
+    private static Constructor<?> newScorePacket;
+    private static Constructor<?> newScoreboardScore;
+    public static Method ScoreboardScore_setScore;
+
+    // PacketPlayOutScoreboardObjective
+    public static Class<?> ObjectivePacketClass;
+    private static Constructor<?> newObjectivePacket;
+    public static Field Objective_OBJECTIVE_NAME;
+    public static Field Objective_METHOD;
+    private static Field Objective_RENDER_TYPE;
+    private static Field Objective_DISPLAY_NAME;
+    public static Class<Enum> EnumScoreboardHealthDisplay;
+    public static Class<?> ScoreboardObjective;
+    private static Constructor<?> newScoreboardObjective;
+
+    // PacketPlayOutScoreboardTeamStorage
+    public static Class<?> TeamPacketClass;
+    private static Constructor<?> newTeamPacket;
+    private static Method TeamPacketConstructor_of;
+    private static Method TeamPacketConstructor_ofBoolean;
+    public static Field TeamPacket_NAME;
+    public static Field TeamPacket_ACTION;
+    public static Field TeamPacket_PLAYERS;
+    public static Class<Enum> EnumNameTagVisibility;
+    public static Class<Enum> EnumTeamPush;
+    public static Class<?> ScoreboardTeam;
+    private static Constructor<?> newScoreboardTeam;
+    private static Method ScoreboardTeam_getPlayerNameSet;
+    public static Method ScoreboardTeam_setNameTagVisibility;
+    private static Method ScoreboardTeam_setCollisionRule;
+    public static Method ScoreboardTeam_setPrefix;
+    public static Method ScoreboardTeam_setSuffix;
+    private static Method ScoreboardTeam_setColor;
+    public static Method ScoreboardTeam_setAllowFriendlyFire;
+    public static Method ScoreboardTeam_setCanSeeFriendlyInvisibles;
+
+    public static void load(NMSStorage nms) throws ReflectiveOperationException {
+        PacketScoreboard.nms = nms;
+        emptyScoreboard = Scoreboard.getConstructor().newInstance();
+        IScoreboardCriteria_self = ReflectionUtils.getFields(IScoreboardCriteria, IScoreboardCriteria).get(0);
+        newDisplayObjective = DisplayObjectiveClass.getConstructor(int.class, ScoreboardObjective);
+        DisplayObjective_POSITION = ReflectionUtils.getOnlyField(DisplayObjectiveClass, int.class);
+        DisplayObjective_OBJECTIVE_NAME = ReflectionUtils.getOnlyField(DisplayObjectiveClass, String.class);
+        newScoreboardObjective = ReflectionUtils.getOnlyConstructor(ScoreboardObjective);
+        Objective_OBJECTIVE_NAME = ReflectionUtils.getFields(ObjectivePacketClass, String.class).get(0);
+        List<Field> list = ReflectionUtils.getFields(ObjectivePacketClass, int.class);
+        Objective_METHOD = list.get(list.size()-1);
+        newScoreboardScore = ScoreboardScoreClass.getConstructor(Scoreboard, ScoreboardObjective, String.class);
+        newScoreboardTeam = ScoreboardTeam.getConstructor(Scoreboard, String.class);
+        TeamPacket_NAME = ReflectionUtils.getFields(TeamPacketClass, String.class).get(0);
+        TeamPacket_ACTION = ReflectionUtils.getInstanceFields(TeamPacketClass, int.class).get(0);
+        TeamPacket_PLAYERS = ReflectionUtils.getOnlyField(TeamPacketClass, Collection.class);
+        ScoreboardTeam_getPlayerNameSet = ReflectionUtils.getOnlyMethod(ScoreboardTeam, Collection.class);
+        ScoreboardScore_setScore = ReflectionUtils.getMethod(ScoreboardScoreClass, new String[] {"func_96647_c", "setScore", "b", "c"}, int.class); // {Thermos, 1.5.1 - 1.17.1, 1.18+, 1.5}
+        ScoreboardTeam_setAllowFriendlyFire = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"func_96660_a", "setAllowFriendlyFire", "a"}, boolean.class); // {Thermos, 1.5.1+, 1.5 & 1.18+}
+        ScoreboardTeam_setCanSeeFriendlyInvisibles = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"func_98300_b", "setCanSeeFriendlyInvisibles", "b"}, boolean.class); // {Thermos, 1.5.1+, 1.5 & 1.18+}
+        if (nms.getMinorVersion() >= 13) {
+            newScorePacket_1_13 = ScorePacketClass.getConstructor(EnumScoreboardAction, String.class, String.class, int.class);
+            newObjectivePacket = ObjectivePacketClass.getConstructor(ScoreboardObjective, int.class);
+            Objective_DISPLAY_NAME = ReflectionUtils.getOnlyField(ObjectivePacketClass, nms.IChatBaseComponent);
+            ScoreboardTeam_setColor = ReflectionUtils.getOnlyMethod(ScoreboardTeam, void.class, nms.EnumChatFormat);
+            ScoreboardTeam_setPrefix = ReflectionUtils.getMethod(ScoreboardTeam, new String[]{"setPrefix", "b"}, nms.IChatBaseComponent); // {1.17.1-, 1.18+}
+            ScoreboardTeam_setSuffix = ReflectionUtils.getMethod(ScoreboardTeam, new String[]{"setSuffix", "c"}, nms.IChatBaseComponent); // {1.17.1-, 1.18+}
+        } else {
+            newScorePacket_String = ScorePacketClass.getConstructor(String.class);
+            newObjectivePacket = ObjectivePacketClass.getConstructor();
+            Objective_DISPLAY_NAME = ReflectionUtils.getFields(ObjectivePacketClass, String.class).get(1);
+            ScoreboardTeam_setPrefix = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"func_96666_b", "setPrefix", "b"}, String.class); // {Thermos, 1.5.1+, 1.5}
+            ScoreboardTeam_setSuffix = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"func_96662_c", "setSuffix", "c"}, String.class); // {Thermos, 1.5.1+, 1.5}
+            if (nms.getMinorVersion() >= 8) {
+                newScorePacket = ScorePacketClass.getConstructor(ScoreboardScoreClass);
+                Objective_RENDER_TYPE = ReflectionUtils.getOnlyField(ObjectivePacketClass, EnumScoreboardHealthDisplay);
+            } else {
+                newScorePacket = ScorePacketClass.getConstructor(ScoreboardScoreClass, int.class);
+            }
+        }
+        if (nms.getMinorVersion() >= 8) {
+            ScoreboardTeam_setNameTagVisibility = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"setNameTagVisibility", "a"}, EnumNameTagVisibility); // {1.8.1+, 1.8 & 1.18+}
+        }
+        if (nms.getMinorVersion() >= 9) {
+            ScoreboardTeam_setCollisionRule = ReflectionUtils.getOnlyMethod(ScoreboardTeam, void.class, EnumTeamPush);
+        }
+        if (nms.getMinorVersion() >= 17) {
+            TeamPacketConstructor_of = ReflectionUtils.getOnlyMethod(TeamPacketClass, TeamPacketClass, ScoreboardTeam);
+            TeamPacketConstructor_ofBoolean = ReflectionUtils.getOnlyMethod(TeamPacketClass, TeamPacketClass, ScoreboardTeam, boolean.class);
+        } else {
+            newTeamPacket = TeamPacketClass.getConstructor(ScoreboardTeam, int.class);
+        }
+    }
+
+    public PacketScoreboard(BukkitTabPlayer player) {
+        super(player);
+    }
+
+    @Override
+    @SneakyThrows
+    public void setDisplaySlot(@NotNull DisplaySlot slot, @NotNull String objective) {
+        player.sendPacket(newDisplayObjective.newInstance(slot.ordinal(), newScoreboardObjective(objective)));
+    }
+
+    @Override
+    @SneakyThrows
+    public void registerObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        player.sendPacket(buildObjective(0, objectiveName, title, hearts));
+    }
+
+    @Override
+    public void unregisterObjective0(@NotNull String objectiveName) {
+        player.sendPacket(buildObjective(1, objectiveName, "", false));
+    }
+
+    @Override
+    public void updateObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        player.sendPacket(buildObjective(2, objectiveName, title, hearts));
+    }
+
+    @SneakyThrows
+    private Object buildObjective(int action, String objectiveName, String title, boolean hearts) {
+        if (nms.getMinorVersion() >= 13) {
+            return newObjectivePacket.newInstance(
+                    newScoreboardObjective.newInstance(null, objectiveName, null,
+                    nms.toNMSComponent(IChatBaseComponent.optimizedComponent(title), player.getVersion()),
+                    asDisplayType(hearts)),
+                    action
+            );
+        }
+        Object nmsPacket = newObjectivePacket.newInstance();
+        Objective_OBJECTIVE_NAME.set(nmsPacket, objectiveName);
+        Objective_DISPLAY_NAME.set(nmsPacket, title);
+        if (nms.getMinorVersion() >= 8) {
+            Objective_RENDER_TYPE.set(nmsPacket, asDisplayType(hearts));
+        }
+        Objective_METHOD.set(nmsPacket, action);
+        return nmsPacket;
+    }
+
+    private Object asDisplayType(boolean hearts) {
+        return Enum.valueOf(EnumScoreboardHealthDisplay, hearts ? "HEARTS" : "INTEGER");
+    }
+
+    @Override
+    @SneakyThrows
+    public void registerTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix,
+                              @NotNull NameVisibility visibility, @NotNull CollisionRule collision,
+                              @NotNull Collection<String> players, int options) {
+        Object team = createTeam(name, prefix, suffix, visibility, collision, options);
+        ((Collection<String>)ScoreboardTeam_getPlayerNameSet.invoke(team)).addAll(players);
+        if (nms.getMinorVersion() >= 17) {
+            player.sendPacket(TeamPacketConstructor_ofBoolean.invoke(null, team, true));
+        } else {
+            player.sendPacket(newTeamPacket.newInstance(team, 0));
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public void unregisterTeam0(@NotNull String name) {
+        Object team = newScoreboardTeam.newInstance(emptyScoreboard, name);
+        if (nms.getMinorVersion() >= 17) {
+            player.sendPacket(TeamPacketConstructor_of.invoke(null, team));
+        } else {
+            player.sendPacket(newTeamPacket.newInstance(team, 1));
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public void updateTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix,
+                            @NotNull NameVisibility visibility, @NotNull CollisionRule collision, int options) {
+        Object team = createTeam(name, prefix, suffix, visibility, collision, options);
+        if (nms.getMinorVersion() >= 17) {
+            player.sendPacket(TeamPacketConstructor_ofBoolean.invoke(null, team, false));
+        } else {
+            player.sendPacket(newTeamPacket.newInstance(team, 2));
+        }
+    }
+
+    @SneakyThrows
+    private Object createTeam(String teamName, String prefix, String suffix, NameVisibility visibility, CollisionRule collision, int options) {
+        Object team = newScoreboardTeam.newInstance(emptyScoreboard, teamName);
+        ScoreboardTeam_setAllowFriendlyFire.invoke(team, (options & 0x1) > 0);
+        ScoreboardTeam_setCanSeeFriendlyInvisibles.invoke(team, (options & 0x2) > 0);
+        if (nms.getMinorVersion() >= 13) {
+            ScoreboardTeam_setPrefix.invoke(team, nms.toNMSComponent(IChatBaseComponent.optimizedComponent(prefix), player.getVersion()));
+            ScoreboardTeam_setSuffix.invoke(team, nms.toNMSComponent(IChatBaseComponent.optimizedComponent(suffix), player.getVersion()));
+            ScoreboardTeam_setColor.invoke(team, Enum.valueOf(nms.EnumChatFormat, EnumChatFormat.lastColorsOf(prefix).toString()));
+        } else {
+            ScoreboardTeam_setPrefix.invoke(team, prefix);
+            ScoreboardTeam_setSuffix.invoke(team, suffix);
+        }
+        if (nms.getMinorVersion() >= 8) ScoreboardTeam_setNameTagVisibility.invoke(team, Enum.valueOf(EnumNameTagVisibility, visibility.name()));
+        if (nms.getMinorVersion() >= 9) ScoreboardTeam_setCollisionRule.invoke(team, Enum.valueOf(EnumTeamPush, collision.name()));
+        return team;
+    }
+
+    @Override
+    @SneakyThrows
+    public void setScore0(@NotNull String objective, @NotNull String playerName, int score) {
+        Object packet;
+        if (nms.getMinorVersion() >= 13) {
+            packet = newScorePacket_1_13.newInstance(Enum.valueOf(EnumScoreboardAction, "CHANGE"), objective, playerName, score);
+        } else {
+            Object scoreboardScore = newScoreboardScore.newInstance(emptyScoreboard, newScoreboardObjective(objective), playerName);
+            ScoreboardScore_setScore.invoke(scoreboardScore, score);
+            if (nms.getMinorVersion() >= 8) {
+                packet = newScorePacket.newInstance(scoreboardScore);
+            } else {
+                packet = newScorePacket.newInstance(scoreboardScore, 0);
+            }
+        }
+        player.sendPacket(packet);
+    }
+
+    @Override
+    @SneakyThrows
+    public void removeScore0(@NotNull String objective, @NotNull String playerName) {
+        if (nms.getMinorVersion() >= 13) {
+            player.sendPacket(newScorePacket_1_13.newInstance(Enum.valueOf(EnumScoreboardAction, "REMOVE"), objective, playerName, 0));
+        } else {
+            player.sendPacket(newScorePacket_String.newInstance(playerName));
+        }
+    }
+
+    /**
+     * Creates a new Scoreboard Objective with given name.
+     *
+     * @param   objectiveName
+     *          Objective name
+     * @return  NMS Objective
+     */
+    @SneakyThrows
+    public Object newScoreboardObjective(@NotNull String objectiveName) {
+        if (nms.getMinorVersion() >= 13) {
+            return newScoreboardObjective.newInstance(
+                    null,
+                    objectiveName,
+                    null,
+                    nms.toNMSComponent(new IChatBaseComponent(""), TAB.getInstance().getServerVersion()),
+                    null
+            );
+        }
+        return newScoreboardObjective.newInstance(
+                null,
+                objectiveName,
+                IScoreboardCriteria_self.get(null)
+        );
+    }
+}
@@ -0,0 +1,147 @@
+package me.neznamy.tab.platforms.bukkit.scoreboard;
+
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.Scoreboard;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.scoreboard.Objective;
+import org.bukkit.scoreboard.RenderType;
+import org.bukkit.scoreboard.Team;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+
+/**
+ * Scoreboard handler using Paper API, which got added
+ * in early 1.16.5 builds. Unlike the Bukkit API, the new
+ * methods using adventure components do not have any
+ * pointless artificial limits added in.
+ * <p>
+ * However, it still inherits the issue with compatibility
+ * with other plugins that create scoreboards.
+ * <p>
+ * Currently, this class is never used. In the future, it might
+ * be used as a fallback solution for unsupported versions if NMS
+ * changes and fields fail to load. Or as a complete replacement
+ * if compatibility with other plugins turns out not to be a problem.
+ */
+// Throw the NPE if something is not as expected, parent class should ensure it anyway
+// Use Bukkit setColor, the adventure one does not support magic codes while they are permitted
+@SuppressWarnings({"ConstantConditions", "deprecation"})
+public class PaperScoreboard extends Scoreboard<BukkitTabPlayer> {
+
+    private final org.bukkit.scoreboard.Scoreboard scoreboard = Bukkit.getScoreboardManager().getNewScoreboard();
+
+    public PaperScoreboard(BukkitTabPlayer player) {
+        super(player);
+
+        // Put player into a different scoreboard for per-player view
+        player.getPlayer().setScoreboard(scoreboard);
+    }
+
+    @Override
+    public void setDisplaySlot(@NotNull DisplaySlot slot, @NotNull String objective) {
+        checkPlayerScoreboard();
+        scoreboard.getObjective(objective).setDisplaySlot(org.bukkit.scoreboard.DisplaySlot.valueOf(slot.name()));
+    }
+
+    @Override
+    public void setScore0(@NotNull String objective, @NotNull String playerName, int score) {
+        checkPlayerScoreboard();
+        scoreboard.getObjective(objective).getScore(playerName).setScore(score);
+    }
+
+    @Override
+    public void removeScore0(@NotNull String objective, @NotNull String playerName) {
+        checkPlayerScoreboard();
+        scoreboard.resetScores(playerName);
+    }
+
+    @Override
+    public void registerObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        checkPlayerScoreboard();
+        scoreboard.registerNewObjective(objectiveName, "dummy", toAdventure(title), hearts ? RenderType.HEARTS : RenderType.INTEGER);
+    }
+
+    @Override
+    public void unregisterObjective0(@NotNull String objectiveName) {
+        checkPlayerScoreboard();
+        scoreboard.getObjective(objectiveName).unregister();
+    }
+
+    @Override
+    public void updateObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        checkPlayerScoreboard();
+        Objective obj = scoreboard.getObjective(objectiveName);
+        obj.setRenderType(hearts ? RenderType.HEARTS : RenderType.INTEGER);
+        obj.displayName(toAdventure(title));
+    }
+
+    @Override
+    public void registerTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix,
+                              @NotNull NameVisibility visibility, @NotNull CollisionRule collision,
+                              @NotNull Collection<String> players, int options) {
+        checkPlayerScoreboard();
+        Team team = scoreboard.registerNewTeam(name);
+        team.prefix(toAdventure(prefix));
+        team.suffix(toAdventure(suffix));
+        team.setColor(ChatColor.valueOf(EnumChatFormat.lastColorsOf(prefix).name()));
+        team.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.values()[visibility.ordinal()]);
+        team.setOption(Team.Option.COLLISION_RULE, Team.OptionStatus.values()[collision.ordinal()]);
+        players.forEach(team::addEntry);
+        team.setAllowFriendlyFire((options & 0x01) != 0);
+        team.setCanSeeFriendlyInvisibles((options & 0x02) != 0);
+    }
+
+    @Override
+    public void unregisterTeam0(@NotNull String name) {
+        checkPlayerScoreboard();
+        scoreboard.getTeam(name).unregister();
+    }
+
+    @Override
+    public void updateTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix,
+                            @NotNull NameVisibility visibility, @NotNull CollisionRule collision, int options) {
+        checkPlayerScoreboard();
+        Team team = scoreboard.getTeam(name);
+        team.prefix(toAdventure(prefix));
+        team.suffix(toAdventure(suffix));
+        team.setColor(ChatColor.valueOf(EnumChatFormat.lastColorsOf(prefix).name()));
+        team.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.values()[visibility.ordinal()]);
+        team.setOption(Team.Option.COLLISION_RULE, Team.OptionStatus.values()[collision.ordinal()]);
+        team.setAllowFriendlyFire((options & 0x01) != 0);
+        team.setCanSeeFriendlyInvisibles((options & 0x02) != 0);
+    }
+
+    /**
+     * Converts raw text into adventure component
+     *
+     * @param   text
+     *          Text to convert
+     * @return  Converted component
+     */
+    private @NotNull Component toAdventure(@NotNull String text) {
+        return IChatBaseComponent.optimizedComponent(text).toAdventureComponent(player.getVersion());
+    }
+
+    /**
+     * Makes sure player is in the correct scoreboard.
+     * If not, puts the player into correct scoreboard and prints
+     * a warning.
+     * The only possible reason for this to happen is another plugin
+     * putting a player into a different scoreboard.
+     * Sadly there is no efficient solution to this, which md_5 fails
+     * to understand and keeps saying you don't need packets for scoreboards.
+     */
+    private void checkPlayerScoreboard() {
+        if (player.getPlayer().getScoreboard() != scoreboard) {
+            player.getPlayer().setScoreboard(scoreboard);
+            TAB.getInstance().getErrorManager().printError("Player " + player.getName() + " was in a different scoreboard " +
+                    "than expected. This means another plugin changed player's scoreboard.");
+        }
+    }
+}
@@ -0,0 +1,111 @@
+main: me.neznamy.tab.platforms.bukkit.BukkitTAB
+name: @name@
+version: @version@
+description: @description@
+api-version: 1.13 # Defining to avoid legacy plugin warn
+load: POSTWORLD
+author: @author@
+website: "@website@"
+depend: []
+softdepend: [PlaceholderAPI, LuckPerms, LibsDisguises, ViaVersion, ViaRewind, floodgate]
+loadbefore: []
+prefix: TAB
+libraries: []
+folia-supported: true
+commands:
+  tab:
+    description: Plugin's main command
+permissions:
+  tab.admin:
+    description: Grants all TAB permissions
+    default: op
+  tab.tabcomplete:
+    description: Allows player to complete all TAB commands
+    default: op
+  tab.reload:
+    description: Allows player to run /tab reload
+    default: op
+  tab.cpu:
+    description: Allows player to run /tab cpu
+    default: op
+  tab.debug:
+    description: Allows player to run /tab debug [player]
+    default: op
+  tab.groupinfo:
+    description: Allows player to run /tab group <group>
+    default: op
+  tab.grouplist:
+    description: Allows player to run /tab groups
+    default: op
+  tab.parse:
+    description: Allows player to run /tab parse <player> <placeholder>
+    default: op
+  tab.setcollision:
+    description: Allows player to run /tab setcollision <player> <true/false>
+    default: op
+  tab.remove:
+    description: Allows player to remove group/user using commands
+    default: op
+  tab.change.*:
+    description: Allows player to change property using command
+    default: op
+  tab.width:
+    description: Allows player to run /tab width
+    default: op
+  tab.announce.bar:
+    description: Allows player to run /tab announce bar
+    default: op
+  tab.bossbar.toggle:
+    description: Allows player to run /tab bossbar
+    default: op
+  tab.send.bar:
+    description: Allows player to run /tab bossbar send
+    default: op
+  tab.mysql.download:
+    description: Allows player to run /tab mysql download
+    default: op
+  tab.mysql.upload:
+    description: Allows player to run /tab mysql upload
+    default: op
+  tab.nametag.toggle:
+    description: Allows player to run /tab nametag toggle
+    default: op
+  tab.nametag.toggle.other:
+    description: Allows player to run /tab nametag toggle [other player]
+    default: op
+  tab.nametag.preview:
+    description: Allows player to run /tab nametag preview
+    default: op
+  tab.nametag.preview.other:
+    description: Allows player to run /tab nametag preview [other player]
+    default: op
+  tab.announce.scoreboard:
+    description: Allows player to run /tab scoreboard announce
+    default: op
+  tab.scoreboard.toggle:
+    description: Allows player to run /tab scoreboard
+    default: op
+  tab.scoreboard.toggle.other:
+    description: Allows player to run /tab scoreboard for other players
+    default: op
+  tab.scoreboard.show:
+    description: Allows player to run /tab scoreboard show
+    default: op
+  tab.scoreboard.show.other:
+    description: Allows player to run /tab scoreboard show for other players
+    default: op
+  tab.staff:
+    description: Makes player counted in %staffonline% placeholder
+    default: op
+  tab.group.*:
+    description: Considers player in group if assigning by permissions
+    default: op
+  tab.bypass:
+    description: Makes player bypass per world playerlist if bypass permission is enabled
+    default: op
+  tab.seevanished:
+    description: Marks player as able to see vanished players for features hooking into vanish plugins
+    default: op
+  tab.spectatorbypass:
+    description: Makes player bypass spectator fix
+    default: op
@@ -0,0 +1,7 @@
+dependencies {
+    implementation(projects.shared)
+    implementation("org.bstats:bstats-bungeecord:3.0.1")
+    compileOnly("net.md-5:bungeecord-proxy:1.20-R0.1-SNAPSHOT")
+    compileOnly("com.github.limework.redisbungee:RedisBungee-Bungee:0.11.0")
+    compileOnly("com.github.LeonMangler:PremiumVanishAPI:2.8.8")
+}
@@ -0,0 +1,94 @@
+package me.neznamy.tab.platforms.bungeecord;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * BossBar handler for BungeeCord. It uses packets, since
+ * BungeeCord does not have a BossBar API. Only supports
+ * 1.9+ players, as dealing with entities would be simply impossible.
+ */
+@RequiredArgsConstructor
+public class BungeeBossBar implements BossBar {
+    
+    private final @NotNull BungeeTabPlayer player;
+
+    /** Both are included in the same action, need to remember and write them both */
+    private final Map<UUID, Integer> colors = new HashMap<>();
+    private final Map<UUID, Integer> styles = new HashMap<>();
+
+    @Override
+    public void create(@NotNull UUID id, @NotNull String title, float progress, @NotNull BarColor color, @NotNull BarStyle style) {
+        if (player.getVersion().getMinorVersion() < 9) return;
+
+        net.md_5.bungee.protocol.packet.BossBar packet = new net.md_5.bungee.protocol.packet.BossBar(id, 0);
+        packet.setHealth(progress);
+        packet.setTitle(IChatBaseComponent.optimizedComponent(title).toString(player.getVersion()));
+        packet.setColor(color.ordinal());
+        packet.setDivision(style.ordinal());
+        player.getPlayer().unsafe().sendPacket(packet);
+
+        colors.put(id, color.ordinal());
+        styles.put(id, style.ordinal());
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull String title) {
+        if (player.getVersion().getMinorVersion() < 9) return;
+
+        net.md_5.bungee.protocol.packet.BossBar packet = new net.md_5.bungee.protocol.packet.BossBar(id, 3);
+        packet.setTitle(IChatBaseComponent.optimizedComponent(title).toString(player.getVersion()));
+        player.getPlayer().unsafe().sendPacket(packet);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, float progress) {
+        if (player.getVersion().getMinorVersion() < 9) return;
+
+        net.md_5.bungee.protocol.packet.BossBar packet = new net.md_5.bungee.protocol.packet.BossBar(id, 2);
+        packet.setHealth(progress);
+        player.getPlayer().unsafe().sendPacket(packet);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarStyle style) {
+        if (player.getVersion().getMinorVersion() < 9) return;
+
+        net.md_5.bungee.protocol.packet.BossBar packet = new net.md_5.bungee.protocol.packet.BossBar(id, 4);
+        packet.setDivision(style.ordinal());
+        packet.setColor(colors.get(id));
+        player.getPlayer().unsafe().sendPacket(packet);
+
+        styles.put(id, style.ordinal());
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarColor color) {
+        if (player.getVersion().getMinorVersion() < 9) return;
+
+        net.md_5.bungee.protocol.packet.BossBar packet = new net.md_5.bungee.protocol.packet.BossBar(id, 4);
+        packet.setDivision(styles.get(id));
+        packet.setColor(color.ordinal());
+        player.getPlayer().unsafe().sendPacket(packet);
+
+        colors.put(id, color.ordinal());
+    }
+
+    @Override
+    public void remove(@NotNull UUID id) {
+        if (player.getVersion().getMinorVersion() < 9) return;
+
+        player.getPlayer().unsafe().sendPacket(new net.md_5.bungee.protocol.packet.BossBar(id, 1));
+
+        colors.remove(id);
+        styles.remove(id);
+    }
+}
@@ -0,0 +1,49 @@
+package me.neznamy.tab.platforms.bungeecord;
+
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.platform.EventListener;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.event.ChatEvent;
+import net.md_5.bungee.api.event.PlayerDisconnectEvent;
+import net.md_5.bungee.api.event.PluginMessageEvent;
+import net.md_5.bungee.api.event.ServerSwitchEvent;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.event.EventHandler;
+
+/**
+ * The core for BungeeCord forwarding events into all enabled features
+ */
+public class BungeeEventListener extends EventListener<ProxiedPlayer> implements Listener {
+
+    @EventHandler
+    public void onQuit(PlayerDisconnectEvent e) {
+        quit(e.getPlayer().getUniqueId());
+    }
+
+    @EventHandler
+    public void onSwitch(ServerSwitchEvent e) {
+        serverChange(e.getPlayer(), e.getPlayer().getUniqueId(), e.getPlayer().getServer().getInfo().getName());
+    }
+
+    @EventHandler
+    public void onChat(ChatEvent e) {
+        if (e.isCommand() && command(((ProxiedPlayer)e.getSender()).getUniqueId(), e.getMessage())) {
+            e.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void on(PluginMessageEvent event) {
+        if (!event.getTag().equals(TabConstants.PLUGIN_MESSAGE_CHANNEL_NAME)) return;
+        if (event.getReceiver() instanceof ProxiedPlayer) {
+            event.setCancelled(true);
+            pluginMessage(((ProxiedPlayer) event.getReceiver()).getUniqueId(), event.getData());
+        }
+    }
+
+    @Override
+    public TabPlayer createPlayer(ProxiedPlayer player) {
+        return new BungeeTabPlayer(player);
+    }
+}
@@ -0,0 +1,215 @@
+package me.neznamy.tab.platforms.bungeecord;
+
+import com.google.common.collect.Lists;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import java.lang.reflect.Field;
+
+import me.neznamy.tab.shared.features.nametags.NameTag;
+import me.neznamy.tab.shared.features.redis.RedisSupport;
+import me.neznamy.tab.shared.features.redis.feature.RedisTeams;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.features.injection.NettyPipelineInjector;
+import me.neznamy.tab.shared.features.redis.RedisPlayer;
+import me.neznamy.tab.shared.features.sorting.Sorting;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.connection.InitialHandler;
+import net.md_5.bungee.netty.ChannelWrapper;
+import net.md_5.bungee.protocol.DefinedPacket;
+import net.md_5.bungee.protocol.packet.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * Pipeline injection to secure proper functionality
+ * of some features by preventing other plugins
+ * from overriding it.
+ */
+@SuppressWarnings("unchecked")
+public class BungeePipelineInjector extends NettyPipelineInjector {
+
+    private static @Nullable Field wrapperField;
+
+    static {
+        try {
+            (wrapperField = InitialHandler.class.getDeclaredField("ch")).setAccessible(true);
+        } catch (ReflectiveOperationException exception) {
+            TAB.getInstance().getErrorManager().criticalError("Failed to initialize bungee internal fields", exception);
+        }
+    }
+
+    /** Packets used by the plugin that must be deserialized and BungeeCord does not do it automatically */
+    private final Class<? extends DefinedPacket>[] extraPacketClasses = new Class[]{Team.class, ScoreboardDisplay.class, ScoreboardObjective.class};
+    private final Supplier<DefinedPacket>[] extraPacketSuppliers = new Supplier[]{Team::new, ScoreboardDisplay::new, ScoreboardObjective::new};
+
+    @Override
+    public Function<TabPlayer, ChannelDuplexHandler> getChannelFunction() {
+        return byteBufDeserialization ? DeserializableBungeeChannelDuplexHandler::new : TabChannelDuplexHandler::new;
+    }
+
+    @Override
+    protected @Nullable Channel getChannel(@NotNull TabPlayer player) {
+        if (wrapperField == null) return null;
+        final BungeeTabPlayer bungee = (BungeeTabPlayer) player;
+        try {
+            return ((ChannelWrapper) wrapperField.get(bungee.getPlayer().getPendingConnection())).getHandle();
+        } catch (final IllegalAccessException exception) {
+            TAB.getInstance().getErrorManager().criticalError("Failed to get channel of " + bungee.getPlayer().getName(), exception);
+        }
+        return null;
+    }
+
+    @Override
+    public void onDisplayObjective(@NotNull TabPlayer player, @NotNull Object packet) {
+        TAB.getInstance().getFeatureManager().onDisplayObjective(player,
+                ((ScoreboardDisplay) packet).getPosition(), ((ScoreboardDisplay) packet).getName());
+    }
+
+    @Override
+    public void onObjective(@NotNull TabPlayer player, @NotNull Object packet) {
+        TAB.getInstance().getFeatureManager().onObjective(player,
+                ((ScoreboardObjective) packet).getAction(), ((ScoreboardObjective) packet).getName());
+    }
+
+    @Override
+    public boolean isDisplayObjective(@NotNull Object packet) {
+        return packet instanceof ScoreboardDisplay;
+    }
+
+    @Override
+    public boolean isObjective(@NotNull Object packet) {
+        return packet instanceof ScoreboardObjective;
+    }
+
+    @Override
+    public boolean isTeam(@NotNull Object packet) {
+        return packet instanceof Team;
+    }
+
+    @Override
+    public boolean isPlayerInfo(@NotNull Object packet) {
+        return packet instanceof PlayerListItem || packet instanceof PlayerListItemUpdate;
+    }
+
+    @Override
+    public void modifyPlayers(@NotNull Object team) {
+        if (TAB.getInstance().getNameTagManager() == null) return;
+        Team packet = (Team) team;
+        if (packet.getMode() == 1 || packet.getMode() == 2 || packet.getMode() == 4) return;
+        Collection<String> col = Lists.newArrayList(packet.getPlayers());
+        for (TabPlayer p : TAB.getInstance().getOnlinePlayers()) {
+            Sorting sorting = TAB.getInstance().getFeatureManager().getFeature(TabConstants.Feature.SORTING);
+            String expectedTeam = sorting.getShortTeamName(p);
+            if (expectedTeam != null && col.contains(p.getName()) &&
+                    !((NameTag)TAB.getInstance().getNameTagManager()).getDisableChecker().isDisabledPlayer(p) &&
+                    !TAB.getInstance().getNameTagManager().hasTeamHandlingPaused(p) && !packet.getName().equals(expectedTeam)) {
+                logTeamOverride(packet.getName(), p.getName(), expectedTeam);
+                col.remove(p.getName());
+            }
+        }
+        RedisSupport redis = TAB.getInstance().getFeatureManager().getFeature(TabConstants.Feature.REDIS_BUNGEE);
+        if (redis != null) {
+            RedisTeams teams = redis.getRedisTeams();
+            if (teams != null) {
+                for (RedisPlayer p : redis.getRedisPlayers().values()) {
+                    if (col.contains(p.getName()) && !packet.getName().equals(teams.getTeamNames().get(p))) {
+                        logTeamOverride(packet.getName(), p.getName(), teams.getTeamNames().get(p));
+                        col.remove(p.getName());
+                    }
+                }
+            }
+        }
+        packet.setPlayers(col.toArray(new String[0]));
+    }
+
+    @Override
+    public void onPlayerInfo(@NotNull TabPlayer receiver, @NotNull Object packet) {
+        if (packet instanceof PlayerListItemUpdate) {
+            PlayerListItemUpdate update = (PlayerListItemUpdate) packet;
+            for (PlayerListItem.Item item : update.getItems()) {
+                if (update.getActions().contains(PlayerListItemUpdate.Action.UPDATE_DISPLAY_NAME)) {
+                    IChatBaseComponent newDisplayName = TAB.getInstance().getFeatureManager().onDisplayNameChange(receiver, item.getUuid());
+                    if (newDisplayName != null) item.setDisplayName(newDisplayName.toString(receiver.getVersion()));
+                }
+            }
+        } else {
+            PlayerListItem listItem = (PlayerListItem) packet;
+            for (PlayerListItem.Item item : listItem.getItems()) {
+                if (listItem.getAction() == PlayerListItem.Action.UPDATE_DISPLAY_NAME || listItem.getAction() == PlayerListItem.Action.ADD_PLAYER) {
+                    IChatBaseComponent newDisplayName = TAB.getInstance().getFeatureManager().onDisplayNameChange(receiver, item.getUuid());
+                    if (newDisplayName != null) item.setDisplayName(newDisplayName.toString(receiver.getVersion()));
+                }
+            }
+        }
+    }
+
+    /**
+     * Constructs new instance of the feature
+     */
+    public BungeePipelineInjector() {
+        super("inbound-boss");
+    }
+
+    /**
+     * Channel duplex handler override if features using packets that must be
+     * deserialized manually are used. If they are disabled, deserialization is
+     * disabled for better performance.
+     */
+    public class DeserializableBungeeChannelDuplexHandler extends TabChannelDuplexHandler {
+
+        /**
+         * Constructs new instance with given player
+         *
+         * @param   player
+         *          player to inject
+         */
+        public DeserializableBungeeChannelDuplexHandler(TabPlayer player) {
+            super(player);
+        }
+
+        @Override
+        public void write(ChannelHandlerContext context, Object packet, ChannelPromise channelPromise) {
+            long time = System.nanoTime();
+            Object modifiedPacket = packet instanceof ByteBuf ? deserialize((ByteBuf) packet) : packet;
+            TAB.getInstance().getCPUManager().addTime(TabConstants.Feature.PACKET_DESERIALIZING, TabConstants.CpuUsageCategory.BYTE_BUF, System.nanoTime()-time);
+            super.write(context, modifiedPacket, channelPromise);
+        }
+
+        /**
+         * Deserializes byte buf in case it is one of the tracked packets coming from backend server and returns it.
+         * If the packet is not one of them, returns input
+         *
+         * @param   buf
+         *          byte buf to deserialize
+         * @return  deserialized packet or input byte buf if packet is not tracked
+         */
+        private @NotNull Object deserialize(@NotNull ByteBuf buf) {
+            int marker = buf.readerIndex();
+            try {
+                int packetId = buf.readByte();
+                for (int i=0; i<extraPacketClasses.length; i++) {
+                    if (packetId == ((BungeeTabPlayer)player).getPacketId(extraPacketClasses[i])) {
+                        DefinedPacket packet = extraPacketSuppliers[i].get();
+                        packet.read(buf, null, ((ProxiedPlayer)player.getPlayer()).getPendingConnection().getVersion());
+                        buf.release();
+                        return packet;
+                    }
+                }
+            } catch (Exception e) {
+                //rare OverflowPacketException or IndexOutOfBoundsException
+            }
+            buf.readerIndex(marker);
+            return buf;
+        }
+    }
+}
@@ -0,0 +1,54 @@
+package me.neznamy.tab.platforms.bungeecord;
+
+import com.imaginarycode.minecraft.redisbungee.RedisBungeeAPI;
+import lombok.AllArgsConstructor;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.features.injection.PipelineInjector;
+import me.neznamy.tab.shared.features.redis.RedisSupport;
+import me.neznamy.tab.shared.proxy.ProxyPlatform;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * BungeeCord implementation of Platform
+ */
+@AllArgsConstructor
+public class BungeePlatform extends ProxyPlatform {
+
+    @NotNull private final BungeeTAB plugin;
+
+    @Override
+    public @Nullable RedisSupport getRedisSupport() {
+        if (ReflectionUtils.classExists("com.imaginarycode.minecraft.redisbungee.RedisBungeeAPI") &&
+                RedisBungeeAPI.getRedisBungeeApi() != null) {
+            return new RedisBungeeSupport(plugin);
+        }
+        return null;
+    }
+
+    @Override
+    public void sendConsoleMessage(@NotNull IChatBaseComponent message) {
+        plugin.getLogger().info(message.toLegacyText());
+    }
+
+    @Override
+    public String getServerVersionInfo() {
+        return "[BungeeCord] " + plugin.getProxy().getName() + " - " + plugin.getProxy().getVersion();
+    }
+
+    @Override
+    public void loadPlayers() {
+        for (ProxiedPlayer p : ProxyServer.getInstance().getPlayers()) {
+            TAB.getInstance().addPlayer(new BungeeTabPlayer(p));
+        }
+    }
+
+    @Override
+    public @Nullable PipelineInjector createPipelineInjector() {
+        return new BungeePipelineInjector();
+    }
+}
@@ -0,0 +1,102 @@
+package me.neznamy.tab.platforms.bungeecord;
+
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.Scoreboard;
+import net.md_5.bungee.protocol.packet.ScoreboardDisplay;
+import net.md_5.bungee.protocol.packet.ScoreboardObjective;
+import net.md_5.bungee.protocol.packet.ScoreboardScore;
+import net.md_5.bungee.protocol.packet.Team;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+
+/**
+ * Scoreboard handler for BungeeCord. Because it does not offer
+ * any Scoreboard API and the scoreboard class it has is just a
+ * downstream tracker, we need to use packets.
+ */
+public class BungeeScoreboard extends Scoreboard<BungeeTabPlayer> {
+
+    public BungeeScoreboard(BungeeTabPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void setDisplaySlot(@NotNull DisplaySlot slot, @NotNull String objective) {
+        player.sendPacket(new ScoreboardDisplay((byte)slot.ordinal(), objective));
+    }
+
+    @Override
+    public void registerObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        player.sendPacket(new ScoreboardObjective(objectiveName, jsonOrRaw(title, player.getVersion()), hearts ? ScoreboardObjective.HealthDisplay.HEARTS : ScoreboardObjective.HealthDisplay.INTEGER, (byte) 0));
+    }
+
+    @Override
+    public void unregisterObjective0(@NotNull String objectiveName) {
+        player.sendPacket(new ScoreboardObjective(objectiveName, "", null, (byte) 1)); // Empty string to prevent kick on 1.7
+    }
+
+    @Override
+    public void updateObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        player.sendPacket(new ScoreboardObjective(objectiveName, jsonOrRaw(title, player.getVersion()), hearts ? ScoreboardObjective.HealthDisplay.HEARTS : ScoreboardObjective.HealthDisplay.INTEGER, (byte) 2));
+    }
+
+    @Override
+    public void registerTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix, @NotNull NameVisibility visibility, @NotNull CollisionRule collision, @NotNull Collection<String> players, int options) {
+        int color = 0;
+        if (player.getVersion().getMinorVersion() >= 13) {
+            color = EnumChatFormat.lastColorsOf(prefix).ordinal();
+        }
+        player.sendPacket(new Team(name, (byte) 0, jsonOrRaw(name, player.getVersion()),
+                jsonOrRaw(prefix, player.getVersion()), jsonOrRaw(suffix, player.getVersion()),
+                visibility.toString(), collision.toString(), color, (byte)options, players.toArray(new String[0])));
+    }
+
+    @Override
+    public void unregisterTeam0(@NotNull String name) {
+        player.sendPacket(new Team(name));
+    }
+
+    @Override
+    public void updateTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix, @NotNull NameVisibility visibility, @NotNull CollisionRule collision, int options) {
+        int color = 0;
+        if (player.getVersion().getMinorVersion() >= 13) {
+            color = EnumChatFormat.lastColorsOf(prefix).ordinal();
+        }
+        player.sendPacket(new Team(name, (byte) 2, jsonOrRaw(name, player.getVersion()),
+                jsonOrRaw(prefix, player.getVersion()), jsonOrRaw(suffix, player.getVersion()),
+                visibility.toString(), collision.toString(), color, (byte)options, null));
+    }
+
+    /**
+     * If {@code clientVersion} is &gt;= 1.13, creates a component from given text and returns
+     * it as a serialized component, which BungeeCord uses.
+     * <p>
+     * If {@code clientVersion} is &lt; 1.12, the text is returned
+     *
+     * @param   text
+     *          Text to convert
+     * @param   clientVersion
+     *          Version of player to convert text for
+     * @return  serialized component for 1.13+ clients, cut string for 1.12-
+     */
+    private String jsonOrRaw(@NotNull String text, @NotNull ProtocolVersion clientVersion) {
+        if (clientVersion.getMinorVersion() >= 13) {
+            return IChatBaseComponent.optimizedComponent(text).toString(clientVersion);
+        } else {
+            return text;
+        }
+    }
+
+    @Override
+    public void setScore0(@NotNull String objective, @NotNull String playerName, int score) {
+        player.sendPacket(new ScoreboardScore(playerName, (byte) 0, objective, score));
+    }
+
+    @Override
+    public void removeScore0(@NotNull String objective, @NotNull String playerName) {
+        player.sendPacket(new ScoreboardScore(playerName, (byte) 1, objective, 0));
+    }
+}
@@ -0,0 +1,37 @@
+package me.neznamy.tab.platforms.bungeecord;
+
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import net.md_5.bungee.api.plugin.Plugin;
+import org.bstats.bungeecord.Metrics;
+import org.bstats.charts.SimplePie;
+
+/**
+ * Main class for BungeeCord platform
+ */
+public class BungeeTAB extends Plugin {
+
+    @Override
+    public void onEnable() {
+        if (!ReflectionUtils.classExists("net.md_5.bungee.protocol.packet.PlayerListItemUpdate")) {
+            getLogger().info(EnumChatFormat.color("&cThe plugin requires BungeeCord build #1671 and up (or an equivalent fork) to work."));
+            return;
+        }
+        getProxy().registerChannel(TabConstants.PLUGIN_MESSAGE_CHANNEL_NAME);
+        getProxy().getPluginManager().registerListener(this, new BungeeEventListener());
+        getProxy().getPluginManager().registerCommand(this, new BungeeTabCommand());
+        TAB.setInstance(new TAB(new BungeePlatform(this), ProtocolVersion.PROXY, getDataFolder()));
+        TAB.getInstance().load();
+        Metrics metrics = new Metrics(this, 10535);
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.PERMISSION_SYSTEM, () -> TAB.getInstance().getGroupManager().getPermissionPlugin()));
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.GLOBAL_PLAYER_LIST_ENABLED, () -> TAB.getInstance().getFeatureManager().isFeatureEnabled(TabConstants.Feature.GLOBAL_PLAYER_LIST) ? "Yes" : "No"));
+    }
+
+    @Override
+    public void onDisable() {
+        if (TAB.getInstance() != null) TAB.getInstance().unload();
+    }
+}
@@ -0,0 +1,49 @@
+package me.neznamy.tab.platforms.bungeecord;
+
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.plugin.Command;
+import net.md_5.bungee.api.plugin.TabExecutor;
+
+import java.util.ArrayList;
+
+public class BungeeTabCommand extends Command implements TabExecutor {
+
+    /**
+     * Constructs new instance
+     */
+    public BungeeTabCommand() {
+        super(TabConstants.COMMAND_PROXY, null);
+    }
+
+    @Override
+    public void execute(CommandSender sender, String[] args) {
+        if (TAB.getInstance().isPluginDisabled()) {
+            for (String message : TAB.getInstance().getDisabledCommand().execute(args, sender.hasPermission(TabConstants.Permission.COMMAND_RELOAD), sender.hasPermission(TabConstants.Permission.COMMAND_ALL))) {
+                sender.sendMessage(new TextComponent(EnumChatFormat.color(message)));
+            }
+        } else {
+            TabPlayer p = null;
+            if (sender instanceof ProxiedPlayer) {
+                p = TAB.getInstance().getPlayer(((ProxiedPlayer)sender).getUniqueId());
+                if (p == null) return; //player not loaded correctly
+            }
+            TAB.getInstance().getCommand().execute(p, args);
+        }
+    }
+
+    @Override
+    public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
+        TabPlayer p = null;
+        if (sender instanceof ProxiedPlayer) {
+            p = TAB.getInstance().getPlayer(((ProxiedPlayer)sender).getUniqueId());
+            if (p == null) return new ArrayList<>(); //player not loaded correctly
+        }
+        return TAB.getInstance().getCommand().complete(p, args);
+    }
+}
@@ -0,0 +1,161 @@
+package me.neznamy.tab.platforms.bungeecord;
+
+import de.myzelyam.api.vanish.BungeeVanishAPI;
+import lombok.Getter;
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.platforms.bungeecord.tablist.BungeeTabList1193;
+import me.neznamy.tab.platforms.bungeecord.tablist.BungeeTabList17;
+import me.neznamy.tab.platforms.bungeecord.tablist.BungeeTabList18;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.Scoreboard;
+import me.neznamy.tab.shared.platform.TabList;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.shared.proxy.ProxyTabPlayer;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.chat.ComponentSerializer;
+import net.md_5.bungee.connection.InitialHandler;
+import net.md_5.bungee.connection.LoginResult;
+import net.md_5.bungee.protocol.DefinedPacket;
+import net.md_5.bungee.protocol.Property;
+import net.md_5.bungee.protocol.Protocol;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Method;
+
+/**
+ * TabPlayer implementation for BungeeCord
+ */
+public class BungeeTabPlayer extends ProxyTabPlayer {
+
+    /** Inaccessible bungee internals */
+    private static @Nullable Object directionData;
+    private static @Nullable Method getId;
+
+    /** Flag tracking plugin presence */
+    private static final boolean premiumVanish = ProxyServer.getInstance().getPluginManager().getPlugin("PremiumVanish") != null;
+
+    static {
+        try {
+            directionData = ReflectionUtils.setAccessible(Protocol.class.getDeclaredField("TO_CLIENT")).get(Protocol.GAME);
+            getId = ReflectionUtils.setAccessible(directionData.getClass().getDeclaredMethod("getId", Class.class, int.class));
+        } catch (ReflectiveOperationException e) {
+            TAB.getInstance().getErrorManager().criticalError("Failed to initialize bungee internal fields", e);
+        }
+    }
+
+    /** Player's scoreboard */
+    @Getter private final @NotNull Scoreboard<BungeeTabPlayer> scoreboard = new BungeeScoreboard(this);
+
+    /** Player's tab list based on version */
+    private final @NotNull TabList tabList1_7 = new BungeeTabList17(this);
+    private final @NotNull TabList tabList1_8 = new BungeeTabList18(this);
+    private final @NotNull TabList tabList1_19_3 = new BungeeTabList1193(this);
+
+    @Getter private final @NotNull BossBar bossBar = new BungeeBossBar(this);
+
+    /**
+     * Constructs new instance for given player
+     *
+     * @param   p
+     *          BungeeCord player
+     */
+    public BungeeTabPlayer(@NotNull ProxiedPlayer p) {
+        super(p, p.getUniqueId(), p.getName(), p.getServer() != null ? p.getServer().getInfo().getName() : "-", -1);
+    }
+
+    @Override
+    public boolean hasPermission0(@NotNull String permission) {
+        return getPlayer().hasPermission(permission);
+    }
+
+    @Override
+    public int getPing() {
+        return getPlayer().getPing();
+    }
+
+    public void sendPacket(@NotNull Object nmsPacket) {
+        getPlayer().unsafe().sendPacket((DefinedPacket) nmsPacket);
+    }
+
+    @Override
+    public void sendMessage(@NotNull IChatBaseComponent message) {
+        getPlayer().sendMessage(ComponentSerializer.parse(message.toString(getVersion())));
+    }
+
+    @Override
+    public @Nullable TabList.Skin getSkin() {
+        LoginResult loginResult = ((InitialHandler)getPlayer().getPendingConnection()).getLoginProfile();
+        if (loginResult == null) return null;
+        Property[] properties = loginResult.getProperties();
+        if (properties == null || properties.length == 0) return null;
+        return new TabList.Skin(properties[0].getValue(), properties[0].getSignature());
+    }
+
+    @Override
+    public @NotNull ProxiedPlayer getPlayer() {
+        return (ProxiedPlayer) player;
+    }
+
+    /**
+     * Returns packet ID for this player of provided packet class
+     *
+     * @param   clazz
+     *          packet class
+     * @return  packet ID
+     */
+    public int getPacketId(@NotNull Class<? extends DefinedPacket> clazz) {
+        if (getId == null) return -1;
+        try {
+            return (int) getId.invoke(directionData, clazz, getPlayer().getPendingConnection().getVersion());
+        } catch (ReflectiveOperationException e) {
+            TAB.getInstance().getErrorManager().printError("Failed to get packet id for packet " + clazz +
+                    " with client version " + getPlayer().getPendingConnection().getVersion(), e);
+            return -1;
+        }
+    }
+
+    /**
+     * If ViaVersion is installed on BungeeCord, it changes protocol to match version
+     * of server to which player is connected to. For that reason, we need to retrieve
+     * the field more often than just on join.
+     *
+     * @return  Player's current protocol version
+     */
+    @Override
+    public @NotNull ProtocolVersion getVersion() {
+        return ProtocolVersion.fromNetworkId(getPlayer().getPendingConnection().getVersion());
+    }
+
+    @Override
+    public boolean isVanished() {
+        //noinspection ConstantConditions
+        if (premiumVanish && BungeeVanishAPI.isInvisible(getPlayer())) return true;
+        return super.isVanished();
+    }
+
+    @Override
+    public boolean isOnline() {
+        return getPlayer().isConnected();
+    }
+
+    @Override
+    public @NotNull TabList getTabList() {
+        return getVersion().getNetworkId() >= ProtocolVersion.V1_19_3.getNetworkId() ?
+                tabList1_19_3 : getVersion().getMinorVersion() >= 8 ? tabList1_8 : tabList1_7;
+    }
+
+    @Override
+    public void sendPluginMessage(byte[] message) {
+        if (getPlayer().getServer() == null) {
+            TAB.getInstance().getErrorManager().printError("Skipped plugin message send to " + getName() + ", because player is not" +
+                    "connected to any server (message=" + new String(message) + ")");
+            return;
+        }
+        getPlayer().getServer().sendData(TabConstants.PLUGIN_MESSAGE_CHANNEL_NAME, message);
+    }
+}
@@ -0,0 +1,45 @@
+package me.neznamy.tab.platforms.bungeecord;
+
+import com.imaginarycode.minecraft.redisbungee.RedisBungeeAPI;
+import com.imaginarycode.minecraft.redisbungee.events.PubSubMessageEvent;
+import lombok.AllArgsConstructor;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.features.redis.RedisSupport;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.api.plugin.Plugin;
+import net.md_5.bungee.event.EventHandler;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Redis implementation for BungeeCord
+ */
+@AllArgsConstructor
+public class RedisBungeeSupport extends RedisSupport implements Listener {
+
+    /** Plugin reference for registering listener */
+    private final @NotNull Plugin plugin;
+
+    @EventHandler
+    public void onMessage(@NotNull PubSubMessageEvent e) {
+        if (!e.getChannel().equals(TabConstants.REDIS_CHANNEL_NAME)) return;
+        processMessage(e.getMessage());
+    }
+
+    @Override
+    public void register() {
+        ProxyServer.getInstance().getPluginManager().registerListener(plugin, this);
+        RedisBungeeAPI.getRedisBungeeApi().registerPubSubChannels(TabConstants.REDIS_CHANNEL_NAME);
+    }
+
+    @Override
+    public void unregister() {
+        ProxyServer.getInstance().getPluginManager().unregisterListener(this);
+        RedisBungeeAPI.getRedisBungeeApi().unregisterPubSubChannels(TabConstants.REDIS_CHANNEL_NAME);
+    }
+
+    @Override
+    public void sendMessage(@NotNull String message) {
+        RedisBungeeAPI.getRedisBungeeApi().sendChannelMessage(TabConstants.REDIS_CHANNEL_NAME, message);
+    }
+}
@@ -0,0 +1,91 @@
+package me.neznamy.tab.platforms.bungeecord.tablist;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.platforms.bungeecord.BungeeTabPlayer;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.TabList;
+import net.md_5.bungee.UserConnection;
+import net.md_5.bungee.protocol.Property;
+import net.md_5.bungee.protocol.packet.PlayerListItem.Item;
+import net.md_5.bungee.protocol.packet.PlayerListItemRemove;
+import net.md_5.bungee.protocol.packet.PlayerListItemUpdate;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.EnumSet;
+import java.util.UUID;
+
+/**
+ * TabList handler for 1.19.3+ players using the new tab list packets.
+ * Because BungeeCord does not have a TabList API, we need to use packets.
+ * They are sent using an internal BungeeCord method that keeps track of them,
+ * so they are removed on server switch to secure parity with Velocity.
+ */
+@RequiredArgsConstructor
+public class BungeeTabList1193 implements TabList {
+
+    /** Player this TabList belongs to */
+    private final BungeeTabPlayer player;
+
+    @Override
+    public void removeEntry(@NotNull UUID entry) {
+        PlayerListItemRemove remove = new PlayerListItemRemove();
+        remove.setUuids(new UUID[]{entry});
+        ((UserConnection)player.getPlayer()).getTabListHandler().onUpdate(remove);
+    }
+
+    @Override
+    public void updateDisplayName(@NotNull UUID entry, @Nullable IChatBaseComponent displayName) {
+        Item item = item(entry);
+        item.setDisplayName(displayName == null ? null : displayName.toString(player.getVersion()));
+        sendPacket(EnumSet.of(PlayerListItemUpdate.Action.UPDATE_DISPLAY_NAME), item);
+    }
+
+    @Override
+    public void updateLatency(@NotNull UUID entry, int latency) {
+        Item item = item(entry);
+        item.setPing(latency);
+        sendPacket(EnumSet.of(PlayerListItemUpdate.Action.UPDATE_LATENCY), item);
+    }
+
+    @Override
+    public void updateGameMode(@NotNull UUID entry, int gameMode) {
+        Item item = item(entry);
+        item.setGamemode(gameMode);
+        sendPacket(EnumSet.of(PlayerListItemUpdate.Action.UPDATE_GAMEMODE), item);
+    }
+
+    @Override
+    public void addEntry(@NotNull Entry entry) {
+        Item item = item(entry.getUniqueId());
+        if (entry.getDisplayName() != null) item.setDisplayName(entry.getDisplayName().toString(player.getVersion()));
+        item.setGamemode(entry.getGameMode());
+        item.setListed(true);
+        item.setPing(entry.getLatency());
+        if (entry.getSkin() != null) {
+            item.setProperties(new Property[]{new Property(TEXTURES_PROPERTY, entry.getSkin().getValue(), entry.getSkin().getSignature())});
+        } else {
+            item.setProperties(new Property[0]);
+        }
+        item.setUsername(entry.getName());
+        sendPacket(EnumSet.allOf(PlayerListItemUpdate.Action.class), item);
+    }
+
+    public @NotNull Item item(@NotNull UUID id) {
+        Item item = new Item();
+        item.setUuid(id);
+        return item;
+    }
+
+    private void sendPacket(@NotNull EnumSet<PlayerListItemUpdate.Action> actions, @NotNull Item item) {
+        PlayerListItemUpdate packet = new PlayerListItemUpdate();
+        packet.setActions(actions);
+        packet.setItems(new Item[]{item});
+        ((UserConnection)player.getPlayer()).getTabListHandler().onUpdate(packet);
+    }
+
+    @Override
+    public void setPlayerListHeaderFooter(@NotNull IChatBaseComponent header, @NotNull IChatBaseComponent footer) {
+        player.getPlayer().setTabHeader(header.toBungeeComponent(player.getVersion()), footer.toBungeeComponent(player.getVersion()));
+    }
+}
@@ -0,0 +1,93 @@
+package me.neznamy.tab.platforms.bungeecord.tablist;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.platforms.bungeecord.BungeeTabPlayer;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.TabList;
+import net.md_5.bungee.UserConnection;
+import net.md_5.bungee.protocol.packet.PlayerListItem;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * TabList handler for 1.7 players, which has a completely different
+ * system. Entries are identified by display name, not uuids. Display
+ * names are changed by removing old entry and adding a new one, which
+ * requires further tracking than just the UUID.<p>
+ * Because BungeeCord does not have a TabList API, we need to use packets.
+ * They are sent using an internal BungeeCord method that keeps track of them,
+ * so they are removed on server switch to secure parity with Velocity.
+ * While BungeeCord itself does not support 1.7, some of its forks do.
+ * This was tested on FlameCord fork.
+ */
+@RequiredArgsConstructor
+public class BungeeTabList17 implements TabList {
+
+    /** Player this TabList belongs to */
+    private final BungeeTabPlayer player;
+
+    /** Because entries are identified by names and not uuids on 1.7 */
+    private final Map<UUID, String> userNames = new HashMap<>();
+    private final Map<UUID, String> displayNames = new HashMap<>();
+
+    @Override
+    public void removeEntry(@NotNull UUID entry) {
+        if (!displayNames.containsKey(entry)) return; // Entry not tracked by TAB
+        update(PlayerListItem.Action.REMOVE_PLAYER, createItem(null, displayNames.get(entry), 0));
+
+        // Remove from map
+        userNames.remove(entry);
+        displayNames.remove(entry);
+    }
+
+    @Override
+    public void updateDisplayName(@NotNull UUID entry, @Nullable IChatBaseComponent displayName) {
+        if (!displayNames.containsKey(entry)) return; // Entry not tracked by TAB
+        update(PlayerListItem.Action.REMOVE_PLAYER, createItem(null, displayNames.get(entry), 0));
+        addEntry(new Entry.Builder(entry).displayName(displayName).name(userNames.get(entry)).build());
+    }
+
+    @Override
+    public void updateLatency(@NotNull UUID entry, int latency) {
+        if (!displayNames.containsKey(entry)) return; // Entry not tracked by TAB
+        update(PlayerListItem.Action.UPDATE_LATENCY, createItem(null, displayNames.get(entry), latency));
+    }
+
+    @Override
+    public void updateGameMode(@NotNull UUID entry, int gameMode) {/*Added in 1.8*/}
+
+    @Override
+    public void addEntry(@NotNull Entry entry) {
+        String displayNameString = entry.getDisplayName() == null ? String.valueOf(entry.getName()) : entry.getDisplayName().toLegacyText();
+        if (displayNameString.length() > 16) displayNameString = displayNameString.substring(0, 16); // 16 character limit
+        update(PlayerListItem.Action.ADD_PLAYER, createItem(entry.getName(), displayNameString, entry.getLatency()));
+
+        // Add to map
+        userNames.put(entry.getUniqueId(), entry.getName());
+        displayNames.put(entry.getUniqueId(), displayNameString);
+    }
+
+    private void update(@NotNull PlayerListItem.Action action, @NotNull PlayerListItem.Item item) {
+        PlayerListItem packet = new PlayerListItem();
+        packet.setAction(action);
+        packet.setItems(new PlayerListItem.Item[]{item});
+        ((UserConnection)player.getPlayer()).getTabListHandler().onUpdate(packet);
+    }
+
+    private PlayerListItem.Item createItem(@Nullable String username, @NotNull String displayName, int latency) {
+        PlayerListItem.Item item = new PlayerListItem.Item();
+        item.setUsername(username);
+        item.setDisplayName(displayName);
+        item.setPing(latency);
+        return item;
+    }
+
+    @Override
+    public void setPlayerListHeaderFooter(@NotNull IChatBaseComponent header, @NotNull IChatBaseComponent footer) {
+        // Added in 1.8
+    }
+}
@@ -0,0 +1,86 @@
+package me.neznamy.tab.platforms.bungeecord.tablist;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.platforms.bungeecord.BungeeTabPlayer;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.TabList;
+import net.md_5.bungee.UserConnection;
+import net.md_5.bungee.protocol.Property;
+import net.md_5.bungee.protocol.packet.PlayerListItem;
+import net.md_5.bungee.protocol.packet.PlayerListItem.Item;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+/**
+ * TabList handler for players between 1.8 and 1.19.2.<p>
+ * Because BungeeCord does not have a TabList API, we need to use packets.
+ * They are sent using an internal BungeeCord method that keeps track of them,
+ * so they are removed on server switch to secure parity with Velocity.
+ */
+@RequiredArgsConstructor
+public class BungeeTabList18 implements TabList {
+
+    /** Player this TabList belongs to */
+    private final BungeeTabPlayer player;
+
+    @Override
+    public void removeEntry(@NotNull UUID entry) {
+        sendPacket(PlayerListItem.Action.REMOVE_PLAYER, item(entry));
+    }
+
+    @Override
+    public void updateDisplayName(@NotNull UUID entry, @Nullable IChatBaseComponent displayName) {
+        Item item = item(entry);
+        item.setDisplayName(displayName == null ? null : displayName.toString(player.getVersion()));
+        sendPacket(PlayerListItem.Action.UPDATE_DISPLAY_NAME, item);
+    }
+
+    @Override
+    public void updateLatency(@NotNull UUID entry, int latency) {
+        Item item = item(entry);
+        item.setPing(latency);
+        sendPacket(PlayerListItem.Action.UPDATE_LATENCY, item);
+    }
+
+    @Override
+    public void updateGameMode(@NotNull UUID entry, int gameMode) {
+        Item item = item(entry);
+        item.setGamemode(gameMode);
+        sendPacket(PlayerListItem.Action.UPDATE_GAMEMODE, item);
+    }
+
+    @Override
+    public void addEntry(@NotNull Entry entry) {
+        Item item = item(entry.getUniqueId());
+        if (entry.getDisplayName() != null) item.setDisplayName(entry.getDisplayName().toString(player.getVersion()));
+        item.setGamemode(entry.getGameMode());
+        item.setPing(entry.getLatency());
+        if (entry.getSkin() != null) {
+            item.setProperties(new Property[]{new Property(TEXTURES_PROPERTY, entry.getSkin().getValue(), entry.getSkin().getSignature())});
+        } else {
+            item.setProperties(new Property[0]);
+        }
+        item.setUsername(entry.getName());
+        sendPacket(PlayerListItem.Action.ADD_PLAYER, item);
+    }
+
+    public @NotNull Item item(@NotNull UUID id) {
+        Item item = new Item();
+        item.setUuid(id);
+        return item;
+    }
+
+    private void sendPacket(@NotNull PlayerListItem.Action action, @NotNull Item item) {
+        PlayerListItem packet = new PlayerListItem();
+        packet.setAction(action);
+        packet.setItems(new Item[]{item});
+        ((UserConnection)player.getPlayer()).getTabListHandler().onUpdate(packet);
+    }
+
+    @Override
+    public void setPlayerListHeaderFooter(@NotNull IChatBaseComponent header, @NotNull IChatBaseComponent footer) {
+        player.getPlayer().setTabHeader(header.toBungeeComponent(player.getVersion()), footer.toBungeeComponent(player.getVersion()));
+    }
+}
@@ -0,0 +1,7 @@
+name: @name@
+main: me.neznamy.tab.platforms.bungeecord.BungeeTAB
+version: @version@
+author: @author@
+description: @description@
+depends: []
+softDepends: [RedisBungee, LuckPerms, PremiumVanish]
@@ -0,0 +1,78 @@
+// Versions that don't require any code changes:
+//      1.19.3, 1.19.4, 1.20, 1.20.1
+val minecraftVersion = "1.20.1"
+
+val v114 = "0.28.5+1.14"
+val v115 = "0.28.5+1.15"
+val v116 = "0.42.0+1.16"
+
+val fabricApiVersions = mapOf(
+    "1.20.1" to "0.83.0+1.20.1",
+    "1.20"   to "0.83.0+1.20",
+    "1.19.4" to "0.77.0+1.19.4",
+    "1.19.3" to "0.76.0+1.19.3",
+    "1.19.2" to "0.76.0+1.19.2",
+    "1.19.1" to "0.58.5+1.19.1",
+    "1.19"   to "0.58.0+1.19",
+    "1.18.2" to "0.76.0+1.18.2",
+    "1.18.1" to "0.46.6+1.18",
+    "1.18"   to "0.46.6+1.18",
+    "1.17.1" to "0.46.1+1.17",
+    "1.17"   to "0.46.1+1.17",
+    "1.16.5" to v116,
+    "1.16.4" to v116,
+    "1.16.3" to v116,
+    "1.16.2" to v116,
+    "1.16.1" to v116,
+    "1.16"   to v116,
+    "1.15.2" to v115,
+    "1.15.1" to v115,
+    "1.15"   to v115,
+    "1.14.4" to v114,
+    "1.14.3" to v114,
+    "1.14.2" to v114,
+    "1.14.1" to v114,
+    "1.14"   to v114,
+)
+
+plugins {
+    id("fabric-loom")
+}
+
+repositories {
+    // Gradle doesn't support combining settings and project repositories, so we have to re-declare all the settings repos we need
+    maven("https://repo.kryptonmc.org/releases")
+    maven("https://repo.opencollab.dev/maven-snapshots/")
+    maven("https://repo.viaversion.com/")
+    maven("https://oss.sonatype.org/content/repositories/snapshots")
+}
+
+dependencies {
+    implementation(projects.shared)
+
+    minecraft("com.mojang:minecraft:$minecraftVersion")
+    mappings(loom.officialMojangMappings())
+
+    modImplementation("net.fabricmc", "fabric-loader", "0.14.17")
+    modImplementation("me.lucko", "fabric-permissions-api", "0.2-SNAPSHOT")
+    modImplementation(fabricApi.module("fabric-api-base", fabricApiVersions[minecraftVersion]))
+    modImplementation(fabricApi.module("fabric-lifecycle-events-v1", fabricApiVersions[minecraftVersion]))
+    modImplementation(fabricApi.module("fabric-networking-api-v1", fabricApiVersions[minecraftVersion]))
+    modImplementation(fabricApi.module("fabric-entity-events-v1", fabricApiVersions[minecraftVersion]))
+    modImplementation(fabricApi.module("fabric-command-api-v${if (minecraftVersion.split(".")[1].toInt() >= 19) "2" else "1"}", fabricApiVersions[minecraftVersion]))
+}
+
+loom {
+    accessWidenerPath.set(file("src/main/resources/tab.accesswidener"))
+}
+
+tasks {
+    compileJava {
+        options.release.set(17)
+    }
+    validateAccessWidener {
+        // We don't want to validate the access wideners, as we have wideners for multiple versions, and the validation task will
+        // fail, as the classes for the old wideners don't exist in the new versions and vice versa.
+        enabled = false
+    }
+}
@@ -0,0 +1,57 @@
+package me.neznamy.tab.platforms.fabric;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import net.minecraft.server.level.ServerBossEvent;
+import net.minecraft.world.BossEvent;
+import org.jetbrains.annotations.NotNull;
+
+@RequiredArgsConstructor
+public class FabricBossBar implements BossBar {
+
+    private final FabricTabPlayer player;
+    private final Map<UUID, ServerBossEvent> bars = new HashMap<>();
+
+    @Override
+    public void create(@NotNull UUID id, @NotNull String title, float progress, @NotNull BarColor color, @NotNull BarStyle style) {
+        ServerBossEvent bar = new ServerBossEvent(
+                FabricTAB.getInstance().toComponent(IChatBaseComponent.optimizedComponent(title), player.getVersion()),
+                BossEvent.BossBarColor.valueOf(color.name()),
+                BossEvent.BossBarOverlay.valueOf(style.name())
+        );
+        bar.setProgress(progress);
+        bars.put(id, bar);
+        bar.addPlayer(player.getPlayer());
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull String title) {
+        bars.get(id).setName(FabricTAB.getInstance().toComponent(IChatBaseComponent.optimizedComponent(title), player.getVersion()));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, float progress) {
+        bars.get(id).setProgress(progress);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarStyle style) {
+        bars.get(id).setOverlay(BossEvent.BossBarOverlay.valueOf(style.name()));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarColor color) {
+        bars.get(id).setColor(BossEvent.BossBarColor.valueOf(color.name()));
+    }
+
+    @Override
+    public void remove(@NotNull UUID id) {
+        bars.remove(id).removePlayer(player.getPlayer());
+    }
+}
@@ -0,0 +1,23 @@
+package me.neznamy.tab.platforms.fabric;
+
+import me.neznamy.tab.shared.platform.EventListener;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import net.fabricmc.fabric.api.entity.event.v1.ServerPlayerEvents;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.minecraft.server.level.ServerPlayer;
+
+public class FabricEventListener extends EventListener<ServerPlayer> {
+
+    public void register() {
+        ServerPlayConnectionEvents.JOIN.register((connection, $, $$) -> join(connection.player));
+        ServerPlayConnectionEvents.DISCONNECT.register((connection, $) -> quit(connection.player.getUUID()));
+        ServerPlayerEvents.AFTER_RESPAWN.register((oldPlayer, newPlayer, alive) -> replacePlayer(oldPlayer.getUUID(), newPlayer));
+    }
+
+    @Override
+    public TabPlayer createPlayer(ServerPlayer player) {
+        return new FabricTabPlayer(player);
+    }
+
+    //TODO world switch
+}
@@ -0,0 +1,16 @@
+package me.neznamy.tab.platforms.fabric;
+
+import me.neznamy.tab.api.placeholder.PlaceholderManager;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.placeholders.UniversalPlaceholderRegistry;
+import net.minecraft.server.level.ServerPlayer;
+import org.jetbrains.annotations.NotNull;
+
+public class FabricPlaceholderRegistry extends UniversalPlaceholderRegistry {
+
+    @Override
+    public void registerPlaceholders(@NotNull PlaceholderManager manager) {
+        manager.registerPlayerPlaceholder(TabConstants.Placeholder.HEALTH, 100, p -> (int) Math.ceil(((ServerPlayer) p.getPlayer()).getHealth()));
+        super.registerPlaceholders(manager);
+    }
+}
@@ -0,0 +1,66 @@
+package me.neznamy.tab.platforms.fabric;
+
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.backend.BackendPlatform;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.features.injection.PipelineInjector;
+import me.neznamy.tab.shared.features.nametags.NameTag;
+import me.neznamy.tab.shared.features.types.TabFeature;
+import me.neznamy.tab.shared.placeholders.expansion.EmptyTabExpansion;
+import me.neznamy.tab.shared.placeholders.expansion.TabExpansion;
+import net.fabricmc.fabric.api.networking.v1.PlayerLookup;
+import net.minecraft.SharedConstants;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class FabricPlatform implements BackendPlatform {
+
+    @Override
+    public void registerUnknownPlaceholder(@NotNull String identifier) {
+        TAB.getInstance().getPlaceholderManager().registerServerPlaceholder(identifier, -1, () -> identifier);
+    }
+
+    @Override
+    public void loadPlayers() {
+        for (ServerPlayer player : PlayerLookup.all(FabricTAB.getInstance().getServer())) {
+            TAB.getInstance().addPlayer(new FabricTabPlayer(player));
+        }
+    }
+
+    @Override
+    public void registerPlaceholders() {
+        new FabricPlaceholderRegistry().registerPlaceholders(TAB.getInstance().getPlaceholderManager());
+    }
+
+    @Override
+    public @NotNull NameTag getUnlimitedNameTags() {
+        return new NameTag();
+    }
+
+    @Override
+    public @Nullable PipelineInjector createPipelineInjector() {
+        return null;
+    }
+
+    @Override
+    public @NotNull TabExpansion createTabExpansion() {
+        return new EmptyTabExpansion();
+    }
+
+    @Override
+    public @Nullable TabFeature getPerWorldPlayerList() {
+        return null;
+    }
+
+    @Override
+    public void sendConsoleMessage(@NotNull IChatBaseComponent message) {
+        MinecraftServer.LOGGER.info("[TAB] " + message.toRawText());
+    }
+
+    @Override
+    public String getServerVersionInfo() {
+        return "[Fabric] " + SharedConstants.getCurrentVersion().getName();
+    }
+}
@@ -0,0 +1,136 @@
+package me.neznamy.tab.platforms.fabric;
+
+import java.util.Collection;
+import java.util.Objects;
+
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.Scoreboard;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.game.ClientboundSetDisplayObjectivePacket;
+import net.minecraft.network.protocol.game.ClientboundSetObjectivePacket;
+import net.minecraft.network.protocol.game.ClientboundSetPlayerTeamPacket;
+import net.minecraft.network.protocol.game.ClientboundSetScorePacket;
+import net.minecraft.server.ServerScoreboard;
+import net.minecraft.world.scores.Objective;
+import net.minecraft.world.scores.PlayerTeam;
+import net.minecraft.world.scores.Team;
+import net.minecraft.world.scores.criteria.ObjectiveCriteria;
+import org.jetbrains.annotations.NotNull;
+
+public class FabricScoreboard extends Scoreboard<FabricTabPlayer> {
+
+    private final @NotNull net.minecraft.world.scores.Scoreboard dummyScoreboard = new net.minecraft.world.scores.Scoreboard();
+    private final @NotNull Component EMPTY_COMPONENT = Objects.requireNonNull(Component.Serializer.fromJson(IChatBaseComponent.EMPTY_COMPONENT));
+
+    public FabricScoreboard(FabricTabPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void setDisplaySlot(@NotNull DisplaySlot slot, @NotNull String objective) {
+        player.sendPacket(
+                new ClientboundSetDisplayObjectivePacket(
+                        slot.ordinal(),
+                        new Objective(
+                                dummyScoreboard,
+                                objective,
+                                ObjectiveCriteria.DUMMY,
+                                EMPTY_COMPONENT,
+                                ObjectiveCriteria.RenderType.INTEGER
+                        )
+                )
+        );
+    }
+
+    @Override
+    public void registerObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        player.sendPacket(
+                new ClientboundSetObjectivePacket(
+                        new Objective(
+                            dummyScoreboard,
+                            objectiveName,
+                            ObjectiveCriteria.DUMMY,
+                            FabricTAB.getInstance().toComponent(IChatBaseComponent.optimizedComponent(title), player.getVersion()),
+                            hearts ? ObjectiveCriteria.RenderType.HEARTS : ObjectiveCriteria.RenderType.INTEGER
+                        ),
+                        0
+                )
+        );
+    }
+
+    @Override
+    public void unregisterObjective0(@NotNull String objectiveName) {
+        player.sendPacket(
+                new ClientboundSetObjectivePacket(
+                        new Objective(
+                                dummyScoreboard,
+                                objectiveName,
+                                ObjectiveCriteria.DUMMY,
+                                EMPTY_COMPONENT,
+                                ObjectiveCriteria.RenderType.INTEGER
+                        ),
+                        1
+                )
+        );
+    }
+
+    @Override
+    public void updateObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        player.sendPacket(
+                new ClientboundSetObjectivePacket(
+                        new Objective(
+                            dummyScoreboard,
+                            objectiveName,
+                            ObjectiveCriteria.DUMMY,
+                            FabricTAB.getInstance().toComponent(IChatBaseComponent.optimizedComponent(title), player.getVersion()),
+                            hearts ? ObjectiveCriteria.RenderType.HEARTS : ObjectiveCriteria.RenderType.INTEGER
+                        ),
+                        2
+                )
+        );
+    }
+
+    @Override
+    public void registerTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix, @NotNull NameVisibility visibility, @NotNull CollisionRule collision, @NotNull Collection<String> players, int options) {
+        PlayerTeam team = new PlayerTeam(dummyScoreboard, name);
+        team.setAllowFriendlyFire((options & 0x01) > 0);
+        team.setSeeFriendlyInvisibles((options & 0x02) > 0);
+        team.setColor(ChatFormatting.valueOf(EnumChatFormat.lastColorsOf(prefix).name()));
+        team.setCollisionRule(Team.CollisionRule.valueOf(collision.name()));
+        team.setNameTagVisibility(Team.Visibility.valueOf(visibility.name()));
+        team.setPlayerPrefix(FabricTAB.getInstance().toComponent(IChatBaseComponent.optimizedComponent(prefix), player.getVersion()));
+        team.setPlayerSuffix(FabricTAB.getInstance().toComponent(IChatBaseComponent.optimizedComponent(suffix), player.getVersion()));
+        team.getPlayers().addAll(players);
+        player.sendPacket(ClientboundSetPlayerTeamPacket.createAddOrModifyPacket(team, true));
+    }
+
+    @Override
+    public void unregisterTeam0(@NotNull String name) {
+        player.sendPacket(ClientboundSetPlayerTeamPacket.createRemovePacket(new PlayerTeam(dummyScoreboard, name)));
+    }
+
+    @Override
+    public void updateTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix, @NotNull NameVisibility visibility, @NotNull CollisionRule collision, int options) {
+        PlayerTeam team = new PlayerTeam(dummyScoreboard, name);
+        team.setAllowFriendlyFire((options & 0x01) > 0);
+        team.setSeeFriendlyInvisibles((options & 0x02) > 0);
+        team.setColor(ChatFormatting.valueOf(EnumChatFormat.lastColorsOf(prefix).name()));
+        team.setCollisionRule(Team.CollisionRule.valueOf(collision.name()));
+        team.setNameTagVisibility(Team.Visibility.valueOf(visibility.name()));
+        team.setPlayerPrefix(FabricTAB.getInstance().toComponent(IChatBaseComponent.optimizedComponent(prefix), player.getVersion()));
+        team.setPlayerSuffix(FabricTAB.getInstance().toComponent(IChatBaseComponent.optimizedComponent(suffix), player.getVersion()));
+        player.sendPacket(ClientboundSetPlayerTeamPacket.createAddOrModifyPacket(team, false));
+    }
+
+    @Override
+    public void setScore0(@NotNull String objective, @NotNull String playerName, int score) {
+        player.sendPacket(new ClientboundSetScorePacket(ServerScoreboard.Method.CHANGE, objective, playerName, score));
+    }
+
+    @Override
+    public void removeScore0(@NotNull String objective, @NotNull String playerName) {
+        player.sendPacket(new ClientboundSetScorePacket(ServerScoreboard.Method.REMOVE, objective, playerName, 0));
+    }
+}