# Glossary > Verified against **Minecraft 26.3** · Reference · A short entry > per term the rest of the corpus uses, and a link to the page that owns it. Every page in this corpus assumes the vocabulary of the pages before it. That is deliberate — a lecture that redefines "chunk holder" every time it appears is unwatchable — but it means a reader who arrives in the middle has no way back. This page is the way back: the terms, alphabetically, a short entry each, each pointing at the page where the term is actually explained. An entry here is a *reminder*, not a definition to rely on. If the entry is all you needed, good; if it is not, the link is the point of the entry. Where a term is a class name, the class name is the entry — this corpus uses Mojang's names for concepts as well as for types, and inventing a second vocabulary to sit beside them would only double the work. ## A **Activity** — the filter that decides which of a brain's behaviours may start at all, rather than a mode it runs in: the active set is always the core activities plus exactly one other, and an `ActivityData` declares each one's prioritised behaviour list. → [AI](../systems/entities/ai-goals-and-brains) **Advancement** — a data-pack-defined goal: criteria, a requirements expression over them, an optional display entry and a reward. → [advancements](../systems/commands/advancements) **Aquifer** — the worldgen component that decides what a point is made of once the density is known — stone, air, water or lava — from its own barrier and fluid-level noises; a carver only marks a shape, and the aquifer decides what fills each block of it. → [terrain](../systems/worldgen/terrain) **Argument type** — a Brigadier `ArgumentType` that parses one *argument* off the command line, however many words that takes — three for a `Vec3Argument`, all of the rest for a `MessageArgument`; vanilla's live in `net/minecraft/commands/arguments` and are described to the client through an `ArgumentTypeInfo`. → [Brigadier and commands](../systems/commands/brigadier-and-commands) **Atlas** — one large texture stitched at load time out of many sprite files, so a chunk section's quads can all be drawn with one bound colour texture. → [models and atlases](../systems/rendering/models-and-atlases) **Attribute** — a named, ranged, modifiable number on a `LivingEntity`; modifiers are keyed by `Identifier`, and eight attributes are not client-syncable at all. → [attributes](../systems/entities/attributes) **Authority** — whose copy of an entity produces the position that counts: the server for a mob, the owning client for its own player and for the boat that player is steering — the server still runs your player's physics, then overwrites its answer with the number your client sent. Five predicates on `Entity` decide it, starting with the final `Entity.isLocalInstanceAuthoritative`. → [authority](../systems/entities/authority) **Avatar** — the class between `LivingEntity` and `Player`, holding the player-shaped body and nothing else; a `Mannequin` is an `Avatar` that is not a player. → [player anatomy](../systems/player/player-anatomy#the-ladder-and-the-class-in-the-middle) ## B **Batch** (game tests) — a group of game tests that share an environment and a dimension, and the key they are grouped by *is* that pair rather than a name. The renderer's *batch* is a different word: quads grouped by render state, which belongs to [section meshing](../systems/rendering/section-meshing#what-the-compiler-makes) and [entity rendering](../systems/rendering/entity-rendering). → [game tests](../systems/commands/game-tests) **Beardifier** — the density-function term that bends terrain around a structure; terrain adaptation writes no blocks, it changes the noise. → [structure placement](../systems/worldgen/structure-placement) **Behaviour** — one unit of brain AI, gated on memories and asked once a tick; unless it overrides `Behavior.canStillUse` it stops inside the same `Brain.tick` that started it, so everything it does it does in `Behavior.start`, or, for a one-shot, in its trigger. → [AI](../systems/entities/ai-goals-and-brains) **Biome** — a named bundle of generation settings, block tints and environment attributes, attached to a 4×4×4 volume of the world; its mob spawns are one of those attributes. → [biomes](../systems/worldgen/biomes) **BiomeSource** — the object that answers "which biome is at this quart position": by a climate search, from one fixed biome, from a checkerboard of a listed few, or, in the End, from the central island's disc and a single erosion sample beyond it; all but the fixed and checkerboard sources make a separate `BiomeResolver` to answer. → [biomes](../systems/worldgen/biomes) **Blaze3D** — Mojang's graphics layer: *com/mojang/blaze3d* keeps `RenderSystem`, the window and the frame graph, and the GPU abstraction under it is *com/mojang/renderpearl*, with OpenGL and Vulkan backends behind one `GpuDevice`. → [Blaze3D](../systems/rendering/blaze3d) **Blend alpha** — the mixing weight `Blender` computes from the distance to the nearest measured old column: zero against the seam, where the old measurement sets the offset and fixed values the factor and jaggedness, and one out of range (use the noise). → [blending at the old-chunk border](../systems/worldgen/blending) **`BlendingData`** — the sixteen-column ring of heights, densities and biomes one of these measures out of its **own** chunk's blocks, on the sides facing ground the game has yet to generate; its presence on a chunk is what makes the chunk old. → [blending at the old-chunk border](../systems/worldgen/blending) **Block** — the singleton describing a kind of block: its behaviour, its property set and its state table. One `Block`, many `BlockState`s. → [blocks and states](../systems/blocks/blocks-and-states) **Block entity** — the per-position mutable state a block cannot fit into its state (a chest's contents, a furnace's progress), stored on the chunk. → [block entities](../systems/blocks/block-entities) **Block event** — a message from a block to itself (a piston push, a note block, a chest lid), queued on `ServerLevel` and drained at one named phase of the level tick — a wait for a phase rather than a delay, so it usually runs in the very tick it was raised — and mirrored to nearby clients as a packet. → [pistons and block events](../systems/blocks/pistons-and-block-events#the-queue-and-which-tick-it-drains-in) **BlockState** — one combination of a block's property values, built once by the block's `StateDefinition` and compared by identity; `Block.BLOCK_STATE_REGISTRY` is the flat table that numbers it for the wire and the global palette. → [blocks and states](../systems/blocks/blocks-and-states) **Border tick** — a position along an old chunk's seam queued for post-processing, so a leaf or a fluid there is re-evaluated when the chunk goes live. → [blending at the old-chunk border](../systems/worldgen/blending) **Boss bar** — a `ServerBossEvent` holding a name, a progress float, a colour, an overlay style and three client effects (darkened screen, boss music, world fog), broadcast to the players attached to it; the `/bossbar` kind adds an integer value and maximum, persists its membership as UUIDs, and is `execute store`'s third sink. → [scores, teams and stored data](../systems/commands/scoreboard-and-data#the-third-sink-is-a-boss-bar-and-it-is-this-pages-shape-again) **Brain** — the memory-and-behaviour AI that twenty mob classes build, villagers, piglins and axolotls among them, as opposed to the older goal system. → [AI](../systems/entities/ai-goals-and-brains) **Brigadier** — Mojang's command-parsing library: a tree of literal and argument nodes with per-node requirements, shared by client and server. → [Brigadier and commands](../systems/commands/brigadier-and-commands) **Built-in block model** — a block model attached in code by `BuiltInBlockModels` rather than by a resource pack, living in a second model table that terrain never reads; how a minecart or a block display draws a chest. → [block-entity rendering](../systems/rendering/block-entity-rendering#the-chests-block-model-is-empty-and-there-are-two-tables-of-them) ## C **Camera** — the client's eye: position, rotation and the cull frustum, copied into a `CameraRenderState` once per frame — plus an `EnvironmentAttributeProbe` that `Camera.tick` advances and no render state carries. → [the frame](../systems/rendering/the-frame) **Carver** — a worldgen pass that hollows out caves and ravines by marking their shape in a mask and writing no block itself; what each marked block becomes — air, water or lava — is the `Aquifer`'s answer, in the Nether as everywhere else. → [terrain](../systems/worldgen/terrain) **Cell** — the lattice unit of terrain noise, four blocks wide and deep and eight tall in the overworld, 768 to a chunk: the expensive three-dimensional density terms are evaluated at its corners and interpolated within it. → [terrain](../systems/worldgen/terrain#filling-the-noise-six-loops-one-number-at-the-bottom), [density functions](../systems/worldgen/density-functions) **Chunk** — a 16-by-16 column of the world's full height: sections, heightmaps, block entities, tick queues and a status. → [chunk anatomy](../systems/world/chunk-anatomy) **Chunk layer** — which of the three `ChunkSectionLayer` buffers a block's quads are meshed into — solid, cutout or translucent — decided at bake time from the alpha inside that quad's own patch of its sprite, unless its material forces translucency, rather than from the block; the mesher only reads the answer, except for leaves, which it overrides. → [models and atlases](../systems/rendering/models-and-atlases#a-quads-chunk-layer-is-read-out-of-the-sprites-pixels) **ChunkHolder** — the server's per-chunk record of the *level* the loading graph computed for it, a future per threshold and status, and what changed in it this tick; which tickets asked for that level is `TicketStorage`'s business, not the holder's. → [tickets and loading](../systems/world/tickets-and-loading) **ChunkMap** — the server's chunk table: holders, the ticket-driven level graphs, entity tracking, and the region-file storage underneath. → [tickets and loading](../systems/world/tickets-and-loading) **ChunkStatus** — one rung of the generation ladder; a chunk advances one status at a time, and the `ChunkStep` for each status declares the neighbour radius that step needs. → [the chunk generation pipeline](../systems/world/chunk-generation-pipeline) **Climate** — the noise sample (temperature, humidity, continentalness, erosion, depth, weirdness) a biome is chosen by. → [biomes](../systems/worldgen/biomes) **Codec** — a DataFixerUpper object that both encodes and decodes one type against any `DynamicOps`; the corpus's universal serialisation vocabulary. → [codecs, NBT and JSON](../systems/foundations/codecs-nbt-json) **CommandSourceStack** — *who is running this command, and from where*: position, rotation, level, entity, a `PermissionSet` and an output sink, immutable, so a `with…` that changes something returns a copy. → [Brigadier and commands](../systems/commands/brigadier-and-commands) **Compiled query** — the immutable `EntitySelector` a parse produces: thirteen fields and no grammar, resolvable any number of times against different sources. → [entity selectors](../systems/commands/entity-selectors#compile-what-a-box-is-and-where-it-comes-from) **Component** — two different things the corpus keeps apart: a *data component* on an item stack, and a `Component` of chat text. → [data components](../systems/foundations/data-components), [text components](../systems/foundations/text-components) **Connection** — the tail handler of one Netty pipeline plus the channel it holds, with exactly one packet listener at a time, swapped when the protocol phase changes. → [the connection](../systems/networking/the-connection#one-packet-there-and-one-back) **Container** — the interface a thing with item slots implements (a chest, a hopper, an inventory), as distinct from the *menu* a player interacts with it through. → [containers and menus](../systems/items/containers-and-menus) **Criterion** — two different things the corpus keeps apart: one condition inside an advancement, backed by a `CriterionTrigger` the server fires when the relevant thing happens; and a scoreboard objective's `ObjectiveCriteria`, which is what the objective counts. → [advancements](../systems/commands/advancements#a-criterions-conditions-are-loot-conditions), [scores, teams and stored data](../systems/commands/scoreboard-and-data) ## D **DamageSource** — the *what hit you, and who is responsible* record every damage calculation and death message reads. → [damage and death](../systems/entities/damage-and-death) **Data component** — a typed, codec-backed value keyed by a `DataComponentType`: a patch over the item's prototype on a stack, a whole map on a block entity, a view over its own fields and its type's prototype on an entity; what NBT item tags became. → [data components](../systems/foundations/data-components) **Data-driven type** — the book's name for the shape a dozen systems share: a registry of *types*, each type a codec, and an instance a `Codec` produced from JSON, dispatched on its own type field. Fifty-six registries follow it. → [the data-driven type pattern](../systems/foundations/data-driven-types#the-idea-stated-once) **Data pack** — a pack of JSON, structure NBT and function files supplying the server's data-driven content; the server half of the resource system. → [the resource system](../systems/foundations/resource-system#discover-the-repository-and-its-packs) **DataLayer** — the nibble array one section's block light or sky light lives in, owned by the light engine and never by the section. → [lighting](../systems/world/lighting) **Debug subscription** — a registered kind of debug value a client can ask the server for; half the kinds the server polls, diffs and sends only when they change, and the rest it pushes as they happen. → [debugging the running game](../systems/client/debugging-the-running-game#the-idea) **DeltaTracker** — the client's clock: how much of a tick has elapsed, and the source of every partial tick in the frame but the lightmap's and a frozen camera entity's, each a literal one. → [the client loop](../systems/client/the-client-loop) **Density function** — a node in the JSON-defined graph that turns a position into a number, but only once compiled into a `DensitySampler`: the graph in the registry is never the graph that actually runs. → [density functions](../systems/worldgen/density-functions) **Dialog** — a data-pack-defined form the server can put on a player's screen, whose submitted values come back as a packet. → [dialogs](../systems/commands/dialogs) **Dimension** — one `ServerLevel` and its `DimensionType`: a height range, a set of environment attributes and its own chunk storage. → [level data and rules](level-data-and-rules#dimensions-and-the-seed) ## E **Enchantment** — a data-pack record of effect components, most of them conditioned on loot predicates; its registry is synchronised, but a client that already has the pack is sent only the id. → [enchantments](../systems/items/enchantments) **Entity** — a thing the level ticks in its own right: a position, a bounding box, synched data and a tick method. A *block entity* is not one. → [entity anatomy](../systems/entities/entity-anatomy) **EntityType** — the registry entry for a kind of entity: its factory, category, size, feature flags and the two numbers that decide how it reaches clients. Spawn rules are keyed *by* the type in `SpawnPlacements`, not held on it. → [entity anatomy](../systems/entities/entity-anatomy) **EnvironmentAttribute** — a per-dimension, per-biome, per-time-of-day, per-weather value resolved through a stack of layers: directly on the server, through the camera's smoothing probe on the client. Not only the visual ones: alongside fog and sky colour sit twenty-three gameplay attributes — whether lava flows fast, whether piglins zombify, whether a bed works, and the villager's schedule. → [environment attributes and timelines](../systems/world/environment-attributes-and-timelines#the-stack-a-value-falls-through) **Event loop** — the queue-and-thread pairing `BlockableEventLoop` is: an owning thread that drains posted tasks and, through `BlockableEventLoop.managedBlock`, keeps draining while it waits. `Minecraft` and `MinecraftServer` are both one — but only the server rations the drain against a time budget; the client empties the queue every frame. → [the server tick](../systems/server/server-tick#the-event-loop-and-what-a-ticks-spare-time-buys) **Experiment** — a built-in data pack whose `PackSource` is `PackSource.FEATURE`, enabling one non-vanilla `FeatureFlag`; switching one on in the create-world screen is a data-pack reload. → [creating a world](../systems/worldgen/creating-a-world) **Extract** — the first half of the client's frame: walk the game state, cull it, and write the render states, so that the drawing half reads no live game state from `LevelRenderer.render` down but what a few snapshots hold by reference (a moving block's light, a sign's text, a section compiled on the spot) — the top of the render half still does. The top-level states are single objects re-filled each frame, not fresh immutable values. → [the frame](../systems/rendering/the-frame) ## F **Feature** — the algorithm half of decoration: what to build, with no say in which positions it is offered. → [features and placement](../systems/worldgen/features-and-placement) **Feature flag** — a bit in a `FeatureFlagSet`, which is a 64-bit mask and the `FeatureFlagUniverse` it belongs to. There is one universe and four flags in it: vanilla and three experiments. A registry element that is a `FeatureElement` carries a set, and a lookup narrowed by the world's enabled set hides it — the registry is still frozen, and the *view* is what changed. → [identifiers and registries](../systems/foundations/identifiers-and-registries#feature-flags-the-same-registry-narrowed) **Flat level generator preset** — a display item plus a `FlatLevelGeneratorSettings`, one row of the Superflat *Presets* screen; nine ship. → [creating a world](../systems/worldgen/creating-a-world#the-layer-editor-edits-the-generator-you-already-have) **Fluid** — the registry object behind a `FluidState`, a source and a flowing instance per liquid, with `FlowingFluid` holding the spread algorithm and `LiquidBlock` the block form. → [fluids](../systems/world/fluids) **Font** — a resource-pack-defined glyph source plus the measuring and wrapping API on top of it; a glyph is baked into a texture the first time its font set is asked for it, and again after a reload or a font-option toggle. → [text and fonts](../systems/client/text-and-fonts) **Frame** — two different things the corpus keeps apart. In Part XI it is one pass of the client's render loop, the unit *partial tick*, *extract* and the frame graph are all relative to ([the frame](../systems/rendering/the-frame#update-and-extract-six-clocks-in-one-frame)). In Part XIII it is the execution engine's unit of a running function: a depth, a result callback that `/return` feeds sideways, and a control that can delete the frame's pending work — one object shared by reference across a whole function body, and deliberately *not* a stack frame. → [the execution engine](../systems/commands/the-execution-engine) **Frame graph** — the client's per-frame declaration of render passes and the targets each reads and writes, resolved before anything is drawn. → [visibility and the frame graph](../systems/rendering/visibility-and-the-frame-graph#declaring-the-passes-and-why-none-of-them-is-ever-culled) **Function** — a `.mcfunction` file: a list of commands loaded as a `CommandFunction`, optionally with macro lines. → [functions and macros](../systems/commands/functions-and-macros) ## G **Game event** — a broadcast fact about something that just happened at a position (a block placed, a door opened) that sculk sensors and mobs listen for. → [game events and vibrations](../systems/world/game-events-and-vibrations#a-game-event-is-one-number) **Game rule** — one typed, server-wide switch or number in `GameRules`, saved with the world and sometimes sent to the client. → [level data and rules](level-data-and-rules#game-rules-are-a-registry) **Game test** — a data-driven test instance: a structure, an environment and a check the server runs and reports on. → [game tests](../systems/commands/game-tests) **Globally-rendered block entity** — one whose renderer says `BlockEntityRenderer.shouldRenderOffScreen`, so the client keeps it in a level-wide set and draws it whether or not its section is visible; three renderers qualify. → [block-entity rendering](../systems/rendering/block-entity-rendering#off-screen-means-off-this-list) **Goal** — one unit of the older mob AI: a start condition, an answer to whether it may be interrupted, and the set of `Goal.Flag` controls it claims while running. The priority belongs to the `WrappedGoal` that holds it, and the flag table rather than the priority is what arbitrates. → [AI](../systems/entities/ai-goals-and-brains) **GpuDevice** — the façade every GPU resource is created through; both graphics backends sit behind it as `GpuDeviceBackend` implementations. A draw reaches the driver through the `CommandEncoder` it hands out and the `RenderPass` that opens. → [Blaze3D](../systems/rendering/blaze3d) **GuiRenderState** — the 2D render tree: strata of nodes that infer their own layering from bounding boxes and are batched into draw calls at the end of the frame. → [the GUI render tree](../systems/client/the-gui-render-tree) ## H **Heightmap** — a per-chunk 2D array holding the first *free* Y above the topmost block matching a predicate; six types exist, and a live chunk keeps the four that survive worldgen and any asked for since. → [chunk anatomy](../systems/world/chunk-anatomy) **Holder** — a reference to a registry entry that can exist before the entry is bound: `Holder.Reference` for a registered value, `Holder.Direct` for an inline one. → [identifiers and registries](../systems/foundations/identifiers-and-registries#the-table) **HolderSet** — a set of holders: either a tag (`HolderSet.Named`) or a literal list. → [tags](../systems/foundations/tags) **HUD** — the in-world overlay (hotbar, hearts, chat, boss bars), which is the class `Hud`; `Gui` is the screen and overlay manager that holds it. → [the HUD](../systems/client/hud) ## I **Identifier** — a namespace and a path; the id of everything. A 1.21-era reader knows it as *ResourceLocation*. → [identifiers and registries](../systems/foundations/identifiers-and-registries#the-name) **Ingredient** — a recipe's "any of these items" test. It cannot be an empty inline list, but a tag that resolves to nothing makes one empty — and a recipe holding it is never placeable. → [recipes](../systems/items/recipes#loading-one-scan-one-swap-and-four-indexes-built-later) **Integrated server** — the `MinecraftServer` a singleplayer client runs on its own Server thread. Every change to the *world* still crosses as a packet; a handful of settings cross by direct call. → [anatomy](../systems/anatomy/anatomy#what-singleplayer-shares-by-direct-call) **InteractionResult** — the answer a block or item gives to a click: was the input consumed, should the arm swing, did the held item change. → [block interaction](../systems/blocks/block-interaction#block-then-empty-hand-then-item) **Item** — the singleton for a kind of item, holding none of the components a stack shows; a stack is a holder to one of these, a count, a pop time and a patched component map — the item's defaults plus the ways this stack differs from them. → [items and stacks](../systems/items/items-and-stacks) **ItemStack** — the object in a slot: a final class holding a count, a pop time, a `Holder` of `Item`, and a patch of data components over the item's prototype. Only the last is really data; equality is the prototype plus the patch, which is why two identical-looking stacks may refuse to merge. → [items and stacks](../systems/items/items-and-stacks#four-fields-and-only-one-of-them-is-really-data) **ItemStackTemplate** — the immutable item-shaped record (an item holder, a count, a component patch) that data uses where a live, mutable `ItemStack` would be wrong. → [items and stacks](../systems/items/items-and-stacks) ## J **Jigsaw** — the structure-assembly system that grows a village out of template pieces by matching connector blocks. → [jigsaw and templates](../systems/worldgen/jigsaw-and-templates) ## K **KeyMapping** — one bindable action: whether its key is down, plus a counter of owed clicks that `KeyMapping.consumeClick` **drains** rather than edge-detects. → [input and keybinds](../systems/client/input-and-keybinds) ## L **Level** — a world: `ServerLevel` on the server, `ClientLevel` on the client, sharing an abstract `Level` that carries most of the behaviour — `ClientLevel` differs by *hollowing out* inherited methods rather than by implementing fewer of them. The word is also a number elsewhere: a *ticket level* is how strongly a chunk is held, a *permission level* is one of five ranks, and an *enchantment level* is an enchantment's strength. → [the level tick](../systems/server/server-level-tick), [the client level](../systems/client/the-client-level) **Lightmap** — the small texture the client samples to turn a block-light / sky-light pair into a colour; drawn on the GPU once per tick. → [lightmap, fog and sky](../systems/rendering/lightmap-fog-and-sky) **LivingEntity** — the rung of the entity tree that can be hurt and healed: health, attributes, mob effects, equipment and the shared movement code. It holds 124 of `Entity`'s 192 descendants and has exactly three direct subclasses — `Avatar`, `ArmorStand` and `Mob`. → [entity anatomy](../systems/entities/entity-anatomy#the-tree-and-the-class-that-was-inserted-into-it) **LocalPlayer** — the `Player` a human steers: its own `ClientInput`, and the last input and position it sent. The block predictions it seems to own are the level's. → [player anatomy](../systems/player/player-anatomy#the-three-sides-of-one-player) **Loot condition** — a predicate in the loot package's own vocabulary (`LootItemCondition`), asked with a loot context; the same objects the `/execute if predicate` check runs, under a different name. → [contexts and predicates](../systems/items/contexts-and-predicates#what-reads-a-context) **Loot context** — the bag of *what was involved* — the level, the position, the tool, the killer, the block entity — that every loot roll, predicate and conditional enchantment effect is asked against; a `LootContext` built to satisfy exactly one parameter set. → [contexts and predicates](../systems/items/contexts-and-predicates#inputs-then-one-invocation) **Loot table** — the data-driven roll that turns an event (a block broken, a mob killed, anything at all reading a container that has not been rolled yet) into item stacks. → [loot tables](../systems/items/loot-tables) ## M **Macro** — a function line beginning with a `$` substitution. The plain lines of the file are parsed once at load; a macro line is substituted and **re-parsed** per distinct argument tuple, cached only eight deep. → [functions and macros](../systems/commands/functions-and-macros) **Memory** — one typed, optionally expiring value in a `Brain`; behaviours are gated on which memories are present, absent or merely registered. → [AI](../systems/entities/ai-goals-and-brains) **Menu** — the object behind an open container screen, one copy on each side: slots and a state id, and on the server's copy the synchroniser that sends its changes to the client. → [containers and menus](../systems/items/containers-and-menus) **MinecraftServer** — the object that *is* the server: the thread, the tick loop, every `ServerLevel`, the player list and the registries the world was loaded with. Singleplayer runs one too, as an `IntegratedServer` inside the client's process. → [the server tick](../systems/server/server-tick#the-cast) **MultiPlayerGameMode** — the client's channel for acting on the world: every break, place, use and attack goes through it, and the ones that predict open a prediction window before they send. → [prediction and acknowledgement](../systems/client/prediction-and-acks) ## N **NBT** — Minecraft's binary tag format: a sealed `Tag` hierarchy whose scalars are records and whose containers (`CompoundTag`, `ListTag`) are final classes, read and written through `NbtIo` and reached by codecs through `NbtOps`. → [codecs, NBT and JSON](../systems/foundations/codecs-nbt-json) **NBT path** — a compiled query over a tag, six node kinds deep — a named child, an index, all elements, and three kinds of match — that `/data` uses to read and write, and which materialises the compounds and lists it walks through on a write, though an index never creates the element it names. → [scores, teams and stored data](../systems/commands/scoreboard-and-data#the-path-language-and-the-accessor-that-is-coarser-than-it-looks) **Neighbour update** — the server-only notification a block sends its six neighbours after a change; distinct from a *shape update*, which runs on both sides. → [blocks and states](../systems/blocks/blocks-and-states#the-two-update-channels) **NoiseChunk** — the per-chunk workspace (a height query builds a one-column one of its own): it binds the dimension's compiled samplers to one context that grants the caches the density-function graph asked for and carries the chunk's beardifier and blender, and it holds the chunk's `Aquifer`. → [density functions](../systems/worldgen/density-functions#wrap-once-per-chunk) **NoiseRouter** — the eight density functions a generator asks for, as one record: six are the climate, which `NoiseRouter.createClimateSampler` turns into a `Climate.Sampler`; *chunk_surface_level* is the surface pass's; and *final_density* is the one the fill samples. → [density functions](../systems/worldgen/density-functions) ## O **Objective** — a named scoreboard column: a criterion, a display name, a render type and a number format. Only the *dummy* and *trigger* criteria wait for commands; every other one — including every statistic in the game, since `Stat` extends `ObjectiveCriteria` — is driven from `ServerPlayer`. → [scores, teams and stored data](../systems/commands/scoreboard-and-data#what-a-criterion-can-be-which-is-nearly-anything) **Occlusion** — four unrelated questions the corpus asks with one word, and no page owns all four. *Does this section hide that one* is the visibility graph's, and the answer is a walk rather than a test ([visibility and the frame graph](../systems/rendering/visibility-and-the-frame-graph#the-walk-that-decides-what-exists-and-the-frustum-that-only-trims-it)). *Does this face stop light, or hide the face against it* is a shape question every `BlockState` precomputes — a field on the state itself rather than anything in its shape cache ([math and primitives](math-and-primitives#shapes-and-collision)) — and it is, beside a block's light dampening, what ends a sky column ([lighting](../systems/world/lighting#the-sky-column-is-a-table-not-a-flood)); the fluid wall test asks the same question of two blocks' *collision* shapes, to decide whether fluid may pass between them ([why the wall test is affordable](../systems/world/fluids#why-the-wall-test-is-affordable)). *Ambient* occlusion is none of that: it is the per-quad shading the mesher bakes in ([section meshing](../systems/rendering/section-meshing)). And a vibration's occlusion is a six-ray raycast for `BlockTags.OCCLUDES_VIBRATION_SIGNALS` that reports occluded only if **all six** are stopped ([game events and vibrations](../systems/world/game-events-and-vibrations#the-gates-between-a-footstep-and-a-candidate)). A page always means exactly one of the four; the word is the only thing they share. **Old chunk** — a chunk whose `ChunkAccess.blendingData` is non-null, which is to say one whose save data carried a *blending_data* compound; `ChunkAccess.isOldNoiseGeneration` is the test. → [blending at the old-chunk border](../systems/worldgen/blending) ## P **Packet** — an interface: a `PacketType`, which is a name and a direction, and one handler method. It comes in three shapes, each class but the bundle packet and its delimiter declares its wire form as a `StreamCodec`, which the phase's protocol description dispatches to by the packet's type, and two dozen types are registered into more than one phase. → [packets and stream codecs](../systems/networking/packets-and-stream-codecs#a-packet-is-a-value-a-name-and-a-direction) **PalettedContainer** — the bit-packed storage a chunk section keeps its block states and biomes in, with a palette that grows as the section gets more varied. → [chunk anatomy](../systems/world/chunk-anatomy) **Parameter set** — the declared contract between a loot context and the things asked against it: a `ContextKeySet` naming which `ContextKey`s must be present and which may be. Building a context with a parameter the set does not allow, or without one it requires, throws; asking for one that is absent gives nothing; and loading a table reports an element that reads a key its set does not allow — the three ways a parameter can be missing. All thirty-one sets are listed in [loot context parameter sets](loot-context-params). → [contexts and predicates](../systems/items/contexts-and-predicates#a-set-is-a-contract-and-the-caller-signs-it) **Partial tick** — the fraction of a tick elapsed at the moment a frame is drawn, used to interpolate the world. There is no single one: a frame carries six values, they disagree on purpose, and two of them, the one screens are handed among them, are not fractions of a tick at all. → [the frame](../systems/rendering/the-frame#update-and-extract-six-clocks-in-one-frame) **Particle** — a client-only object with a position, a velocity and an age, most of them a textured quad, ticked by the `ParticleEngine` and extracted from it each frame. Nothing about it is authoritative: it is spawned locally, by prediction, by the ambient scatter or on a packet or level event, and the server is told the player's particle setting and never acts on it. → [particles](../systems/rendering/particles#does-the-particle-happen-at-all) **Path** — the list of nodes a navigator is following, produced by `PathFinder`'s A\* over a snapshot of already-loaded chunks, with a `NodeEvaluator` deciding what each candidate block *is* to this mob. → [pathfinding](../systems/entities/pathfinding) **Permission atom** — a named capability with an `Identifier` (`Permission.Atom`), the other kind of permission besides a command level; an operator's level-based set grants exactly one, the entity-selector atom, from gamemaster up. → [permissions](../systems/commands/permissions#a-question-an-answer-and-a-check) **Permission level** — one rung of `PermissionLevel` (all, moderators, gamemasters, admins, owners), and only the *ordered* half of a permission: a command source carries a `PermissionSet` and a node requires a `PermissionCheck`, neither of which is an integer. → [permissions](../systems/commands/permissions#a-question-an-answer-and-a-check) **Permission set** — what a command source carries and a node's check is asked against: on the server a level-based set (a rung plus one atom). The client rebuilds four of those from the op level it is told — rung zero maps to `PermissionSet.NO_PERMISSIONS` instead — and keeps a chat set built by subtraction beside them. No packet carries a `PermissionSet` itself. → [permissions](../systems/commands/permissions#where-a-set-comes-from) **PlacedFeature** — a feature plus an ordered list of placement modifiers; the unit a biome names. → [features and placement](../systems/worldgen/features-and-placement) **Player** — the shared player class: the inventory and ender chest, the open menu, the abilities, the food and experience bars, sleep, and the cooldowns. `ServerPlayer` is its server subclass, `LocalPlayer` and `RemotePlayer` its client ones (through `AbstractClientPlayer`), and an `Avatar` is the rung above it. → [player anatomy](../systems/player/player-anatomy#what-player-owns) **Point of interest** — a block state the game has decided is worth walking to: a bed, a job site, a portal. `PoiManager` indexes them by position, in its own files beside the chunks. → [points of interest](../systems/world/points-of-interest) **Prediction ledger** — the corpus's name for `BlockStatePredictionHandler`: the client's record of what the server is known to have at a block it changed optimistically. The ack is a receipt for a number, not a verdict — it settles every entry at or below it, writing back a correction if one arrived and rolling the block back if none did. → [prediction and acknowledgement](../systems/client/prediction-and-acks#the-four-writes) **Protocol phase** — one of handshaking, status, login, configuration and play; each has its own packet table and its own listener. → [protocol phases](../systems/networking/protocol-phases#the-five-phases) ## Q **Quart** — a four-block cell, the resolution biomes are stored and sampled at; `QuartPos` is the arithmetic, tabulated with the other coordinate spaces in [math and primitives](math-and-primitives#the-coordinate-spaces). → [biomes](../systems/worldgen/biomes) ## R **Random tick** — a turn a block gets that nobody booked: aimed at no block, carrying no promise, and drawn from the *entity*-ticking chunk set rather than the wider block-ticking one a scheduled tick uses — so there is a ring of chunks where appointments come due and nothing is ever chosen at random. → [scheduled ticks](../systems/world/scheduled-ticks#the-other-kind-of-turn-random-ticks) **Recipe** — a server-side matcher and assembler; no `Recipe` ever crosses the wire. The client gets a `RecipeDisplay` and a `RecipeDisplayId`, which is a position in a list rather than the recipe's name. → [recipes](../systems/items/recipes) **Region file** — the 32-by-32-chunk container file chunks are stored in, addressed by a sector table at its head. → [chunk storage](../systems/world/chunk-storage#inside-a-region-file) **Registry** — a frozen, id-assigning table of one kind of thing; some are built into the jar, some are loaded from data packs, some are sent to the client, and the 161 registry keys are listed in [registries](registries). → [identifiers and registries](../systems/foundations/identifiers-and-registries#the-table) **Reload listener** — the unit of a reload: one object that reads what it needs off the worker pool and swaps its live state on the owning thread, every apply running in order behind a `PreparableReloadListener.PreparationBarrier`. → [the resource system](../systems/foundations/resource-system#prepare-every-listener-at-once) **Render state** — the snapshot of what to draw, produced by the extract half of the frame and consumed by the drawing half; the property that matters is that the drawing half reads no game state below `LevelRenderer.render` but what a few snapshots hold by reference (see *Extract* for where the wall actually is). → [the frame](../systems/rendering/the-frame#the-wall-and-the-one-level-at-which-it-is-real) **RenderPipeline** — the client's declaration of how to rasterise: shaders, blend, depth, cull, vertex format, topology. It says nothing about which textures to bind, which `RenderType` adds, or which target to draw into, which is the one its `RenderPass` was opened on. → [Blaze3D](../systems/rendering/blaze3d) **RenderType** — a `RenderPipeline` plus the textures to bind and the layering and batching rules. Neither says which target to draw into: a `RenderType` draws into whatever `RenderPass` its caller has opened. → [Blaze3D](../systems/rendering/blaze3d) **Resource pack** — a pack of assets; the client half of the same pack machinery data packs use. → [the resource system](../systems/foundations/resource-system#discover-the-repository-and-its-packs) ## S **SavedData** — a named, codec-backed blob stored beside the world (the border, the weather, the rules, raids, the dragon fight); `level.dat` itself is nearly a stub. → [level data and rules](level-data-and-rules#two-saved-data-storages-neither-of-them-the-overworlds) **Scheduled tick** — a block or fluid position queued to run at a named future tick, with a priority breaking ties inside that tick. → [scheduled ticks](../systems/world/scheduled-ticks) **Score** — one number for one holder under one objective, reached through a `ScoreAccess` handle rather than a setter. → [scores, teams and stored data](../systems/commands/scoreboard-and-data) **Screen** — one full-window client UI with its own widget tree and lifecycle; the server is told nothing about most of them. → [GUI and screens](../systems/client/gui-and-screens) **Section** — a 16-cubed piece of a chunk: one paletted container of block states, one of biomes, and four counters. Its light lives in the light engine's own storage, not on the section. → [chunk anatomy](../systems/world/chunk-anatomy) **Section mesh** — what one section compiled to (`CompiledSectionMesh`): a draw record per layer into the shared vertex arenas, the visibility set, the block entities and the translucent layer's sort state, rebuilt when the section is both dirty and visible — usually on a worker, but inline on the Render thread when the chunk-builder option asks for it. → [section meshing](../systems/rendering/section-meshing#what-the-compiler-makes) **Selector head** — the single character after the *@* (*a*, *e*, *n*, *p*, *r*, *s*) that sets a selector's default limit, order and entity scope before any option is read; three of the six also pin the type to player, and two instead add an aliveness test. → [entity selectors](../systems/commands/entity-selectors#parse-six-heads-and-twenty-one-names) **Sensor** (brains) — the half of brain AI that writes memories from the world, on a fixed interval. A *sculk sensor* is a block and a different subject ([one footstep, and the ticks it takes to arrive](../systems/world/game-events-and-vibrations#one-footstep-and-the-ticks-it-takes-to-arrive)). → [AI](../systems/entities/ai-goals-and-brains) **ServerEntity** — the server's per-tracked-entity bookkeeping: what the watching clients were last told, and what to send them next. → [what the client is told](../systems/networking/what-the-client-is-told#one-entitys-tick-and-the-gates-it-does-not-pass) **ServerPlayer** — the server's copy of a player: the entity, the connection's listener, the game-mode object and the session state, all on one class. `LocalPlayer` is the client's answer to it, `RemotePlayer` the client's copy of anyone else, and all three share `Player`. → [player anatomy](../systems/player/player-anatomy#the-three-sides-of-one-player) **Shape update** — the "your neighbour changed, recompute yourself" call that runs on both client and server, unlike a neighbour update. → [blocks and states](../systems/blocks/blocks-and-states#the-two-update-channels) **Signed message** — a chat message carrying a signature over its content and its place in a per-player chain, so the server, and every client that holds the sender's session, can check who said it. → [chat and signing](../systems/networking/chat-and-signing#what-the-signature-covers) **Simulation distance** — how far the world *ticks*, as against how far you can see: the radius behind `TicketType.PLAYER_SIMULATION`, deciding which chunks tick blocks, fluids and entities. → [tickets and loading](../systems/world/tickets-and-loading) **Special model renderer** — a hand-written submitter for a shape no cuboid model can express, reached from an item model or a block state rather than from a block entity; thirteen of them. → [block-entity rendering](../systems/rendering/block-entity-rendering#where-rendererspecial-borrows-its-geometry) **Staging buffer** — in the command engine, the list an executing action appends its spawned commands to, spliced onto the *head* of the queue after it runs — which is what makes an `ArrayDeque` behave as a call stack. → [the execution engine](../systems/commands/the-execution-engine#the-queue-four-moments-apart) **Status effect** — a `MobEffect` held on a `LivingEntity` with an amplifier and a duration; the ones that change a number mostly do it by attaching an attribute modifier, and others are read where the number is used, jump boost, slow falling and levitation among them. → [status effects](../systems/player/status-effects#what-an-effect-is) **StreamCodec** — the wire counterpart of a `Codec`: encodes to and decodes from a `ByteBuf`, with no schema and no field names. → [packets and stream codecs](../systems/networking/packets-and-stream-codecs#the-codec-layer-is-small-and-composition-is-all-of-it) **Structure** — a generated building or landmark: a placement lottery, a start assembled in memory, and pieces written a chunk at a time. → [structure placement](../systems/worldgen/structure-placement) **StructurePiece** — one room, corridor or slab of a structure. In the hand-built half it is a Java class that writes its own blocks and, in the procedural graphs, constructs its own neighbours, chosen by no pool; the jigsaw half's `PoolElementStructurePiece` is one too. Every piece carries a registered `StructurePieceType`, which is how it comes back off disk. → [hand-built structures](../systems/worldgen/hand-built-structures#the-idea) **StructureStart** — one decided structure: the `Structure`, the chunk it started in, a `PiecesContainer`, a reference count and a cached bounding box, stored on the chunk it began in. → [structure placement](../systems/worldgen/structure-placement) **Submit node** — one thing to draw that is not terrain, written into `SubmitNodeStorage` by the *submit* pass out of the render states extract left behind, and sorted into a phase before the feature renderers turn it into vertices; the fifteen phases and the twelve renderers are listed in [submit phases](submit-phases). → [entity rendering](../systems/rendering/entity-rendering#submit-describing-a-draw-without-making-one) **SynchedEntityData** — the per-entity table of small values the server pushes to watching clients, keyed by class-tree ordinal. → [synched entity data](../systems/entities/synched-entity-data) ## T **Tag** — a named set of registry entries defined by data packs and merged across them, unless a higher pack sets *replace*. (The unrelated NBT sense of the word belongs to [NBT](../systems/foundations/codecs-nbt-json).) → [tags](../systems/foundations/tags) **Team** — a named set of score holders carrying a colour, a friendly-fire flag, a collision rule and a nametag rule — so a class in the scores package is read by collision and by rendering. → [scores, teams and stored data](../systems/commands/scoreboard-and-data#teams-which-systems-far-from-scores-read) **Tick** — one step of the server's simulation, 50 ms at the default rate that `/tick rate` can change, or one step of the client's; a client behind the clock catches up to ten accumulated ticks in a frame and discards the rest. → [the server tick](../systems/server/server-tick), [the client loop](../systems/client/the-client-loop) **Ticket** — the reason a chunk is loaded: a type and a level, fed by its type's flags into one or both of two separate graphs, with `ChunkLevel` deciding what the level buys — a holder still generating toward some status, then full, then block-ticking, then entity-ticking. → [tickets and loading](../systems/world/tickets-and-loading) **Timeline** — one clock's data-driven curve set: an optional period, the named instants on that clock, and one `AttributeTrack` per environment attribute — keyframed over *modifier arguments*, which for an override are the values themselves. → [environment attributes and timelines](../systems/world/environment-attributes-and-timelines#arguments-not-values) **Trigger** (advancements) — the server-side hook that tells **one** player's advancement state that something happened, by sweeping that player's listener map for this trigger. Nothing broadcasts. The scoreboard's *trigger* criterion and the `/trigger` command are a different thing entirely ([scores, teams and stored data](../systems/commands/scoreboard-and-data#what-a-criterion-can-be-which-is-nearly-anything)). → [advancements](../systems/commands/advancements#from-a-slot-that-changed-to-a-toast) ## U **Unattended command** — a command the player did not type: a dialog button or a chat click event, sent through `ClientPacketListener.sendUnattendedCommand`. The client re-parses it and asks first if it fails to parse, needs a signature, or needs any permission at all; a clean one goes without a prompt. A sign's command is not one of these — it runs on the server at gamemaster level, only on a sign whose *allow_op_features* flag is set, and the client is never asked. → [permissions](../systems/commands/permissions#asking-a-question-the-client-cannot-answer) ## V **View distance** — how far the *server* sends chunks. A client's render-distance request only clamps what it is sent; the ticket radius comes from the server's own number. Not *simulation distance*, which is how far the world ticks. → [tickets and loading](../systems/world/tickets-and-loading) **VoxelShape** — the collision or outline volume of a block state, a set of boxes over a bit grid, with fast merge and sweep operations. → [math and primitives](math-and-primitives#shapes-and-collision) ## W **Watchdog** — `ServerWatchdog`, the daemon that treats a tick longer than *max-tick-time* as a dead server: it writes a crash report, calls `System.exit`, and halts the JVM ten seconds later if the shutdown has not ended it by then. → [how a server dies](../systems/server/how-a-server-dies#the-watchdog-that-does-not) **Widget** — an `AbstractWidget`, the reusable piece of a screen: a button, a slider, an edit box. It is usually in all three of a screen's lists at once — the children that get input, the renderables that get extracted, and the narratables that get described. → [GUI and screens](../systems/client/gui-and-screens#the-objects-and-what-contains-what) **Window** — the SDL window handle the whole client hangs off: the framebuffer size, the GUI scale, fullscreen, and the nineteen kinds of event `Window.handleEvent` answers — not the input ones, which `SDLEventHandler` hands to `KeyboardHandler` and `MouseHandler`. → [the window](../systems/rendering/the-window) **World clock** — the identity a timeline is sampled against: a unit record in `Registries.WORLD_CLOCK`, two of them in vanilla, holding nothing at all. The tick count, the rate and the paused flag are `ServerClockManager.ServerClockInstance`'s, one per clock, and `/time` can move or pause each independently. → [environment attributes and timelines](../systems/world/environment-attributes-and-timelines#who-owns-the-clock) **World gen settings** — `WorldGenSettings`: a `WorldOptions` (the seed, *generate structures*, *bonus chest* and a legacy string) and the `LevelStem` map, a `SavedData` written to *data/minecraft/world_gen_settings.dat*. It is the one piece of world generation's own settings that is saved; the worldgen registries are re-read from the enabled packs on every world open, and a template is looked for in the world's own files before the packs'. → [creating a world](../systems/worldgen/creating-a-world#the-object-and-what-is-not-in-it) **World-limited** — a parse-time flag, set by any of seven positional selector options, that confines a selector's resolve to the source's own level instead of every level on the server. → [entity selectors](../systems/commands/entity-selectors#resolve-which-levels-which-structure-which-order) **World preset** — a `WorldPreset` registry entry holding one `LevelStem` per dimension; what the world-type button selects, and what *level-type* names on a dedicated server. → [creating a world](../systems/worldgen/creating-a-world) **World stem** — `WorldStem`, the four things `WorldLoader.load` hands the server constructor in one bundle: the resource manager, the reloadable server resources, the layered registries, and the level data with its gen settings. → [starting a server](../systems/server/starting-a-server) **WorldGenRegion** — the bounded, write-guarded view of the world a generation step is given; it throws rather than loading a chunk, which is why cascading worldgen cannot happen. → [the chunk generation pipeline](../systems/world/chunk-generation-pipeline) --- *Rules: names, never code · how the system works, not how the code reads · newest version only · every backticked name passes `tools/verify_names.py`.*