zenphayt

Create a complete, production-ready Minecraft Paper 1.21.11 plugin using Java.

The plugin will be called:

HideName

The main purpose of this plugin is to hide a selected player's username/name from all visible places where their name normally appears, while keeping the actual player completely visible and functional.

This is NOT a vanish plugin.

The player must remain fully visible in the world.

---

CORE FEATURE

The plugin must provide:

/hide <player>

and:

/unhide <player>

Example:

/hide Zenpha

When "/hide Zenpha" is executed, Zenpha's name should become hidden/blank in:

  1. Nametag above the player's head.
  2. TAB player list.
  3. Chat messages sent by that player.
  4. Chat-related player-name display where the plugin can safely control it.

The actual player must remain visible and usable.

---

VERY IMPORTANT: THIS IS NOT VANISH

Do NOT hide the player entity.

Do NOT use:

Player#hidePlayer(...)

Do NOT use vanish functionality.

Do NOT make the player's skin disappear.

Do NOT remove the player from the server.

Do NOT remove the player from TAB.

Do NOT make the player invisible.

The only thing being hidden is their displayed username/name.

The player should still be:

  • Completely visible.
  • Able to move.
  • Able to jump.
  • Able to attack.
  • Able to be attacked.
  • Able to take damage.
  • Able to interact with blocks.
  • Able to interact with entities.
  • Able to open inventories.
  • Able to use items.
  • Able to chat.
  • Able to receive messages.
  • Able to send messages.
  • Able to appear as a normal player entity.

---

  1. COMMAND: /hide

Implement:

/hide <player>

Example:

/hide Zenpha

The target player's username should immediately become hidden.

The change should happen without requiring the player to reconnect.

---

  1. NAMETAG

Normally a player has:

Zenpha

above their head.

After:

/hide Zenpha

the result should be:

[blank]

The nametag location/entity representation should remain normal, but the username text must not be visible.

The player itself must remain visible.

For example:

[blank] ↓ [PLAYER]

NOT:

[blank] ↓ X

The player must NOT disappear.

---

  1. TAB LIST

The hidden player must remain inside the TAB list.

For example, normally:

Players Online

Zenpha Steve Alex Player123

After:

/hide Zenpha

TAB should effectively display:

Players Online

[blank] Steve Alex Player123

IMPORTANT:

The entry must still exist.

Do NOT remove Zenpha from TAB.

Do NOT use:

hidePlayer()

The player should still occupy their TAB position/entry.

Only their displayed username should become blank.

---

  1. CHAT NAME HIDING — VERY IMPORTANT

Add another major feature:

When a player is hidden, their username must also be hidden when they send a chat message.

For example, normally chat might look like:

Zenpha: Hello everyone!

After:

/hide Zenpha

it should become approximately:

: Hello everyone!

or preferably:

Hello everyone!

depending on the configured chat format.

The most important requirement is:

The hidden player's username must NOT be visible in the chat message.

The actual message content must still be visible.

Example:

Player sends:

Hello everyone, welcome to the server!

Other players should still receive the message.

Only the sender's username/name should be blank or omitted.

---

  1. DO NOT HIDE CHAT CONTENT

This distinction is extremely important.

If Zenpha is hidden and sends:

Hello guys!

the plugin must NOT block the message.

It must NOT make the message invisible.

It must NOT cancel the chat event simply because the player is hidden.

Expected:

[blank]: Hello guys!

or:

Hello guys!

depending on the selected implementation/configuration.

NOT:

[message completely hidden]

---

  1. CHAT FORMAT COMPATIBILITY

The plugin must account for modern Paper 1.21.11 chat APIs.

Do NOT blindly use old:

AsyncPlayerChatEvent

implementations if they are not appropriate for the current Paper version.

Use the modern Paper-compatible chat event/API where appropriate.

The implementation must work correctly with the modern Paper chat system.

If Paper 1.21.11 uses signed chat / renderer-related APIs, use the correct current API.

The objective is:

Hidden player + sends chat ↓ Message still appears ↓ Player's displayed name is blank/removed

---

  1. CHAT EXAMPLE

Suppose these players are online:

Zenpha Steve Alex Notch

Zenpha executes:

/hide Zenpha

Zenpha sends:

Hello everyone!

Instead of:

Zenpha: Hello everyone!

other players should see something like:

: Hello everyone!

or, preferably:

Hello everyone!

No visible "Zenpha" username should remain in the rendered chat message.

---

  1. UNHIDE CHAT

When:

/unhide Zenpha

is executed, the normal chat name should return.

So:

Before hiding:

Zenpha: Hello!

While hidden:

Hello!

After unhide:

Zenpha: Hello!

The plugin must restore normal behavior.

---

  1. DO NOT HARD-CODE A CHAT FORMAT

Do not assume every server uses:

<player>: <message>

Some servers may use:

[VIP] Zenpha: Hello

or:

[Admin] Zenpha » Hello

or:

Zenpha ➜ Hello

The plugin should interfere with only the player-name component where possible.

Do not unnecessarily destroy:

  • Prefixes.
  • Suffixes.
  • Ranks.
  • Colors.
  • Chat formatting.
  • Hover events.
  • Click events.
  • Other chat components.

If another plugin controls chat formatting, try to remain compatible.

---

  1. CHAT PLUGIN COMPATIBILITY

The plugin should try to coexist with common chat/permission plugins.

Potentially installed plugins may include:

  • LuckPerms
  • Essentials
  • PlaceholderAPI
  • TAB
  • other chat-formatting plugins
  • scoreboard plugins

Do not aggressively replace the entire chat system.

Use the least invasive Paper-compatible approach.

If complete compatibility with an external chat-formatting plugin cannot be guaranteed, clearly explain the limitation in the documentation.

---

  1. PLAYER JOIN

Suppose:

  1. Zenpha is hidden.
  2. Steve joins the server.

Steve must immediately see:

Nametag:

[blank]

TAB:

[blank]

Chat:

If Zenpha sends:

Hello!

Steve should see:

Hello!

instead of:

Zenpha: Hello!

The hidden state must be applied to newly joined players as necessary.

---

  1. PLAYER REJOIN

Suppose:

  1. "/hide Zenpha"
  2. Zenpha disconnects.
  3. Zenpha reconnects.

If persistence is enabled, Zenpha should automatically remain hidden.

The plugin must reapply:

  • Nametag hiding.
  • TAB name hiding.
  • Chat name hiding.

Do not require the administrator to run "/hide Zenpha" again.

---

  1. UUID-BASED STORAGE

Internally identify players using:

UUID

Do NOT rely only on usernames.

Example persistent data:

hidden-players: - "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

This ensures the hidden state remains associated with the player even if their username changes.

---

  1. PLAYER NAME CHANGE

If the hidden player's username changes:

OldName → NewName

the hidden state should remain active because it is associated with their UUID.

The plugin should not suddenly reveal the new username.

---

  1. /unhide COMMAND

Implement:

/unhide <player>

Example:

/unhide Zenpha

This should restore everything:

Nametag

Zenpha

TAB

Zenpha

Chat

Zenpha: Hello!

All normal display behavior should return.

---

  1. ALREADY HIDDEN

If:

/hide Zenpha

is executed while Zenpha is already hidden, do not duplicate anything.

Do not create duplicate teams.

Do not repeatedly modify the scoreboard.

Do not repeatedly overwrite the stored original TAB name.

Return:

Player Zenpha is already hidden.

---

  1. NOT HIDDEN

If:

/unhide Zenpha

is executed while Zenpha isn't hidden, return a clear message:

Player Zenpha is not hidden.

Do not cause errors.

---

  1. PERMISSIONS

Create permission:

hidename.use

Only players with this permission or server operators should be able to use:

/hide /unhide

Players without permission should receive:

You don't have permission to use this command.

Console should also be able to execute the commands.

---

  1. TAB COMPLETION

Implement tab completion.

For:

/hide Z

suggest online players beginning with:

Z

For:

/unhide Z

also provide player suggestions.

Use modern Paper-compatible command/tab-completion APIs.

---

  1. CONFIG.YML

Create a configurable:

config.yml

Example:

messages: no-permission: "&cYou don't have permission to use this command." player-not-found: "&cPlayer not found." hidden: "&a✔ &f%player% &ahas been hidden." already-hidden: "&e⚠ &f%player% &eis already hidden." unhidden: "&a✔ &f%player% &ahas been unhidden." not-hidden: "&e⚠ &f%player% &eis not hidden."

chat: remove-name-completely: true

Allow all messages to be customized.

Support Minecraft color codes such as:

&

or the modern Paper component system.

---

  1. CHAT CONFIGURATION

Add a configuration option to control the exact hidden-chat behavior.

Example:

chat: enabled: true remove-name-completely: true

When:

remove-name-completely: true

the hidden player's name should be completely removed from the chat rendering.

Example:

Zenpha: Hello!

becomes:

Hello!

If technically necessary because of the server's custom chat renderer, use the safest compatible implementation.

---

  1. NAMETAG IMPLEMENTATION

For the nametag, investigate the safest modern Paper 1.21.11 implementation.

Prefer Bukkit/Paper APIs over NMS.

A scoreboard Team may be used if it is the most reliable solution.

However:

DO NOT replace the entire player's scoreboard unnecessarily.

DO NOT break another plugin's scoreboard.

Do not create a team that conflicts with other plugins.

Use a unique internal team identifier.

For example:

hidename_hidden

or another safely namespaced identifier.

Before creating a team:

  • Check if it exists.
  • Avoid duplicate registration.
  • Avoid overwriting unrelated teams.

---

  1. SCOREBOARD SAFETY

This is very important.

Do NOT do:

player.setScoreboard(newScoreboard);

unless there is a very strong technical reason.

Doing so could break:

  • Sidebar scoreboard.
  • Other teams.
  • Prefixes.
  • Suffixes.
  • Other plugins.
  • Existing nametag configuration.

Use the player's existing scoreboard whenever safely possible.

If a different architecture is required for Paper 1.21.11, explain it and make the implementation as non-invasive as possible.

---

  1. TAB IMPLEMENTATION

Use the current Paper/Bukkit API for changing the displayed TAB name.

Investigate the current equivalent of:

Player#setPlayerListName(...)

If the API accepts Components, use the appropriate Component API.

When hiding:

TAB display name = blank

When unhiding:

TAB display name = original value

The player must remain in TAB.

---

  1. PRESERVE ORIGINAL TAB NAME

This is important for compatibility.

Suppose another plugin has changed Zenpha's TAB name to:

[VIP] Zenpha

When "/hide Zenpha" is executed, temporarily replace the displayed TAB name with blank.

Store the original value.

When "/unhide Zenpha" is executed, restore:

[VIP] Zenpha

Do not blindly restore only:

Zenpha

if an external plugin had previously customized it.

Use the safest practical approach.

---

  1. PRESERVE NORMAL PLAYER DISPLAY NAME

Do not permanently modify:

  • Player's actual username.
  • Game profile name.
  • UUID.
  • Skin.
  • Entity name.
  • Custom nickname data belonging to another plugin.

The hidden state should be a display-layer modification.

---

  1. DEATH AND RESPAWN

If the player is hidden and dies:

Zenpha → death → respawn

the hidden state must remain.

After respawn:

  • Nametag remains blank.
  • TAB remains blank.
  • Chat name remains hidden.

No manual "/hide" should be required again.

---

  1. WORLD CHANGE

If a hidden player changes worlds:

World → Nether

or:

Nether → Overworld

their name must remain hidden.

Do not accidentally reveal them during world change.

---

  1. TELEPORT

Teleporting should not reveal the name.

The hidden state should remain active after:

  • "/tp"
  • plugin teleport
  • portal teleport
  • respawn teleport
  • world change

---

  1. SERVER RESTART

The hidden state should persist after a normal server restart.

On startup:

  1. Load hidden UUIDs.
  2. When hidden players join, restore their hidden state.
  3. Apply blank nametag.
  4. Apply blank TAB name.
  5. Apply chat-name hiding.

Do not require manual reconfiguration.

---

  1. DATA STORAGE

Use a simple YAML data file, for example:

plugins/HideName/data.yml

Example:

hidden-players: - "uuid-1" - "uuid-2"

Save changes when:

  • Player is hidden.
  • Player is unhidden.
  • Plugin disables.
  • Other appropriate safe points.

Avoid excessive disk writes.

---

  1. PERFORMANCE

The plugin must be lightweight.

Do NOT run a repeating task every tick.

Do NOT constantly loop through every player.

Do NOT continuously send packets.

Only perform work when necessary:

  • "/hide"
  • "/unhide"
  • player join
  • respawn if needed
  • world change if needed
  • plugin startup
  • chat event

Avoid unnecessary operations.

---

  1. EVENTS

Use appropriate modern Paper/Bukkit events for:

  • PlayerJoinEvent
  • PlayerQuitEvent
  • PlayerRespawnEvent
  • PlayerChangedWorldEvent
  • PlayerTeleportEvent if required
  • modern chat event/API

Do not register unnecessary events.

Do not use deprecated APIs if a modern Paper 1.21.11 alternative exists.

---

  1. CHAT EVENT EDGE CASES

The chat implementation must correctly handle:

Hidden player sends chat

Name hidden.

Normal player sends chat

Completely normal.

Hidden player sends multiple messages

Every message should keep the name hidden.

Player gets unhidden

Next message should show the normal name.

Player rejoins while hidden

Chat name should remain hidden.

Player becomes hidden while online

The next chat message should use the hidden format immediately.

Player becomes unhidden while online

The next chat message should use the normal format immediately.

---

  1. DO NOT BREAK PRIVATE MESSAGES

Do not unnecessarily modify commands such as:

/msg /tell /w /r

unless the plugin specifically needs to.

The primary requirement is normal public chat.

Do not interfere with private messaging functionality.

---

  1. DO NOT CHANGE CHAT CONTENT

If Zenpha says:

My name is Zenpha

the plugin must NOT remove the word "Zenpha" from the message.

The plugin only hides the automatically generated sender name.

For example:

Zenpha: My name is Zenpha

should become:

My name is Zenpha

The word "Zenpha" typed inside the actual message must remain untouched.

This distinction is extremely important.

---

  1. CHAT EXAMPLE WITH PREFIX

If chat normally looks like:

[VIP] Zenpha: Hello!

the plugin should ideally make it:

[VIP] : Hello!

or:

[VIP] Hello!

depending on the renderer.

Do NOT remove:

[VIP]

unless the prefix itself contains the player's username and cannot be separated safely.

The main goal is to hide the actual player username.

---

  1. CHAT COMPONENTS

If the player's name is represented as a clickable/hoverable chat Component, the hidden state should remove or blank that component.

Do not leave the username inside:

  • Hover text.
  • Click event.
  • Suggest command.
  • Insertion text.

If the original username component has:

hover = show player info

make sure the hidden name is not accidentally exposed through that component if the goal is complete name hiding.

---

  1. SECURITY / PRIVACY OF DISPLAY

The purpose is visual name hiding.

Do not modify:

  • UUID.
  • Mojang account data.
  • Authentication.
  • Permissions.
  • Login system.
  • Player profile.

The actual username still exists internally; it is simply not displayed in the specified UI locations.

---

  1. ADMIN FEEDBACK

When admin executes:

/hide Zenpha

send:

✔ Zenpha has been hidden.

When:

/unhide Zenpha

send:

✔ Zenpha has been unhidden.

Make these configurable.

---

  1. OPTIONAL STATUS COMMAND

You may optionally implement:

/hidestatus <player>

which returns:

Zenpha is currently hidden.

or:

Zenpha is currently visible.

This is optional and should not interfere with the core commands.

---

  1. COMPLETE PROJECT STRUCTURE

Prefer a clean structure similar to:

HideName/ │ ├── build.gradle │ ├── settings.gradle │ └── src/ └── main/ ├── java/ │ └── your/package/ │ ├── HideNamePlugin.java │ ├── HideManager.java │ ├── HideCommand.java │ ├── UnhideCommand.java │ └── PlayerListener.java │ └── resources/ ├── plugin.yml └── config.yml

You may modify the architecture if a better Paper 1.21.11 implementation is available.

---

  1. DEPENDENCIES

The plugin should ideally have:

No external dependency

unless absolutely necessary.

Use the Paper API.

Do not require PlaceholderAPI, LuckPerms, TAB, Essentials, or another plugin for the core functionality.

If optional integrations are implemented, they must not be mandatory.

---

  1. PLUGIN.YML

Create a correct "plugin.yml" containing:

  • plugin name
  • version
  • main class
  • API version compatible with the target
  • commands
  • permissions

Example structure:

name: HideName version: 1.0.0 main: your.package.HideNamePlugin api-version: '1.21'

commands: hide: description: Hide a player's displayed name usage: /hide <player> permission: hidename.use

unhide: description: Show a player's displayed name usage: /unhide <player> permission: hidename.use

permissions: hidename.use: description: Allows using HideName commands default: op

Adjust anything that is technically required for Paper 1.21.11.

---

  1. JAVA VERSION

Use the Java version appropriate for Paper 1.21.11.

Prefer Java 21 if that is the correct runtime requirement for the target Paper version.

The project must compile successfully.

---

  1. BUILD SYSTEM

Use either:

Gradle

or:

Maven

Prefer Gradle if there is no reason to choose Maven.

Provide all required build configuration.

For example, explain:

./gradlew build

and on Windows:

gradlew.bat build

Then explain where the JAR will be generated, normally:

build/libs/

---

  1. INSTALLATION

Explain:

  1. Build the plugin.
  2. Locate the generated ".jar".
  3. Put it inside:

plugins/

  1. Start/restart the Paper 1.21.11 server.
  2. Check the console for successful loading.
  3. Use:

/hide <player>

---

  1. FINAL FUNCTIONAL EXAMPLE

Assume 25 players are online.

Zenpha is one of them.

Before hiding:

Above head

Zenpha

TAB

Zenpha

Chat

Zenpha: Hello guys!

After:

/hide Zenpha

Above head

[blank]

TAB

[blank]

Chat

Hello guys!

OR another clean format where Zenpha's automatically generated sender name is completely absent.

But:

Player entity

VISIBLE

Skin

VISIBLE

Armor

VISIBLE

Movement

NORMAL

Combat

NORMAL

Inventory

NORMAL

Chat ability

NORMAL

---

  1. UNHIDE EXAMPLE

After:

/unhide Zenpha

everything returns to normal:

Nametag

Zenpha

TAB

Zenpha

Chat

Zenpha: Hello guys!

---

  1. IMPORTANT API REQUIREMENT

Before producing the final code, verify that all APIs are actually valid for:

Paper 1.21.11

Do NOT copy old tutorials blindly.

Pay particular attention to:

  • Modern chat API.
  • Player display name APIs.
  • TAB list APIs.
  • Scoreboard Team APIs.
  • Component APIs.
  • Event APIs.
  • API deprecations.
  • Java version.
  • Paper plugin configuration.

If an API changed between older Minecraft versions and 1.21.11, use the current implementation.

---

  1. NO NMS UNLESS ABSOLUTELY REQUIRED

Prefer:

Paper API Bukkit API Adventure API

over NMS.

Only use NMS if the requested behavior genuinely cannot be implemented reliably through the public API.

If NMS is unavoidable:

  1. Explain why.
  2. Keep it isolated.
  3. Make it specifically compatible with Paper 1.21.11.
  4. Avoid unnecessary version-dependent code.

---

  1. TESTING REQUIREMENTS

After writing the code, mentally/test-review the following scenarios:

Test A — Basic Hide

/hide Zenpha

Expected:

  • Player remains visible.
  • Nametag username disappears.
  • TAB entry remains but username is blank.
  • Chat sender name is
Kodari AI
KodariSep 9 at 8:19 am 2
HideName
A Paper 1.21.11 plugin that hides a player's username from nametags, TAB list, and chat messages while keeping the player entity completely visible and functional. Not a vanish plugin - the player remains fully visible, movable, and interactive. Uses UUID-based persistent storage via YAML with admin commands like /hide, /unhide with tab completion, customizable config messages with color code support, and safe non-invasive scoreboard team implementation to preserve existing server displays. Supports all players joining and rejoining while maintaining hidden state, world changes, respawns, and teleports without revealing the name. Preserves original display names and prefixes when unhiding, and handles modern chat renderers and external plugin compatibility.

Implemented the complete HideName Paper 1.21.11 plugin.

Included:

  • /hide <player> and /unhide <player>

  • UUID-based persistent storage in plugins/HideName/data.yml

  • Blank TAB display name while keeping the player in TAB

  • Scoreboard-team nametag hiding without replacing player scoreboards

  • Modern Paper AsyncChatEvent renderer integration

  • Configurable chat name removal

  • Join, respawn, world-change, quit, and restart handling

  • Original TAB names preserved and restored

  • Permission: hidename.use

  • Console command support

  • Online-player tab completion

  • Configurable color-coded messages

  • Build configuration targeting Java 21 and Paper 1.21.11

  • README with build, installation, and compatibility notes

Build with Gradle:

Plain Text
gradle build

The generated JAR will be located in:

Plain Text
build/libs/

Copy it into the server’s plugins/ directory and restart the Paper server.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
README.md
settings.gradle
Code
11 526
src/main/java/com/kodari/hidename/HideNamePlugin.java
package com.kodari.hidename;

import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;

public final class HideNamePlugin extends JavaPlugin {
    private HideManager hideManager;

    @Override
    public void onEnable() {
        saveDefaultConfig();

        HiddenPlayerStore store = new HiddenPlayerStore(this);
        hideManager = new HideManager(this, store);
        PlayerListener listener = new PlayerListener(hideManager);
        Bukkit.getPluginManager().registerEvents(listener, this);

        HideCommand command = new HideCommand(this, hideManager);
        if (getCommand("hide") != null) {
            getCommand("hide").setExecutor(command);
            getCommand("hide").setTabCompleter(command);
        }
        if (getCommand("unhide") != null) {
            getCommand("unhide").setExecutor(command);
            getCommand("unhide").setTabCompleter(command);
        }
    }

    @Override
    public void onDisable() {
        if (hideManager != null) {
            hideManager.save();
        }
    }
}