Glossary

Every term in the guide, explained in plain English.

BeginnerReference

Every term used in this guide, in plain English. Hover a dotted word on any page to see its entry, or search here.

A

Abstract class: A class that cannot be created directly. It is a base for other classes, which fill in the methods it leaves empty. Inheritance, interfaces and annotations
Account: Your own username and password on the hosted guide, used to save your progress and join the leaderboard. Leaderboard
Action: What kind of interaction a PlayerInteractEvent describes: a click, or PHYSICAL for stepping on something. Project: Parkour course with timer
Action bar: The short line of text shown just above a player's hotbar, used for quick status messages. Titles, action bars, boss bars and sounds
Alias: Another name for the same command, such as /hi for /hello. Commands, part 1: simple commands
Annotation: A label starting with @, like @Override or @EventHandler, that gives extra information to Java or to Paper. Inheritance, interfaces and annotations
API: The set of classes and methods a plugin or program offers so other developers can use its features from their own code. Working with other plugins
api-version: The plugin.yml field that says which Minecraft version a plugin was written for, such as '26.3'. plugin.yml explained
Argument: A word typed after a command's name, like Alex and 5 in /paylevels Alex 5. Your code receives them as text. Commands, part 1: simple commands
Argument node: A Brigadier node for a value the player chooses, with a name for your code and a type the game checks. Commands, part 2: Brigadier command trees
Array: A fixed-size row of values of one type, numbered from 0. String[] args is an array of text. Lists, sets and maps
Assignment: Putting a value into a variable with a single =, such as coins = 80; the old value is replaced. Variables and types
Async: Running beside the main game loop instead of inside it, so slow work does not freeze the server. Threads, performance and lag
Async event: An event that fires off the main thread, such as AsyncChatEvent; its handlers must not change the world directly. Event priorities and canceling
Async scheduler: Runs your task on a worker thread, away from any region. It must not touch game objects. Folia and regionized scheduling
Atomic: An action that happens completely or not at all, so no other thread can see it half done. Threads, performance and lag
Attribute: A number that describes a living thing, such as its maximum health, walking speed or attack damage. Entities and mobs
Audience: Anything that can receive messages, titles and sounds: a player, the console, or the whole server. Text and colors with Adventure
Autocomplete: IntelliJ's list of names that fit where you are typing; pick one and it writes the full name for you. IntelliJ survival guide

B

Batching: Doing work in groups, a limited amount per tick, instead of all at once. Threads, performance and lag
Block: One cube of the world at a position. Containers like chests are blocks that also hold an inventory. Blocks and block data
Block: Lines of code between curly braces { } that belong together, such as the body of an if or a method. Making decisions: if, else and switch
Block physics: How the game reacts when a block changes: sand falls, torches pop off and water flows. Blocks and block data
BlockData: The settings of one block, such as which way stairs face or how old a crop is. Blocks and block data
BlockState: A snapshot copy of a block including its contents, such as chest items or sign text; call update() to apply changes. Blocks and block data
BlockType: The modern object for a kind of block, such as stone. It knows things like hardness and whether the block is solid. Registries, keys and data components
boolean: A Java type with only two values, true and false; every condition is a boolean. Variables and types
Bootstrapper: An optional class that implements PluginBootstrap and runs very early, before the worlds load, to register commands or registry changes. Paper plugins: paper-plugin.yml, bootstrapper and loader
Branch: A separate line of commits, used to try something new without touching the main line of work. Git and GitHub for plugin developers
Breakpoint: A red marker on a line of code where the debugger pauses the server so you can look at the values. Debugging like a pro
Brigadier: Mojang's command system, used by vanilla Minecraft and by Paper plugins. Commands are trees of typed nodes the game understands. Commands, part 2: Brigadier command trees
Build tool: A program that finds libraries, compiles your code and packs it into a jar. Gradle and Maven are build tools. Gradle and Maven reference
Builder: An object you configure step by step with chained method calls, then finish with build() to get the real thing. Commands, part 2: Brigadier command trees
Bytecode: The compact instructions in .class files that the Java Virtual Machine runs; the same bytecode works on every operating system. How code reads

C

Cache: A saved copy of an answer, kept so you do not have to work it out again each time. Threads, performance and lag
camelCase: Writing names with a small first letter and a capital at each new word, like sendRichMessage or maxHomes. How code reads
Cancelable event: An event that implements Cancellable, so a listener can stop the action with setCancelled(true). Events and listeners
Case sensitive: Capital and small letters count as different, so getPlayer and getplayer are two different names in Java. How code reads
Cast: Telling Java that a value is a more specific type, written like (Stairs) data; it fails if you are wrong. Inheritance, interfaces and annotations
Child components: Pieces of text appended after a component; they copy its style unless they set their own. Text and colors with Adventure
Chunk: A 16 by 16 block wide column of the world that the server loads, saves and ticks as one piece. Worlds, locations and movement
Chunk loading: Reading or generating a 16 by 16 piece of the world so it can be used. It is one of the slowest things a server does. Threads, performance and lag
Class: A named block of Java code that describes a kind of thing, like a blueprint; your plugin is made of classes. Classes and objects
Class file: A .class file made by the compiler from one Java class; the jar of a plugin is full of them. Compile Lab
Classloader: The part of Java that finds and loads the classes inside a jar; Paper plugins each get their own isolated one. Paper plugins: paper-plugin.yml, bootstrapper and loader
Classpath: The list of jars and folders where Java looks for the classes a program uses. Paper plugins: paper-plugin.yml, bootstrapper and loader
Click event: An action attached to text, such as running a command or opening a link, that happens when the player clicks it. Text and colors with Adventure
Client: The Minecraft game you start from the launcher; it draws the world and sends your clicks and keys to the server. What is a plugin?
Command: A word starting with a slash, like /hello, that runs plugin code when a player, the console or a command block uses it. Commands, part 1: simple commands
Command sender: Whoever runs a command: a player, the server console or a command block. In Java it is a CommandSender. Commands, part 1: simple commands
Command tree: The shape of a Brigadier command: a root word with branches of literals and arguments; each path to a runnable node is a valid command. Commands, part 2: Brigadier command trees
CommandExecutor: The classic Bukkit interface for commands: its onCommand method runs a command declared in plugin.yml. Obsolete since Paper 26.3. Commands, part 3: the classic plugin.yml way
Comment: A note for humans in code, after // or between /* and */, that the compiler ignores. How code reads
Commit: One saved snapshot of your project, with a short message that says what changed. Git and GitHub for plugin developers
Comparison operator: An operator such as ==, !=, <, <=, > or >= that compares two values and gives true or false. Operators and math
Compile: Turning the Java text you write into .class files the Java runtime can run; Gradle does it before packing the jar. How code reads
Compile error: A mistake in the grammar of your code that stops the compiler from building it, reported with a file and line number. How code reads
compileOnly: A Gradle setting that uses a library to compile your code but leaves it out of your jar. Working with other plugins
Compiler: The tool (javac) that checks your Java source code and translates it into bytecode in .class files. How code reads
Compiler error: A message from javac that names the file, the line and what is wrong, so the code cannot be built until you fix it. Compile Lab
Compiling: Turning source code into class files and checking it for mistakes, then packing the result into a jar. Compile Lab
CompletableFuture: Java's class for a future you can attach steps to, such as thenAccept, which runs when the result is ready. Folia and regionized scheduling
Component: Paper's type for formatted text: colors, styles, hover text and click actions in one object. Text and colors with Adventure
Compound assignment: A shortcut that changes a variable in place, such as coins += 25 for coins = coins + 25, or kills++. Operators and math
Concatenation: Gluing Strings together with +, such as "Hello, " + name; numbers and other values are turned into text. Working with text
ConcurrentHashMap: A map that many threads can read and change at the same time without breaking. Threads, performance and lag
Condition: A question with a true or false answer, written in round brackets after if, while or for. Making decisions: if, else and switch
Config file: A text file next to the plugin, usually config.yml, that the server owner edits to change settings without touching code. Configuration files
Configuration section: One indented block of a YAML config file, which you read by name and can look inside for more values. Configuration files
Console: The text window where a server prints what it is doing and where you can type server commands without a slash. Build, install and test
Constant: A named value that never changes, usually written static final with an UPPER_CASE name, like MAX_ZOMBIES. Variables and types
Constructor: The special method that runs when an object is created with new. It has the same name as the class. Classes and objects
Constructor injection: Giving a class what it needs, such as your plugin or a manager, through its constructor instead of looking it up. The main class and plugin lifecycle
Cooldown: A wait that players must sit out before they can use something again, stored as the time they may act next. Patterns: cooldowns, toggles and player state
Coordinates: The three pieces of text that name one library file: group, name and version. Gradle and Maven reference
CraftBukkit: The layer inside Paper whose Craft classes, like CraftPlayer, connect the public API to Mojang's server code. Server internals (NMS) with paperweight
Criteria: The rule that says what changes an objective's numbers: only your plugin (DUMMY) or the game itself, like health or deaths. Scoreboards, sidebars and teams
Custom event: An event class you write yourself and fire with callEvent(), so your plugin or other plugins can react to it. Making your own events

D

Data component: One named piece of information stored on an item, such as its name, lore or enchantments, set with item.setData(...). Items and ItemStacks
Data folder: Your plugin's own folder, plugins/YourPlugin/, where config.yml and your saved files live. The main class and plugin lifecycle
Datapack: A folder or zip of data files that changes game content, such as recipes, loot tables and enchantments, without code. Registries, keys and data components
Debugger: An IntelliJ tool that pauses your running plugin at chosen lines so you can inspect values step by step. Debugging like a pro
Declaration: The line that creates a variable by giving its type and name, such as int coins; often with a first value. Variables and types
Decorations: Text styles such as bold, italic, underlined, strikethrough and obfuscated (scrambled magic text). Text and colors with Adventure
Decoupling: Keeping parts of a program independent, so one part can change or be added without editing the others. Making your own events
Default value: The value a config read falls back to when the setting is missing from the file. Configuration files
Delay: How many ticks the scheduler waits before the first run of a task. Timing and tasks: the scheduler
depend: A plugin.yml list of plugins yours cannot work without; if one is missing, Paper does not load yours. plugin.yml explained
Dependency: A library your project needs, such as the Paper API, listed in the build file so Gradle can download it. Anatomy of a plugin project
Dependency injection: Giving a class the objects it needs through its constructor instead of letting it find them itself. Organizing a bigger plugin
Deprecated: Marked by its authors as old and replaced by something better. It may stop working in a later version. Using AI assistants well
Descriptor: The small file inside a plugin jar, plugin.yml or paper-plugin.yml, that tells the server the plugin's name, version and main class. Paper plugins: paper-plugin.yml, bootstrapper and loader
Dev bundle: A download from PaperMC that holds the server classes and API for one version, so Gradle can compile against them. Server internals (NMS) with paperweight
Display slot: A place on the screen that shows one objective: the sidebar, under player names, or the tab list. Scoreboards, sidebars and teams
do-while loop: A loop that runs its body first and checks the condition afterward, so it always runs at least once. Loops: doing things many times
Duration: A Java object that stands for an amount of time, such as Duration.ofSeconds(3) or Duration.ofMillis(500). Titles, action bars, boss bars and sounds

E

Eclipse Temurin: A free, widely used build of Java from the Eclipse Adoptium project; this guide uses Temurin 25. Your toolbox: Java, IntelliJ and Gradle
Enchantment: A magical bonus on an item, such as Sharpness or Efficiency. Every enchantment is a constant like Enchantment.SHARPNESS. Items and ItemStacks
Entity: Anything in the world that is not a block: players, mobs, arrows, dropped items, minecarts. Entities and mobs
Entity scheduler: Runs your task wherever an entity currently is, and calls a retired callback if the entity disappears first. Folia and regionized scheduling
Entry: Whatever owns a score on a scoreboard: usually a player's name, but it can be any text such as line-1. Scoreboards, sidebars and teams
Enum: A Java type with a fixed list of allowed values, such as LOBBY, PLAYING and SPECTATING. Enums, records and modern Java
Environment variable: A named setting that belongs to the operating system, so a program can read it without it being in the code. Git and GitHub for plugin developers
Escape: Writing a backslash before a character so it is shown as itself instead of having its special meaning. MiniMessage Studio
Escape sequence: A backslash plus a character inside a String that stands for a special character, such as for a new line. Working with text
Event: An object Paper creates when something happens in the game, like a player joining or a block breaking, so plugins can react. Events and listeners
Event handler: A method marked with @EventHandler that takes one event parameter; Paper calls it whenever that event happens. Events and listeners
Event priority: The turn a handler gets for an event: LOWEST runs first, then LOW, NORMAL, HIGH, HIGHEST, and MONITOR last. Event priorities and canceling
Exception: Java's way of reporting that something went wrong, like text that is not a number. Unhandled, it stops the current code. Null, exceptions and stack traces
Executor: The entity a command acts on. Usually the player who typed it, but /execute as can change it; null for the console. Commands, part 1: simple commands
Expansion: A PlaceholderAPI add-on class that answers placeholders with a certain first word, such as coins for %coins_balance%. Working with other plugins

F

Fall-through: In a classic switch without break, Java keeps running the code of the following cases too; usually a bug. Making decisions: if, else and switch
Field: A variable that belongs to an object and keeps its value for as long as the object lives. Classes and objects
File mode: Opening the guide's index.html directly in a browser; examples show recorded output instead of running. Welcome
Folia: A fork of Paper that splits the world into regions and ticks each region on its own thread, for very large servers. Folia and regionized scheduling
for loop: A loop with a start, a condition and a step in its header, such as for (int i = 0; i < 9; i++). Loops: doing things many times
For-each loop: A loop written for (Type item : collection) that runs its body once for every element. Loops: doing things many times
for-each loop: A loop that visits every item of an array or collection in turn: for (Player player : players). Loops: doing things many times
Fork: A copy of a software project that is continued separately, like Paper being built from Spigot. What is a plugin?
Format specifier: A code like %d, %s or %.1f in a String.format template that is replaced by a value. Working with text
Future: A promise of a result that will arrive later, like the answer of teleportAsync. You attach code to run when it arrives. Folia and regionized scheduling

G

Game rule: A world setting such as keepInventory that you can change with /gamerule or with world.setGameRule. Worlds, locations and movement
Generic type: A type with a type in angle brackets, like List<Player> or LiteralCommandNode<CommandSourceStack>, saying what it holds or works with. Lists, sets and maps
Git: The most popular version control tool. It runs on your PC and keeps your project's history in a hidden .git folder. Git and GitHub for plugin developers
GitHub: A website that stores online copies of Git repositories, so they are backed up and can be shared. Git and GitHub for plugin developers
Global region: Folia's special region for server-wide work that belongs to no place, such as weather, time and console commands. Folia and regionized scheduling
Global region scheduler: Runs your task on the global region, for server-wide jobs that are not tied to a place. Folia and regionized scheduling
Gradle: The build tool that downloads the Paper API, compiles your code and packs it into a plugin jar. Your toolbox: Java, IntelliJ and Gradle
Gradle wrapper: The gradlew.bat and gradle/wrapper files that download and run the exact Gradle version a project needs. Anatomy of a plugin project
Guard clause: An if statement at the start of a method that returns early when there is nothing to do, keeping the rest of the method flat. Making decisions: if, else and switch

H

Handle: The real Minecraft object behind an API object. For a Player it is a ServerPlayer, which you get with getHandle(). Server internals (NMS) with paperweight
Handler list: The static HandlerList in every event class that holds all handlers registered for that event. Making your own events
Hard dependency: A plugin listed under depend: yours loads only after it and refuses to load at all if it is missing. Working with other plugins
Hard fork: A fork that stops copying changes from its parent project and develops on its own, as Paper did from Spigot. What is a plugin?
Hex color: A color written as # and six digits or letters, two each for red, green and blue, like #ff8800 for orange. MiniMessage Studio
Hook: A small class that holds all the code touching another plugin, created only when that plugin is present. Working with other plugins
Hot path: Code that runs very often, such as a handler for player movement. Small waste there adds up fast. Threads, performance and lag
HotSwap: Replacing changed method code in a running server while debugging; it cannot add methods, fields or classes. Build, install and test
Hover event: A tooltip attached to text; it appears when the player points the mouse at that text. Text and colors with Adventure

I

IDE: Integrated development environment: a code editor that understands your code, such as IntelliJ IDEA. Your toolbox: Java, IntelliJ and Gradle
Identifier: A name you choose for a class, method or variable; letters, digits, _ and $, not starting with a digit. How code reads
if statement: Code that runs a block only when its condition is true, optionally with an else block for when it is false. Making decisions: if, else and switch
ignoreCancelled: An @EventHandler setting; with ignoreCancelled = true, Paper skips the handler when the event is already canceled. Event priorities and canceling
Immutable: Cannot be changed after it is created. Strings are immutable, so methods like toUpperCase return a new String. Working with text
Import: A line at the top of a Java file that tells Java which class you mean, such as import org.bukkit.entity.Player. Packages, imports and visibility
Index: A position in a String, array or list, counted from 0, so the first character is at index 0. Working with text
Infinite loop: A loop whose condition never becomes false, so it never ends; on a server it freezes the game. Loops: doing things many times
Inheritance: A Java type can be a more specific kind of another type and automatically gets everything that type can do. Inheritance, interfaces and annotations
Instance method: A method called on a specific object, like player.getHealth(), that works with that object's data. Classes and objects
Integer division: Dividing two whole numbers in Java, which drops the decimals: 7 / 2 gives 3, not 3.5. Operators and math
Interface: A Java type that lists methods a class promises to have; a class uses implements to make that promise. Inheritance, interfaces and annotations
Internals: The parts of the server that are not part of the public API, so nobody promises they will keep working. Server internals (NMS) with paperweight
Inventory: A numbered row of slots, each holding an item or nothing. Players, chests and menus all have one. Inventories
Inventory holder: An object that owns an inventory. A small holder class acts as a name tag so your plugin can recognize its own menus. Building GUI menus
Inventory holder: The object that owns an inventory, such as a chest block, a player or a small class you write to recognize your own menu. Inventories
ItemMeta: The older helper object for changing an item's name, lore and enchantments. You reach it safely with item.editMeta(...). Items and ItemStacks
ItemStack: A Java object for what sits in one inventory slot: a material, an amount and extra data such as a name or enchantments. Items and ItemStacks
ItemType: The modern object for a kind of item, such as the diamond sword. It knows the item's defaults, like its stack size. Registries, keys and data components
Iteration: One trip through a loop's body; a loop over 9 slots has 9 iterations. Loops: doing things many times
Iterator: An object that walks through a collection one item at a time and can safely remove items. Lists, sets and maps

J

Jar: A Java archive: one zip-style file holding compiled classes and resources, the file a plugin is shipped in. What is a plugin?
Java: The programming language Minecraft and Paper plugins are written in. Your toolbox: Java, IntelliJ and Gradle
Javadoc: The written descriptions above classes and methods in Java source code, shown by IntelliJ with Ctrl+Q. IntelliJ survival guide
JDK: The Java Development Kit: Java plus the tools to compile code. Paper 26.3 plugins need JDK 25. Your toolbox: Java, IntelliJ and Gradle
JRE: Java Runtime Environment: enough to run Java programs, but without the compiler, so not enough to make plugins. Your toolbox: Java, IntelliJ and Gradle
JVM (Java Virtual Machine): The program that runs Java bytecode. The java command starts one, and a Paper server runs inside one. How code reads

K

Key: The name before the colon on a YAML line, such as name or version; the part after the colon is its value. plugin.yml explained
Keyword: A word reserved by Java's grammar, such as class, void, if or return, that you cannot use as a name. How code reads

L

Label: The name a command was typed with, such as hello in /hello. With aliases, several labels can lead to the same command. Commands, part 1: simple commands
Lambda: A short piece of code written with an arrow, like event -> { ... }, that you pass to a method to run later. Lambdas, method references and streams
Leaderboard: A public list of the players with the most XP, shown only for people who chose to appear on it. Leaderboard
Legacy color codes: The old way to color text with codes like &a or section signs; MiniMessage does not read them. MiniMessage Studio
Level: A number that goes up as you collect XP, calculated the same way as the experience level of a Minecraft player. Leaderboard
Lexicon: A list of words and phrases with a meaning attached; the classifier uses one to link phrases like "log in" to the right Paper event. Plugin Idea Classifier
License: A note that tells other people what they may and may not do with your code. Releasing and sharing your plugin
Lifecycle event: A moment in the server's life, such as building the command list, that plugins can hook into with getLifecycleManager(). Commands, part 1: simple commands
List: An ordered collection of values in Java, such as the lines of an item's lore. Lists, sets and maps
Listener: A class that implements Listener and contains event handlers, so Paper can call your code when events happen. Events and listeners
Literal: A value written directly in code, such as 42, 20.0, true or "Hello". Working with text
Literal node: A fixed word in a Brigadier command that the player types exactly, such as give in /tools give. Commands, part 2: Brigadier command trees
Live mode: The guide opened with Start Guide.cmd, so it can run Java programs, compile plugins and start a test server on your PC. Welcome
Loader: An optional class that implements PluginLoader and builds your plugin's classpath, for example by downloading libraries at startup. Paper plugins: paper-plugin.yml, bootstrapper and loader
Localhost: An address that always means this computer, used to join a server running on your own PC. Test Server
Logger: The object from getLogger() that writes lines to the server console with your plugin's name in front. The main class and plugin lifecycle
Logical operator: && (and), || (or) and ! (not), which combine or flip true/false values. Operators and math
Loop: Code that runs the same block many times, for example once for every online player. Loops: doing things many times
Loop body: The block inside a loop's curly braces; it runs once per round of the loop. Loops: doing things many times
Lore: The lines of description text under an item's name in its tooltip. You set it as a list of components. Items and ItemStacks
LTS: Long-term support: a Java version, such as 21 or 25, that gets updates for years, so tools and servers settle on it. Your toolbox: Java, IntelliJ and Gradle

M

Main class: The one class in a plugin that extends JavaPlugin; plugin.yml names it, and Paper creates it when the plugin loads. The main class and plugin lifecycle
Main thread: The thread that runs the game 20 times a second; most Paper API calls, and all world changes, must happen on it. Threads, performance and lag
Map: A lookup table in Java: you give it a key, such as a player's UUID, and it gives back the value stored for that key. Lists, sets and maps
Mappings: A dictionary that turns scrambled class and method names back into readable ones. Since 26.1 the game ships readable names. Server internals (NMS) with paperweight
Markdown: A plain text style where # makes a heading and - makes a list item, used for README files. Releasing and sharing your plugin
Material: A fixed list of every block and item type in the game, such as STONE or DIAMOND_SWORD. Blocks and block data
Maven: Another Java build tool, configured with a pom.xml file; it does the same job as Gradle and puts jars in target. Gradle and Maven reference
Memory leak: Memory that nothing needs any more but that is never freed, so it keeps growing, like a map of players who left long ago. Patterns: cooldowns, toggles and player state
Merge conflict: What happens when two branches changed the same lines and Git needs you to choose which version to keep. Git and GitHub for plugin developers
Method: A named block of code inside a class that does one job and can be called again and again. Methods: reusable actions
Method body: The lines between a method's curly braces; they run every time the method is called. Methods: reusable actions
Method call: Running a method by writing its name with round brackets and any arguments, like formatTime(125). Methods: reusable actions
Method reference: A short way to pass a method as code, written ClassName::methodName, like HealCommand::healSelf. Lambdas, method references and streams
MiniMessage: Paper's text format that uses tags like <gold> and <bold> to color and style messages. MiniMessage: easy formatted text
MSPT: Milliseconds per tick: how long the server really needs to finish one tick. It must stay under 50. Threads, performance and lag

N

Naive Bayes: A simple way for a computer to learn from examples: it counts which words usually appear with which labels and uses those counts to guess new ones. Plugin Idea Classifier
Namespace: The part of a key before the colon. It says who owns the name: minecraft for the game, or your plugin's name. Registries, keys and data components
Namespaced key: The name a saved value is stored under, made of your plugin's name and a lowercase word, so it cannot clash with other plugins. Saving data on things: PersistentDataContainer
NamespacedKey: A unique name made of an owner and a key, like myplugin:ruby_pickaxe, used for recipes and other game resources. Custom crafting recipes
Naming convention: The shared habit of how to write names: camelCase for methods and variables, PascalCase for classes, UPPER_SNAKE_CASE for constants. How code reads
Nested loop: A loop inside another loop; the inner loop runs completely for every round of the outer one. Loops: doing things many times
NMS: Short for net.minecraft.server: Mojang's own server code, which plugins can reach into but which changes with almost every update. Server internals (NMS) with paperweight
NoClassDefFoundError: A crash that happens when your code uses a class from a plugin or library that is not installed on the server. Working with other plugins
Node: One step in a command tree, either a fixed word (literal) or a typed value (argument). Commands, part 2: Brigadier command trees
Non-valued component: A data component that is only on or off, like unbreakable. Having it is the whole message. Registries, keys and data components
Null: Java's word for "no object here". Calling a method on null crashes, so check for it first. Making decisions: if, else and switch
NullPointerException: The error Java throws when code calls a method on null, a variable that holds nothing. Null, exceptions and stack traces

O

Obfuscation: Scrambling names in compiled code, like a to z, so it is hard to read. Mojang stopped doing this to Minecraft in 26.1. Server internals (NMS) with paperweight
Object: One thing created from a class, such as one Player object that stands for one connected person. Classes and objects
Objective: A scoreboard item that holds scores and can be shown on screen, for example as the sidebar on the right. Scoreboards, sidebars and teams
Off-by-one error: A loop that runs one time too many or too few, often from writing <= where < was needed. Loops: doing things many times
OfflinePlayer: A smaller type for a player who may be offline; it knows the name, UUID and play history only. Working with players
Operator: A symbol that does something with values, such as + to add, == to compare or && to combine true/false values. Operators and math
Operator precedence: The order Java works out operators in: parentheses first, then * / %, then + -, then comparisons, then && and ||. Operators and math
Overflow: When a number goes past its type's limit and wraps around, so the largest int plus one becomes a huge negative number. Variables and types
Overloading: Several methods with the same name but different parameters; Java picks one by the arguments you pass. Methods: reusable actions
Override: To replace a method that a parent class already has with your own version, marked with @Override. Inheritance, interfaces and annotations

P

Package: A named folder for Java classes, such as com.example.myplugin, that keeps classes organized and their names unique. Packages, imports and visibility
Packet: One small message sent over the network between the server and a player's game, such as 'show this action bar text'. Server internals (NMS) with paperweight
Paper: Popular Minecraft server software that runs plugins and adds a large, modern plugin API on top of Bukkit and Spigot. What is a plugin?
paperweight: PaperMC's Gradle tooling. The userdev plugin lets your project compile against the server's own classes. Server internals (NMS) with paperweight
Parameter: A value a method receives when it is called, listed in the brackets after the method's name, like sender or args. Methods: reusable actions
Parse: Read text and turn it into a value, such as Integer.parseInt("64") giving the number 64. Variables and types
Particle: A tiny flying picture, like smoke or a heart, that the server shows players; it looks nice but changes nothing. Potion effects, particles and effects
PATH: A Windows list of folders that the terminal searches, in order, when you type a program name such as java. Your toolbox: Java, IntelliJ and Gradle
Pattern matching: Writing x instanceof Player player checks the type and, if it matches, gives you a ready-to-use variable of that type. Inheritance, interfaces and annotations
Period: How many ticks pass between the runs of a repeating task. Timing and tasks: the scheduler
Permission: A named right such as myplugin.fly that decides whether a player may use a feature. Permissions
Permission node: The dotted text name of a permission, such as myplugin.kit.vip, written from general to specific. Permissions
Persistent data container: A notebook attached to a player, block or item that Minecraft saves for you, so your plugin's values survive restarts. Saving data on things: PersistentDataContainer
PersistentDataContainer: A small data store attached to a player, block or item, saved with the world. Saving data on things: PersistentDataContainer
Phases: The fixed steps Maven runs in order, such as compile, test and package. Asking for one runs all before it. Gradle and Maven reference
Placeholder: A tag like <name> in a MiniMessage template that is filled in with a value; Placeholder.unparsed inserts it as plain text. MiniMessage: easy formatted text
Plugin: A jar of compiled Java code that a Paper server loads at startup to add features, commands and reactions to the game. What is a plugin?
Plugin lifecycle: The fixed order in which Paper loads, enables and disables a plugin, calling onLoad, onEnable and onDisable. The main class and plugin lifecycle
plugin.yml: The file in src/main/resources that tells Paper a plugin's name, version, main class, api-version, dependencies and permissions. plugin.yml explained
plugin.yml: The small text file inside every plugin jar that tells the server the plugin's name, version, main class and api-version. plugin.yml explained
Portable: Code that works unchanged in several environments, here both on Paper and on Folia. Folia and regionized scheduling
Potion effect: A timed change to a living thing, like Speed or Regeneration, with a type, a duration in ticks and an amplifier. Potion effects, particles and effects
PowerShell: The command language that the Windows 11 terminal runs; it needs a dot and backslash in front of programs in the current folder. Your toolbox: Java, IntelliJ and Gradle
Primitive type: One of Java's eight built-in lowercase types: int, long, double, float, boolean, char, byte and short. Variables and types
Profiler: A tool that watches a running program and shows which parts use the most time. Threads, performance and lag
Program: A list of instructions the computer carries out in order, from top to bottom. How code reads
Project: A folder with your plugin's code, resources and build files that IntelliJ opens and Gradle builds. Anatomy of a plugin project
Projectile: An entity that flies on its own after being thrown or shot, such as a snowball, an arrow or a fireball. Entities and mobs
Prompt: The message you send to an AI assistant. The clearer it is, the better the answer. Using AI assistants well
Prototype: The default components every item of one type starts with. A stack stores only what you changed on top. Registries, keys and data components

Q

Quick fix: A ready-made correction IntelliJ offers when you press Alt+Enter on a problem, such as adding a missing import. IntelliJ survival guide

R

Race condition: A bug where two threads change the same thing at once and the result depends on who is faster. Threads, performance and lag
Recipe: A rule that turns ingredients into a result at a crafting table, furnace, stonecutter or smithing table. Custom crafting recipes
RecipeChoice: A rule for what an ingredient slot accepts: one item, any of several item types, or one exact custom item. Custom crafting recipes
Record: A short way to write a class that just holds values; Java creates the constructor and getters for you. Enums, records and modern Java
Records: Short classes that only hold values; Java writes the constructor and readers for you. Enums, records and modern Java
Refactoring: Changing how code is organized, such as renaming or moving things, without changing what it does. IntelliJ survival guide
Region: A group of nearby loaded chunks that Folia ticks together on one thread, separate from other regions. Folia and regionized scheduling
Region scheduler: Runs your task on the region that owns a given location, so it is safe to touch blocks there. Folia and regionized scheduling
Regionized: Split into regions that run in parallel, like Folia's world, instead of one single main thread. Folia and regionized scheduling
Registries: The game's official lists of things like enchantments, damage types and paintings that can be looked up by key. Registries, keys and data components
Registry: The server's list of everything of one kind, such as every sound, that you can look up by its key. Registries, keys and data components
RegistryAccess: Paper's front door to every registry. Ask it for a registry by its RegistryKey. Registries, keys and data components
RegistryKey: The name of a registry itself, such as RegistryKey.ENCHANTMENT. You pass it to RegistryAccess to get that registry. Registries, keys and data components
Regular expression: A short pattern that describes text to look for, such as whole words from a list. Working with text
Relocation: Renaming a shaded library's package inside your jar so it cannot clash with another plugin's copy. Gradle and Maven reference
Remote: Another copy of your repository somewhere else, such as on GitHub. The usual name for it is origin. Git and GitHub for plugin developers
Renderer: The piece that builds the final chat line from the player, the name and the message. Project: Chat formatter and filter
Repository: A project together with all its saved history. People usually call it a repo. Git and GitHub for plugin developers
Resolver: What selector and position arguments give you: call resolve(source) to turn @p or ~ ~1 ~ into real players or positions. Commands, part 2: Brigadier command trees
Retired callback: Code you give the entity scheduler to run instead of your task if the entity is removed before the task could run. Folia and regionized scheduling
Return value: The result a method hands back with return; it takes the place of the call in your code. Methods: reusable actions
Run configuration: A saved IntelliJ button, like Run Paper Server or Build Plugin Jar, that runs a task with one click. IntelliJ survival guide
Runtime error: A problem that happens while code runs, after it compiled fine, such as dividing by zero. Java reports it as an exception. How code reads

S

ScheduledTask: The handle you get back from the newer schedulers. You can call cancel() on it to stop the task. Folia and regionized scheduling
Scheduler: The part of Paper that runs your code later or repeatedly, measured in ticks, without freezing the server. Timing and tasks: the scheduler
Scope: The part of the code where a variable exists: the block, such as a method or if, that created it. Methods: reusable actions
Score: The whole number an entry has in an objective; in a sidebar it decides the line's position. Scoreboards, sidebars and teams
Scoreboard: Minecraft's built-in system of objectives, scores and teams, behind sidebars, name tag colors and hearts under names. Scoreboards, sidebars and teams
Scoreboard manager: The object from Bukkit.getScoreboardManager() that hands out the main scoreboard and new empty scoreboards. Scoreboards, sidebars and teams
SDK: Software development kit; in IntelliJ's settings, the JDK a project uses to understand and compile Java. IntelliJ survival guide
Secret: Anything that gives access to something, such as a password, token or webhook address. Never put it in Git. Git and GitHub for plugin developers
Section: A group of related settings in a YAML file, written as a heading with indented lines under it. Configuration files
Semantic versioning: A system of three numbers, MAJOR.MINOR.PATCH, where each number tells how big the change was. Releasing and sharing your plugin
Serializer: A converter between a component and another format, such as plain text, old color codes or JSON. Text and colors with Adventure
Server: The program that runs a Minecraft world for players to join; Paper is a server, and it runs your plugins. What is a plugin?
Server console: The text window of a running server: it prints the log and accepts commands typed without a slash. Test Server
ServerPlayer: Mojang's own class for a player on the server. The API's Player is a wrapper around it. Server internals (NMS) with paperweight
Service: An interface that a plugin registers with the ServicesManager so that other plugins can use its features. Working with other plugins
ServicesManager: Paper's registry where plugins offer interfaces, called services, that other plugins can look up without knowing who provides them. Working with other plugins
Set: A collection where each thing is either in or out, with no duplicates, such as the players who have build mode on. Lists, sets and maps
Shading: Copying a library's classes into your own jar so the plugin carries everything it needs. Gradle and Maven reference
Shadow plugin: The Gradle plugin (com.gradleup.shadow) that adds the shadowJar task for shading and relocation. Gradle and Maven reference
Shaped recipe: A crafting recipe where the position of each ingredient in the grid matters, like a pickaxe. Custom crafting recipes
Shapeless recipe: A crafting recipe that only needs the right ingredients, in any slots of the grid. Custom crafting recipes
Short-circuiting: Java skips the right side of && or || when the left side already decides the answer, which makes null checks safe. Making decisions: if, else and switch
Short-circuiting: && and || skip their right side when the left side already decides the answer, which makes null checks safe. Operators and math
Snapshot: A copy of something taken at one moment; changing the copy does not change the original until you apply it. Blocks and block data
Soft dependency: A plugin listed under softdepend: it loads first when installed, but your plugin still loads without it. Working with other plugins
softdepend: A plugin.yml list of plugins yours uses if installed; Paper enables them first but loads yours either way. plugin.yml explained
Source code: The text you write in .java files; people can read it, and the compiler turns it into bytecode. How code reads
spark: A profiler that Paper includes. The /spark command shows what your server spends its time on. Threads, performance and lag
Stack trace: The error report Java prints when code crashes: the exception, then the methods that were running, with file and line numbers. Null, exceptions and stack traces
Staging area: The list of changes Git will put into your next commit. git add puts changes on it. Git and GitHub for plugin developers
Stale object: A Player object kept after the player left; it no longer stands for anyone in the game. Working with players
State machine: A way to organize behavior where something is in exactly one state at a time and events move it to another state. Patterns: cooldowns, toggles and player state
Statement: One complete instruction in Java, usually ending with a semicolon, such as IO.println("Hi");. How code reads
Static: Belonging to the class itself instead of one object, so you can use it without having an object, like Bukkit.getServer(). Classes and objects
Static method: A method that belongs to a class rather than an object, called on the class name, like Math.max(7, 12). Classes and objects
String: Java's type for text. A String literal is written between double quotes, like "Hello". Working with text
StringBuilder: A changeable text buffer you fill with append and turn into a String with toString; efficient for building long text. Working with text
Style: The color, bold, italic and other looks of one piece of text, plus any click or hover action attached to it. Text and colors with Adventure
Subcommand: A fixed word after the command name that picks a feature, such as give in /tools give. Commands, part 2: Brigadier command trees
Superclass: The parent class a class extends; the child class inherits every method the parent has. Inheritance, interfaces and annotations
Superinterface: An interface that another type extends. The type can do everything its superinterfaces can do. Where to go next
switch: A statement that compares one value against a list of cases and runs the code for the matching case. Making decisions: if, else and switch
Switch expression: An arrow-style switch that produces a value, has no fall-through and must cover every possible input. Making decisions: if, else and switch
System.nanoTime: A Java method that returns a very precise timer value in nanoseconds, good for measuring how long code takes. Threads, performance and lag

T

Tag: A word in angle brackets, such as gold or /bold, that switches a style on or off in MiniMessage text. MiniMessage: easy formatted text
TagResolver: An object that tells MiniMessage what to put in place of a tag, such as a placeholder named name. MiniMessage: easy formatted text
Tags: Built-in groups of blocks or items, like Tag.LOGS for every kind of log, kept up to date by Mojang. Blocks and block data
Task: One job Gradle knows how to do, such as build, clean or runServer. Build, install and test
Team: A group of scoreboard entries that share a name prefix, a color and rules like collisions and name tag visibility. Scoreboards, sidebars and teams
Terminal: A window where you type commands instead of clicking. IntelliJ has one built in at the bottom. Your toolbox: Java, IntelliJ and Gradle
Ternary operator: A one-line choice between two values: condition ? valueIfTrue : valueIfFalse. Making decisions: if, else and switch
Tests: Small programs that call your code and check the result, so the guide can tell you what works and what does not. Practice Arena
Text block: A multi-line String written between triple double quotes; line breaks and quotes inside need no escapes. Working with text
Thread: One line of work a program runs; a server runs several at once, but the game itself runs on the main thread. Threads, performance and lag
Thread-safe: Safe to use from several threads at the same time without breaking. Threads, performance and lag
Thread-safe: Safe to use from several threads at the same time without breaking or losing data. Threads, performance and lag
Tick: One step of the game loop, one twentieth of a second; 20 ticks make one second. Timing and tasks: the scheduler
Tick: One step of the game loop; the server runs 20 ticks per second, so one tick is 50 milliseconds. Timing and tasks: the scheduler
Tick budget: The 50 milliseconds the server has to finish all its work in one tick. Threads, performance and lag
Tile entity: A block that carries extra data, such as a chest with items, a sign with text or a spawner with a mob type. Blocks and block data
Toggle: A switch you flip on and off with the same command. Project: Chat formatter and filter
Tool window: A panel on the edge of the IntelliJ window, such as the project tree, Run window, Gradle window or terminal. IntelliJ survival guide
Toolchain: A Gradle setting that says which Java version compiles the project; Gradle finds or downloads that Java by itself. Your toolbox: Java, IntelliJ and Gradle
Tooltip: Extra text the game shows when the player hovers over something, such as a command suggestion. Commands, part 2: Brigadier command trees
TPS: Ticks per second. A healthy server runs exactly 20 of them. Lower means the server is falling behind. Threads, performance and lag
Transitive dependencies: Libraries that your library needs in turn. The build tool downloads them automatically. Gradle and Maven reference
Trigger: The thing that makes a plugin do something, such as a player joining, a block breaking, a command or a timer. Events and listeners
Type: The kind of value a variable can hold, such as int for whole numbers, double for decimals or String for text. Variables and types
Type inference: Letting Java work out a variable's type from its value with var; the type is still fixed afterwards. Variables and types
TypedKey: A key that also remembers which registry it belongs to, so the compiler can stop you mixing up items and enchantments. Registries, keys and data components

U

UUID: A long unique id that every player has and that never changes, even if they rename their account. Time, UUIDs and randomness

V

Valued component: A data component that carries a value, like a name (text) or a stack size (number). Registries, keys and data components
Vanilla: Plain Minecraft exactly as Mojang makes it, with no plugins, mods or changes. What is a plugin?
Variable: A named box that holds a value, such as Player player or int online, so later lines can use it. Variables and types
Version control: A tool that saves snapshots of your project so you can look back at old versions and undo mistakes. Git and GitHub for plugin developers
Version number: The number that names one release of your plugin, like 1.4.0, so owners know which one they have. Releasing and sharing your plugin

W

while loop: A loop that checks its condition before every round and repeats as long as it is true. Loops: doing things many times
Wrapper: An object that holds another object and offers a friendlier or safer way to use it. Server internals (NMS) with paperweight

X

XP: Experience points: you earn them in this guide by finishing pages and solving practice challenges, and they raise your level. Leaderboard

Y

YAML: A text format for settings that uses key: value lines and indentation with spaces; plugin.yml and config.yml are written in it. plugin.yml explained