This directory answers one backend question per file: how a language operation can actually be represented and executed by a Minecraft Java data pack.
The target is Minecraft Java 26.2, data-pack format 107.1. The commands discussed
here are not assumed to be equally fast merely because they occupy the same number
of lines. Minecraft counts execution stages, function invocations, and forked
contexts separately; a single execute as @e line can therefore be much more
expensive than several scalar scoreboard commands.
- Documented: described by Mojang release notes.
- Derived: follows from documented command behavior, but the composition is our own design.
- Candidate: plausible compiler strategy that needs a real-server test.
- Measured: observed on the target vanilla server with the experiment recorded.
Many executable recipes still need to become automated 26.2 integration tests. OpenJDK 25.0.3 and the official vanilla 26.2 server are now available for doing so; the command-limit, scheduling, native range, and float-conversion claims have received direct server tests.
- Which native value carriers and command domains exist in Java 26.2?
- What is the complete scoreboard surface and its arithmetic behavior?
- What exactly does scoreboard
*select, and can it match patterns? - How do lists, compounds, dictionaries, and higher-order operations compose?
- What is the exact list-operation algebra, and what structures compose from it?
- What do existing collection libraries and list-heavy datapacks teach us?
- Which list experiments and source inspections have been recorded?
- What do existing NBT/dictionary libraries and datapacks teach us?
- Which NBT/dictionary experiments and source inspections have been recorded?
- Which range domains exist, how do they compose, and what are native float semantics?
- Which range/float probes and public implementations have been recorded?
- How should macros be used as a backend primitive? — the
compiler architecture built on this is the value-crossing model in
../compiler/macro-reference-crossing-model.md, with full specifications in../compiler/macro-system-specification.md(every command's syntax slots, the ABI, cost/placement),../compiler/references-design.md(ref/DataRef<T>), and../compiler/nbt-schema-system.md(the compiler-known entity/item/NBT dictionary mechanism) - How do we concatenate strings?
- How do we search through a string?
- How do we append one element to a list?
- How do we append many elements to a list?
- How do we convert integers and floats?
- How do we increment a value?
- Can one command update many values?
- How should branches and basic blocks be lowered?
- How should typed, block-scoped execute chains work?
- How do command success, result, and missing contexts compose?
- When are newly summoned entities safe to query?
- What is the exact Java 26.2 written-book/entity path?
- How should execution context and coordinate frames interact?
- How do we access a dynamic field or index?
- How do we implement loops?
- How should the compiler select runtime representations?
- What are the command limits, and how can work span ticks?
- Which primitive questions should we research next?
The reusable vanilla research fixture for the three new inventories lives under
fixtures/native-primitives-26.2. Run
its world on an isolated port; it is research input, not compiler runtime code.
Stage 8 turns the score/NBT and synchronous execution research into compiler
evidence. Scalar recursive SCCs use compiler-private command-storage tail fields
with Bool stored as byte and Int32 as int; acyclic and serial selector children
reuse static scores. The measured behavior, abnormal-termination contract, and exact
compiler protocol are recorded in
../compiler/stage-8-completion-audit.md.
A source type does not imply one runtime representation. The compiler should track a set of legal representations and select one using whole-region usage information. For example:
- a hot mutable integer normally belongs in a scoreboard;
- an integer used only as command NBT can remain an NBT integer;
- a numeric value used as a float only at an output boundary can be converted during
execute store; - a newly constructed list should be materialized once, not appended element by element;
- a
Textvalue should normally remain a structured text component rather than be flattened into a string; - a bounded dynamic array can use specialization or dispatch, while a truly dynamic array may justify a macro-indexed NBT path.
This means representation selection, scalar replacement, batching, and loop specialization are core compiler passes—not library afterthoughts.
Every candidate implementation should eventually be measured along at least these dimensions:
- pre-parsed command executions;
executestages;- contexts created by selector forks;
- function invocations;
- macro cache hits and misses;
- scoreboard reads/writes;
- command-storage/NBT reads, writes, copies, and list shifts;
- temporary commands needed to bridge representations;
- generated pack size and load/reload time;
- peak commands and wall time per tick.
Mojang explicitly documents that macro lines are reparsed after substitution and
that repeated argument sets may be cached. Mojang also documents that command-chain
accounting includes individual command contexts, execute stages, and function
invocations. These facts are the starting point for the cost model, not a complete
performance model.