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

Advancement — a data-pack-defined goal: criteria, a requirements expression over them, an optional display entry and a reward. → 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

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

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

Attribute — a named, ranged, modifiable number on a LivingEntity; modifiers are keyed by Identifier, and eight attributes are not client-syncable at all. → 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

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

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 and entity rendering. → game tests

Beardifier — the density-function term that bends terrain around a structure; terrain adaptation writes no blocks, it changes the noise. → 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

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

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

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

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

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

Block — the singleton describing a kind of block: its behaviour, its property set and its state table. One Block, many BlockStates. → 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

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

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

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

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

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

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

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

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

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

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, 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

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

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

ChunkMap — the server’s chunk table: holders, the ticket-driven level graphs, entity tracking, and the region-file storage underneath. → 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

Climate — the noise sample (temperature, humidity, continentalness, erosion, depth, weirdness) a biome is chosen by. → 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

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

Compiled query — the immutable EntitySelector a parse produces: thirteen fields and no grammar, resolvable any number of times against different sources. → entity selectors

Component — two different things the corpus keeps apart: a data component on an item stack, and a Component of chat text. → data components, 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

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

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, scores, teams and stored data

D

DamageSource — the what hit you, and who is responsible record every damage calculation and death message reads. → 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

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

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

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

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

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

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

Dialog — a data-pack-defined form the server can put on a player’s screen, whose submitted values come back as a packet. → dialogs

Dimension — one ServerLevel and its DimensionType: a height range, a set of environment attributes and its own chunk storage. → level data and rules

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

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

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

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

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

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

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

F

Feature — the algorithm half of decoration: what to build, with no say in which positions it is offered. → 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

Flat level generator preset — a display item plus a FlatLevelGeneratorSettings, one row of the Superflat Presets screen; nine ship. → creating a world

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

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

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). 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

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

Function — a .mcfunction file: a list of commands loaded as a CommandFunction, optionally with macro lines. → 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

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

Game test — a data-driven test instance: a structure, an environment and a check the server runs and reports on. → 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

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

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

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

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

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

HolderSet — a set of holders: either a tag (HolderSet.Named) or a literal list. → 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

I

Identifier — a namespace and a path; the id of everything. A 1.21-era reader knows it as ResourceLocation. → identifiers and registries

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

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

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

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

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

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

J

Jigsaw — the structure-assembly system that grows a village out of template pieces by matching connector blocks. → 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

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, 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

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

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

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

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

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

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

Memory — one typed, optionally expiring value in a Brain; behaviours are gated on which memories are present, absent or merely registered. → AI

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

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

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

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

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

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

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

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

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

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). 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) — and it is, beside a block’s light dampening, what ends a sky column (lighting); 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). Ambient occlusion is none of that: it is the per-quad shading the mesher bakes in (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). 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

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

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

Parameter set — the declared contract between a loot context and the things asked against it: a ContextKeySet naming which ContextKeys 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. → contexts and predicates

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

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

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

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

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

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

PlacedFeature — a feature plus an ordered list of placement modifiers; the unit a biome names. → 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

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

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

Protocol phase — one of handshaking, status, login, configuration and play; each has its own packet table and its own listener. → protocol 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. → 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

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

Region file — the 32-by-32-chunk container file chunks are stored in, addressed by a sector table at its head. → chunk storage

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. → identifiers and registries

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

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

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

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

Resource pack — a pack of assets; the client half of the same pack machinery data packs use. → the resource system

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

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

Score — one number for one holder under one objective, reached through a ScoreAccess handle rather than a setter. → scores, teams and stored 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

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

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

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

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). → AI

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

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

Shape update — the “your neighbour changed, recompute yourself” call that runs on both client and server, unlike a neighbour update. → blocks and states

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

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

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

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

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

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

Structure — a generated building or landmark: a placement lottery, a start assembled in memory, and pieces written a chunk at a time. → 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

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

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. → entity rendering

SynchedEntityData — the per-entity table of small values the server pushes to watching clients, keyed by class-tree ordinal. → 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.) → 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

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, 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

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

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). → advancements

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

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

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

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

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

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

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

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

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

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

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

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

Rules: names, never code · how the system works, not how the code reads · newest version only · every backticked name passes tools/verify_names.py.