Nishi Compare · measured, not asserted

Game Engine

Nishi vs the field — every Nishi cell is measured against real organ source at emit time; each gap names the watch contract that will close it.

Nishi vs Unreal Engine 5.8 and Godot 4.7 and Unity 6 and Bevy 0.19 -- the sovereign engine as certified PARTS: five live wasm worlds, chunked voxels, staged procgen, constraint-solved rooms, 2D swept physics, generated skeletons, mocap, glTF rig import, device-agnostic input, save/load, RPG stats, loot, inventory, faction world-sim, A* pathfinding, story VM, plot generator, VN compositor, music and SFX synthesis, lockstep and rollback netcode, rooms and chat, one-source native+wasm from our own compiler, a sovereign wasm VM, a data-spec game emitter, a byte-asserted ship lane, VR frames, and a corpus-backed capability benchmark. Measured 2026-08-23: nx_gamebench 980 permil capability presence over 26 axes, 3 of 12 titles wired-loop measured at 863-888 permil, 9 self-graded-suspect. Open: WebGPU default, 3D rigid bodies, UDP real-time transport, a scene editor, and the NishiOS native raster lane.

Layer 1 · Executive

Where we are. Measured and working: five live wasm worlds on a sovereign CPU raycaster with a WebGL2 delivery tier live and a WebGPU pass levered, chunked voxel streaming, staged procgen with hydrology, constraint-solved rooms, swept 2D physics with slide and impulse, the in-solver-stable secondary dynamics, a skeleton generated from anthropometric rules, mocap decode and retarget, glTF import that now carries the rig, device-agnostic input, save/load with checksum, RPG stats, loot tables, an inventory substrate, a faction and economy world-sim, integer A*, a story-graph VM and a plot generator, the VN compositor, music and SFX synthesis, lockstep and rollback netcode, rooms with chat over the sovereign store, one NishiLang source shipping native and wasm through our own compiler, a sovereign wasm VM that runs the shipped bytes, a data-spec game emitter, a byte-asserted ship lane, VR frames, and the corpus-backed capability ruler: 36 of 36 claimed symbols grounded at admission. Open: WebGPU as the default, a 3D rigid-body solver, a UDP real-time session, the native raster lane, the visual editor, and nine of twelve benchmark titles that are still self-graded rather than wired-loop measured.

Where we need to go. A sovereign game engine that ships titles, not parts: every gamebench reference title measured by a wired genre loop, delivery at native resolution on WebGPU by default and on the NishiOS raster lane with no vendor driver, a rigid-body solver and a UDP session so real-time multiplayer games are honest, and an editor over the recipe planes so a world is authored the Infinigen way -- generators plus constraints plus search -- never hand-sculpted. Every fidelity or performance claim graded by a referee, never by the author.

The unit. 1 u = one measured session-leg. Calibration inherited from graphics.plan (R21, the skinned in-world figure, parts to live on five worlds in one leg, 2026-08-15) and corroborated by the gamebench parts that each landed in one leg (save/load, netsync, worldsim, loot, rpgstats). Estimates recalibrate as rungs land.

Where we are: 980 vs 863-888 permil. nx_gamebench reports 980 permil capability presence over 26 axes, but only 3 of 12 reference titles are WIRED-PARTS-LOOP-MEASURED (863-888 permil) and 9 are SELF-GRADED-SUSPECT. The honest engine number is the wired one; the distance between the two is the first half of this roadmap.

Cost to delivery parity: 1.5 u. GE1: WebGPU becomes the default once the character and eye passes reach parity and the same frame bit-compares against the CPU path at reference size.

Cost to an engine core: 13.5 u. M2: GE2 rigid bodies, GE3 UDP session, GE4 every benchmark title wired-loop measured, GE8 chunked voxels streamed into the live worlds, GE14 the staged procgen heightfield UNDER the live worlds -- the parts become an engine when the titles run on them.

Cost to an editor and native delivery: 23.5 u. M3 adds GE5 the scene editor, GE6 the NishiOS raster lane, GE10 hot reload of recipe planes, GE11 the visual-novel genre loop toward the north-star output.

Research bar. Godot 4.7 is measured on a complete open-source editor with first-class web export over WebGL 2, 2D and 3D physics, navigation, XR [@godot-features] [@godot-docs]. Theirs: 4.7.2-stable pinned live in knowledge/barcheck.conf [@godot-release]; their docs state WebGPU is not supported [@godot-web]. Ours: our WebGL2 tier is live and the WebGPU pass is levered; no editor, no 3D rigid-body solver.

Research bar. Bevy 0.19 is measured on a data-driven ECS engine in Rust rendering on WebGPU, no shipped editor [@bevy-home] [@bevy-news]. Theirs: v0.19.1 pinned live in knowledge/barcheck.conf [@bevy-release]. Ours: one NishiLang source ships native and wasm through our own compiler; our parts loop is composition, not a measured ECS.

Research bar. Unreal Engine 5.8 is measured on the editor-first AAA bar: Nanite, Lumen, Chaos, Niagara, MetaSounds, PCG, MetaHuman, Pixel Streaming [@unreal-features]. Theirs: the release-notes page served the UE 5.8 notes on 2026-08-23 [@ue-notes]; no machine-readable release registry, so UNPINNED. Ours: we meet none of its render tiers and exceed on generated rigs, one-source native+wasm, and the corpus ruler.

Research bar. Unity 6 is measured on the broadest platform matrix and package ecosystem: physics, multiplayer, input, XR, animation, audio, UI on its manual index [@unity-manual]; Web platform over WebGL [@unity-web]. Theirs: "Unity 6.0 is the latest long-term supported release" on its own product page [@unity-engine]; UNPINNED. Ours: our platform matrix is the browser and NishiOS; everything else on this board is a watch contract.

41 of 52 capabilities measured|6 of them measured exceeds|11 open|coverage 788/1000|adoption 25 full / 16 partial

Layer 2 · Roadmap

Do this next — computed by the ranker, never chosen by a seat

Order from nx_compare_rank (nx_dr_ocm: (deficit + cost-of-delay + option + enables) x sponsor x self-sufficiency x momentum / cost). FINISH rows are rungs whose symbol is present but whose organ is short of full adoption: the cheapest closures on this board, listed before any new work. Stamp: # asof=1787883588 domain=gameengine target_version=0.1 rungs=13 done=2 open=11 finish=0 ranker=nx_dr_ocm

#	Stage	Rung	Priority	Derivation
#1	0.1	glTF import at full fidelity (GE7) g2_uv_anim	1600	v=16 m=1 c=10
#2	0.1	WebGPU default delivery (GE1) gpe_webgpu_default	266	v=4 m=1 c=15
#3	later	Hot reload of recipe planes (GE10) wc_hot_reload	4000	v=12 m=1 c=3
#4	later	3D rigid-body solver (GE2) rb3_solve	900	v=18 m=1 c=20
#5	later	The live worlds read the staged procgen heightfield (GE14) wc_worldpipe_bind	833	v=5 m=1 c=6
#6	later	NishiOS native raster lane (GE6) gpu_raster_rung	533	v=16 m=1 c=30
#7	later	UDP real-time session (GE3) nt_udp_session	500	v=10 m=1 c=20
#8	later	Scene editor over the recipe planes (GE5) ed_scene_edit	275	v=11 m=1 c=40
#9	later	Chunked voxels in the live worlds (GE8) wc_chunk_stream	166	v=1 m=1 c=6
#10	later	Every benchmark title wired-loop measured (GE4) gb_wire_loop	133	v=2 m=1 c=15
#11	later	Visual-novel genre loop (GE11) gl_vn_loop	100	v=1 m=1 c=10

Critical path — contract, done-rule, executor, cost

Rung	Closes with	Definition of done (pre-declared)	Executor	Est.
WebGPU default delivery (GE1)	gpe_webgpu_default	The NPC and eye passes reach parity on the WGSL tier, the same frame bit-compares against the CPU path at reference size, and ?gpu=1 becomes the default with the GL tier as fallback; proven on a real GPU over the CDP wire	Organ	1.5 u
3D rigid-body solver (GE2)	rb3_solve	A sovereign integer rigid-body solver with joints and constraints; replay bit-identical on all frame checksums; a stacked-boxes and a pendulum-chain tooth, plus a neg-control that an unsatisfiable constraint set REFUSES	Organ	2 u
UDP real-time session (GE3)	nt_udp_session	A sovereign UDP session under the rollback core: loss, reorder and jitter injected by the gate, the sim converges to the lossless trace; the video board's freeze class measured gone	Organ	2 u
Every benchmark title wired-loop measured (GE4)	gb_wire_loop	All 12 gamebench reference titles carry a WIRED-PARTS-LOOP-MEASURED grading with a banked wiring artifact; SELF-GRADED-SUSPECT reads zero; the demand-weighted number is recomputed from wired loops only	Organ	3 u
Scene editor over the recipe planes (GE5) after GE1	ed_scene_edit	A sovereign editor that reads and writes the recipe and layout planes the worlds already consume; an edit lands in the live world on the next emit; never a second renderer	Organ	4 u
NishiOS native raster lane (GE6)	gpu_raster_rung	A compute-shader rasteriser writing a framebuffer through the proven dxg submission lane, no vendor driver, the same frame bit-compared against the browser tier	Organ	3 u
glTF import at full fidelity (GE7)	g2_uv_anim	UVs, morph targets and animation clips carried into the sovereign asset beside the rig; the round-trip gate proves nothing is dropped (the 16=10+6+0 partition closes)	Organ	1 u
Chunked voxels in the live worlds (GE8)	wc_chunk_stream	The craft worlds stream through the bounded resident chunk set instead of the fixed volume; eviction and reload proven in-world with the frame-time envelope published	Organ	2 u
Hot reload of recipe planes (GE10) after GE5	wc_hot_reload	A recipe-plane edit reaches a running world without a rebuild; the gate proves the frame after the edit differs exactly where the plane changed	Organ	1 u
Visual-novel genre loop (GE11) after GE4	gl_vn_loop	The VN genre loop composes the VN compositor, story VM, plot generator and save/load into a playable reference loop; the north-star Monster Girl Island class graded by the wired-loop ruler	Organ	2 u

Milestones

Milestone	Rungs	Cumulative
M0 · Delivery at parity	GE1	1.5 u
M1 · Assets whole	GE1,GE7	2.5 u
M2 · Engine core complete	GE2,GE3,GE4,GE8,GE14	13.5 u
M3 · Editor and native	GE5,GE6,GE10,GE11	23.5 u

Rung	Closes with	Definition of done (pre-declared)	Executor	Est.
Gait-phased vertical locomotion (GE12)	mob_step_gait	Mobs step and fall instead of gliding: per-mob vertical velocity with gravity acceleration and terminal clamp replaces the linear 64-Q8-per-tick ease (nx_wasm_craft.nx:2768 measured 2026-08-26); a step up reads as a step (rise during stride phase), a drop accelerates; replay bit-identical; operator-reported glide-up measured gone in a headless motion capture	Organ	1 u
Beach world is a beach (GE13)	wsp_beach_ocean	The beach world spec carries an ocean region with shoreline slope and a water surface using the engine's existing water blocks, plus per-world outfit flags (swimwear/topless/nude beach) consumed by the outfit system; spec-data rows, no per-world code; proven by the world census reading water permil above a named floor at the shoreline band and the outfit flag round-tripping	Organ	1.5 u
The live worlds read the staged procgen heightfield (GE14)	wc_worldpipe_bind	genworld voxelises nx_worldpipe's staged pipeline (heightfield, hydrology bake, erosion, biome field) instead of its own inline noise, so every procgen-board terrain rung (PG20 erosion LANDED, wp_biome_field, PG21 plants, PG22 weather) reaches /world by construction. Measured 2026-08-24 (procgen.matrix row 23, corpus_complete=1): nx_wasm_craft does NOT import nx_worldpipe -- Infinigen-class environment generation is being built BESIDE the five live worlds, not UNDER them. Done when nx_wasm_craft imports nx_worldpipe behind a recipe-row bind (GEN-TIME row, default OFF), the five recipe worlds re-emit byte-identical at their pinned seeds with the bind OFF (the legacy path stays the KAT), and a recipe row with the bind ON renders a hydrology-traced shoreline that the world census reads at the shoreline band	Organ	2 u

Layer 3 · Engineering

How this is scored. Every Nishi mark is measured: the generator reads the real organ source on disk and requires the implementing symbol to exist (no self-grading). A watching tag names the organ and symbol contracted to close a gap — the mark flips itself on the next compare beat when that workstream ships, and the comparewatch- plane row flips with it. The flip is necessary, not sufficient: it proves the symbol exists, never that the capability is good. The bar is the rung's pre-declared done-rule, proven by its gate — a symbol shipped without the behaviour behind it is a defect, and the flip is exactly what makes that defect visible instead of quiet. Competitor marks record documented capability presence — presence, not depth or scale. Adoption is measured too: every measured row carries where its organ stands on the estate's ladder (source → built → promoted → registered → invoked; libraries by importer reach minus validation importers; gates by the execution surfaces that run them). A row is fully adopted only at the top of its ladder; anything short is tagged partial with the exact remedy, so a build nobody promoted can no longer read as shipped. Census stamps: importers asof 1787849099, gate census asof 1787855507 (unix seconds; -1 = census absent).

Capability matrix — measured against source

◉ leads / measured exceed● present◐ partial○ absent · click any capability for its evidence

Capability	Nishi	Unreal Engine 5.8	Godot 4.7	Unity 6	Bevy 0.19
WORLD
five live wasm worlds, sovereign CPU raycaster, no GPU shader in the path Measured: `wc_mob_mesh` exists in `runtime/nx_wasm_craft.nx`, verified at emit. /world/craft, shore, vale, isle, crags: NishiLang compiled to wasm with skinned genome-distinct characters in-world, gate 74 of 74. Godot ships a first-class web export over WebGL 2 [godot-web]; Unity exports to its Web platform [unity-web]; Bevy targets the browser through the Rust wasm toolchain [bevy-home]; Unreal reaches browsers only by Pixel Streaming, a server-rendered path, not a web export [unreal-features]. Adoption: `LIB-WIRED importers=7 nonval=3` — fully adopted (top of its ladder).	●	◐	◉	●	●
chunked unbounded voxel world streamed through a bounded resident set with disk flush Measured: `vxc_ensure` exists in `runtime/_hdl_build/nx_voxchunk.nx`, verified at emit. The Minecraft-class bar the gamebench capability names: unbounded world, bounded memory, eviction and reload proven. No engine ships a voxel world natively; all four leave it to plugins, so this is a lead nobody holds rather than a measured exceed. Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. adoption LIB-GATE-ONLY importers=1	●	○	○	○	○
staged procedural heightfield (six noise parameters, spline terrain, baked hydrology) Measured: `wp_hydro_bake` exists in `runtime/nx_worldpipe.nx`, verified at emit. The banked Minecraft-pipeline curriculum as an ordered staged pipeline; hydrology traces downhill to the sea. Unreal leads with Landscape plus the PCG framework [unreal-features]; Godot and Unity ship noise primitives and terrain tools at index level [godot-docs] [unity-manual]; Bevy has none built in. Adoption: `LIB-WIRED importers=8 nonval=3` — fully adopted (top of its ladder).	●	◉	●	●	○
indoor rooms by constraint solve (the Infinigen 2.0 expansion) Measured: `ig_room_solve` exists in `runtime/nx_indoorgen_lib.nx`, verified at emit. Composes the estate part-solver: envelope, no-clip, door-clearance and wall-hug rows, REFUSES an unsatisfiable set rather than overlapping furniture; stamped into three live worlds. Unreal's PCG does procedural placement [unreal-features]; nobody ships constraint-solved rooms natively. Adoption: `LIB-WIRED importers=2 nonval=1` — fully adopted (top of its ladder).	●	●	○	○	○
SHIP-QA
every name the emitted page references resolves to an ENCLOSING scope (static resolution over the sovereign JS parser) Measured exceed: `jss_check` in `runtime/nx_jsscope.nx`, verified at emit. WIRED IN-PATH 2026-08-25: ship stage [4c/5] REFUSES the deploy on any unresolved or out-of-scope name, with a planted-undeclared neg-control biting on EVERY run -- proven live on all five /world ships (refs 6,324-6,360 per page, reports=0). Same referee as nx_jsscope_gate (14/14 GREEN), adopted at the shipping surface, not only as a gate. LANDED 2026-08-25, nx_jsscope_gate 14/14 GREEN ON THE NAS over the real page: 6,324 references, 128 scopes, 1,274 declarations, OUT-OF-SCOPE=0 and UNRESOLVED=0 against knowledge/js_globals.conf -- a globals allowlist CALIBRATED BY MEASUREMENT (its five newest rows are the gate's own first-run misses, each with its reason, including a window-assignment global the resolver declares it does not model). The referee reproduces the outage class on a fixture and NAMES THE DECLARING FUNCTION (OUT-OF-SCOPE name=nxHairTick declared_in=loadNPC), which is the line that sends a reader to the fix instead of to grep. Building it grew the sovereign ECMAScript parser four rungs measured off the real page (async function decl+expr, async arrows -- which had NEVER fired, the lexer reserves async as a keyword -- and BigInt literals) with the octane corpus as regression control. Rival columns NOT MEASURED; the exceed is coded against the measured outage class, not a bake-off. Adoption: `LIB-WIRED importers=2 nonval=1` — fully adopted (top of its ladder).	◉	○	○	○	○
the emitted page must LEX before a byte reaches the docroot (in-path stage + planted-bad control every run) Measured exceed: `jsb_check_page` in `runtime/nx_jsbalance.nx`, verified at emit. LANDED 2026-08-25 after a measured outage: an emitter edit shipped 410 KB of generated JS that took /world/beach and /world/craft BLACK with every stage green -- organ compiled, wasm-vm gate PAINTS passed, ship lane read the page back and verified its marker; NOTHING parsed the JavaScript, and a script that does not lex takes the CPU FALLBACK down with it, which is the difference between ugly and nothing. Now nx_craft_emit ce_ship composes the sovereign lexer IN-PROCESS on every world and REFUSES by name (code/brace/paren/state/offsets), and must first BITE a planted unclosed brace or it refuses to ship with ruler-is-blind. Proven live: [4b/5] prints before every [5/5] SHIPPED. Rival columns are NOT MEASURED for this row and no claim is made about them; the exceed is coded against the measured outage class this closes, not against a rival bake-off. Adoption: `LIB-WIRED importers=2 nonval=1` — fully adopted (top of its ladder).	◉	○	○	○	○
RENDER
GPU delivery tier in third-party browsers (WebGL2, sovereign wasm raster always the fallback) Measured: `gpe_build` exists in `runtime/nx_game_page_emit.nx`, verified at emit. Every /world page renders on the visitor's GPU at device resolution with the NishiLang-wasm rasteriser compiled in as fallback. Godot leads on web export [godot-web]; Unity Web is WebGL-based [unity-web]; Bevy runs in the browser [bevy-news]; Unreal has no native web export [unreal-features]. Adoption: `REGISTERED-DARK` — PARTIAL: callable, authorised, no MCP invocation on record (a direct fork logs the runner, so this is not proof it never ran); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked). adoption REGISTERED-DARK	●	○	◉	●	●
WebGPU tier -- WGSL world pass over the same organ state Measured: `gpe_emit_webgpu` exists in `runtime/nx_game_page_emit.nx`, verified at emit. Stage A landed 2026-08-18, levered by ?gpu=1 with a boot-stall ceiling; default stays WebGL2 until the character passes reach parity. Godot's own docs: "Godot currently does not support WebGPU" [godot-web]; Bevy renders on WebGPU [bevy-news]; Unity's mirrored web page documents WebGL only [unity-web]; Unreal none. Adoption: `REGISTERED-DARK` — PARTIAL: callable, authorised, no MCP invocation on record (a direct fork logs the runner, so this is not proof it never ran); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked). adoption REGISTERED-DARK	●	○	○	○	◉
native GPU raster on the sovereign bare-metal lane (NishiOS, no vendor driver) Open — watching `runtime/_hdl_build/_gpu_dxg_submit_gate.nx` : `gpu_raster_rung`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. Every rival renders natively on desktop GPUs through vendor drivers; ours is the compute-shader rasteriser over the proven dxg submission lane -- the graphics board's native contract, one contract two pages. watching gpu_raster_rung	○	◉	◉	◉	◉
PHYSICS
continuous swept 2D collision with slide response and impulse integration Measured: `c2_step` exists in `runtime/_hdl_build/nx_collide2d.nx`, verified at emit. The three absences the gamebench bar named, gated and mutation-proven. Godot ships 2D and 3D physics servers, Jolt in 3D [godot-docs]; Unreal Chaos [unreal-features]; Unity Physics [unity-manual]; Bevy has no built-in physics and relies on ecosystem crates [bevy-features]. Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. adoption LIB-GATE-ONLY importers=1	●	◉	◉	◉	◐
secondary dynamics -- jiggle, recoil, hair, cloth -- with the stability envelope enforced in the solver Measured: `sd_step` exists in `runtime/nx_softdyn.nx`, verified at emit. Spring-damper so an unstable configuration cannot be requested; gate 7 of 7 with an anti-vacuity tooth. Unreal Chaos cloth and Niagara lead [unreal-features]; Godot soft bodies and Unity cloth at index level; Bevy none. Adoption: `LIB-WIRED importers=7 nonval=5` — fully adopted (top of its ladder).	●	◉	●	●	○
3D rigid-body solver with joints and constraints Open — watching `runtime/nx_rigidbody.nx` : `rb3_solve`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. The estate has the real-skeleton damped-pendulum integrator on the anatomy rig and no general rigid-body solver. Godot 4 ships Jolt [godot-docs]; Unreal Chaos and Unity Physics are built in; Bevy through crates. Contract: a sovereign integer rigid-body solver with constraints, replay bit-identical. watching rb3_solve	○	◉	◉	◉	◐
ANIMATION
skeleton GENERATED from anthropometric parameters with legal joint ranges Measured exceed: `sg_legal` in `runtime/_hdl_build/nx_skelgen.nx`, verified at emit. EXCEED with the why: rivals import authored rigs (Unreal's MetaHuman and Control Rig are artist pipelines [unreal-features]); ours derives bone lengths and joint limits from height, proportion and sex rules, so a rig exists for any genome without an artist. Honest: the human plan only; the second species is a graphics-board contract. Adoption: `REGISTERED-DARK` — PARTIAL: callable, authorised, no MCP invocation on record (a direct fork logs the runner, so this is not proof it never ran); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked). adoption REGISTERED-DARK	◉	○	○	○	○
real mocap decoded and retargeted (BVH, VMD) Measured: `m_joints` exists in `runtime/nx_bvhmotion.nx`, verified at emit. Decoded sovereignly and retargeted at 30fps. Unreal retargeting and Live Link lead [unreal-features]; Godot and Unity retarget at index level [godot-docs] [unity-manual]; Bevy none. Adoption: `REGISTERED-DARK` — PARTIAL: callable, authorised, no MCP invocation on record (a direct fork logs the runner, so this is not proof it never ran); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked). adoption REGISTERED-DARK	●	◉	●	●	○
pose application on declared mesh regions about declared pivots (region, pivot, angle as data) Measured: `pz_apply` exists in `runtime/_hdl_build/nx_meshpose.nx`, verified at emit. The pose-match instrument: error measured per kinematic chain. Animation systems are first-class in all three editors; Bevy ships an animation crate [bevy-home]. Adoption: `REGISTERED-DARK` — PARTIAL: callable, authorised, no MCP invocation on record (a direct fork logs the runner, so this is not proof it never ran); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked). adoption REGISTERED-DARK	●	◉	◉	◉	●
ASSET
glTF, GLB and VRM import to the sovereign mesh oracle format Measured: `g2_convert` exists in `runtime/_hdl_build/nx_gltf2mesh.nx`, verified at emit. Godot imports glTF first-class [godot-docs]; Unity and Unreal through packages; Bevy loads glTF scenes [bevy-features]. Honest: a FORM oracle -- UVs and animations are not carried yet. Adoption: `LIVE` — fully adopted (top of its ladder).	●	●	◉	●	●
rig-carrying import -- joints, weights and inverse bind matrices into the asset Measured: `g2_skin_weights` exists in `runtime/_hdl_build/nx_gltf2mesh.nx`, verified at emit. LANDED 2026-08-23 (the charsim board's R22 contract, one contract two pages): skinned control proven against an unskinned one. Rivals import skinned meshes natively. Adoption: `LIVE` — fully adopted (top of its ladder).	●	◉	◉	◉	●
INPUT
device-agnostic action state -- keyboard, gamepad buttons, gamepad axes, touch -- driving one semantic map Measured: `ia_frame` exists in `runtime/nx_input_abstract.nx`, verified at emit. The key-to-meaning map lives in the sovereign organ, the JS shim stays transport. Unreal Enhanced Input [unreal-features]; Godot InputMap [godot-docs]; Unity Input [unity-manual]; Bevy raw input events [bevy-home]. Adoption: `LIB-WIRED importers=6 nonval=3` — fully adopted (top of its ladder).	●	◉	◉	◉	●
look-vector accumulation from mouse and touch deltas for first-person cameras Measured: `ia_look_take` exists in `runtime/nx_input_abstract.nx`, verified at emit. Consumed per frame by the craft worlds; rivals expose the same through their input systems. Adoption: `LIB-WIRED importers=6 nonval=3` — fully adopted (top of its ladder).	●	◉	◉	◉	●
SYSTEMS
save and load with a schema id and checksum, verified on read Measured: `gs_save` exists in `runtime/_hdl_build/nx_gamesave.nx`, verified at emit. Ranked first by the gamebench demand queue (blocked 11 of 12 titles) and landed as a part. Unreal SaveGame objects [unreal-features]; Godot and Unity serialise through their own APIs at index level; Bevy leaves persistence to crates. Adoption: `LIB-WIRED importers=28 nonval=8` — fully adopted (top of its ladder).	●	◉	●	●	○
RPG stats and progression -- xp curve, levels, derived hit points, modifiers, skill ranks Measured: `rs_level_for_xp` exists in `runtime/_hdl_build/nx_rpgstats.nx`, verified at emit. Saturating integer arithmetic so a buff cannot overflow. No engine ships a stat system natively (Unreal's ability system is a plugin), so this is a lead nobody holds. Adoption: `LIB-WIRED importers=11 nonval=5` — fully adopted (top of its ladder).	●	○	○	○	○
weighted, tiered loot and item-affix tables Measured: `lt_roll` exists in `runtime/_hdl_build/nx_loottable.nx`, verified at emit. The Diablo-class archetype's defining system; seeded, deterministic. No rival ships loot tables. Adoption: `LIB-WIRED importers=6 nonval=3` — fully adopted (top of its ladder).	●	○	○	○	○
domain-agnostic inventory and crafting substrate over the sovereign store Measured: `iv_consume` exists in `runtime/_hdl_build/nx_inventory.nx`, verified at emit. One item store serves games, the pantry and an estate catalogue alike: quantities, par levels, expiry, consumption. No rival ships inventory natively. Adoption: `LIB-WIRED importers=9 nonval=5` — fully adopted (top of its ladder).	●	○	○	○	○
faction and economy world simulation -- resources, population, territory, relations, trade Measured: `ws_tick` exists in `runtime/_hdl_build/nx_worldsim.nx`, verified at emit. Closes the Freeciv and Cataclysm faction gap on the gamebench board; the keystone of the north-star persistent-world output. No rival ships a world-sim. Adoption: `LIB-WIRED importers=4 nonval=2` — fully adopted (top of its ladder).	●	○	○	○	○
A* grid pathfinding, integer only, optimal path with parent reconstruction Measured: `pf_astar` exists in `runtime/_hdl_build/nx_pathfind.nx`, verified at emit. Unreal navigation meshes [unreal-features]; Godot AStar and NavigationServer [godot-docs]; Unity's AI Navigation package (not on the mirrored index, coded at package level); Bevy none built in. Adoption: `LIB-WIRED importers=9 nonval=2` — fully adopted (top of its ladder).	●	◉	◉	●	○
data-driven story-graph VM -- dialogue trees, quests, flag-gated branches Measured: `sv_choose` exists in `runtime/_hdl_build/nx_story_vm.nx`, verified at emit. A story is data, not control flow: nodes, choices, required and set flags. No rival ships a dialogue system natively; all rely on add-ons. Adoption: `LIB-WIRED importers=5 nonval=2` — fully adopted (top of its ladder).	●	○	○	○	○
plot generator that emits story graphs the VM runs Measured: `pg_gen` exists in `runtime/_hdl_build/nx_plotgen.nx`, verified at emit. Generates, then walks every generated graph to an ending as its own proof. No rival generates plots. Adoption: `LIB-WIRED importers=3 nonval=1` — fully adopted (top of its ladder).	●	○	○	○	○
visual-novel sprite compositor with attribute groups (the Ren'Py layeredimage class) Measured: `vsp_compose` exists in `runtime/_hdl_build/nx_vnsprite.nx`, verified at emit. Expression, outfit and pose groups where selecting one attribute excludes the rest of its group; dissolve transitions. No engine ships a VN compositor. Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. adoption LIB-GATE-ONLY importers=1	●	○	○	○	○
AUDIO
music sequencer rendered to a real WAV -- equal temperament, envelopes, mix Measured: `mus_render` exists in `runtime/_hdl_build/nx_gamemusic.nx`, verified at emit. Unreal MetaSounds lead [unreal-features]; Godot audio streams and generators [godot-docs]; Unity Audio [unity-manual]; Bevy audio [bevy-home]. Ours is a sequencer, not a DAW-class graph. Adoption: `LIB-GATE-ONLY importers=3` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. adoption LIB-GATE-ONLY importers=3	●	◉	●	●	●
procedural sound effects -- coin, laser, explosion -- synthesised to WAV Measured: `sfx_explosion` exists in `runtime/nx_audio_sfx.nx`, verified at emit. The SFX half of the gamebench audio capability, gated 3 of 3 with a real waveform; rivals play authored clips and, in Unreal's case, synthesise in MetaSounds. Adoption: `LIB-WIRED importers=8 nonval=5` — fully adopted (top of its ladder).	●	◉	●	●	●
NET
deterministic lockstep netcode composed with the certified parts, desync detected by checksum Measured: `ns_step` exists in `runtime/_hdl_build/nx_netsync.nx`, verified at emit. Only inputs cross the wire; every peer stays byte-identical. Unreal's replication is state synchronisation, not lockstep [unreal-features]; Godot high-level multiplayer [godot-docs]; Unity Netcode [unity-manual]; Bevy none built in. Adoption: `BUILT-UNPROMOTED` — PARTIAL: compiled, never promoted to the serving root: /api/promote it. adoption BUILT-UNPROMOTED	●	●	●	●	○
rollback netcode core -- predict, detect misprediction, restore and resimulate Measured: `rb_resim` exists in `runtime/_hdl_build/nx_rollback.nx`, verified at emit. The fighting-game standard, built on the deterministic step. No engine ships rollback natively. Adoption: `LIB-GATE-ONLY importers=2` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. adoption LIB-GATE-ONLY importers=2	●	○	○	○	○
turn-based multiplayer rooms with chat over the sovereign store Measured: `gc_room_wire` exists in `runtime/nx_game_chat.nx`, verified at emit. The comms board's C12 contract landed: two clients exchange moves and chat through the C1 store with the game's own rules as referee. Rivals offer lobby and relay services; Bevy none. Adoption: `REGISTERED-DARK` — PARTIAL: callable, authorised, no MCP invocation on record (a direct fork logs the runner, so this is not proof it never ran); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked). adoption REGISTERED-DARK	●	●	●	●	○
real-time UDP transport for live sessions Open — watching `runtime/nx_net_udp.nx` : `nt_udp_session`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. Today's rooms and calls ride the TCP/TLS relay -- the video board's measured reason for freezes under loss. Godot ENet, Unity Transport and Unreal networking are UDP-native at index level. Contract: a sovereign UDP session with loss handling under the rollback core. watching nt_udp_session	○	◉	◉	◉	○
SCRIPT
game logic in NishiLang compiled to wasm AND native from ONE source by our own compiler Measured exceed: `wat_emit_module` in `runtime/nx_wasm.nx`, verified at emit. EXCEED with the why: the same .nx ships as a native binary (PNG-proven) and as browser wasm through OUR wat backend; rivals compile C++, GDScript, C# and Rust through third-party toolchains (Emscripten, IL2CPP, rustc) [godot-web] [unity-web] [bevy-home]. Honest: no hot reload and no visual scripting, which Unreal's Blueprints lead [unreal-features]. Adoption: `LIB-WIRED importers=3 nonval=3` — fully adopted (top of its ladder).	◉	○	●	●	●
the shipped wasm executed natively in the sovereign VM -- test the shipped bytes, not a proxy Measured exceed: `wm_run` in `runtime/nx_wasm_vm.nx`, verified at emit. EXCEED with the why: a sovereign wasm interpreter (SIMD subset included) runs the exact module the page ships, so autotests execute the artifact; no rival tests its shipped module in its own VM. Adoption: `LIB-WIRED importers=33 nonval=10` — fully adopted (top of its ladder).	◉	○	○	○	○
data game-spec to playable module -- generate a game from a spec over six proven FSM types Measured: `gg_emit_spec` exists in `runtime/_hdl_build/nx_game_gen2.nx`, verified at emit. The autonomous game-gen lever: spec in, module out, transition tables sourced from the same data the gates read. No rival generates games from specs. Adoption: `REGISTERED-UNAUTHORISED` — PARTIAL: registered, no cap ever minted; no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked). adoption REGISTERED-UNAUTHORISED	●	○	○	○	○
TOOLING
byte-asserted ship lane -- gate-check to .nx to .wat to .wasm to page to live docroot Measured: `ce_ship` exists in `runtime/nx_craft_emit.nx`, verified at emit. Every stage byte-asserted before the next runs (a 0-byte .wat once shipped a 20-byte game). All three editors ship export pipelines; Bevy ships through cargo and the wasm toolchain. Adoption: `LIVE` — fully adopted (top of its ladder).	●	◉	◉	◉	●
visual scene editor Open — watching `runtime/nx_game_editor.nx` : `ed_scene_edit`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. The field's defining surface and our largest absence: Unreal, Godot and Unity are editors first [unreal-features] [godot-docs] [unity-manual]; Bevy has no shipped editor on its mirrored pages. Contract: a sovereign scene editor over the recipe planes the worlds already read. watching ed_scene_edit	○	◉	◉	◉	○
UI
sovereign text and HUD rendering onto a framebuffer with our own font Measured: `nx_text_render_string` exists in `runtime/nx_text_render.nx`, verified at emit. Composes the 1bpp font and framebuffer; rivals ship full widget toolkits (UMG, Control nodes, UI Toolkit [unity-manual]) and Bevy a UI crate [bevy-home]. Adoption: `LIB-GATE-ONLY importers=2` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. adoption LIB-GATE-ONLY importers=2	●	◉	◉	◉	●
VR
stereo compositor frame -- per-eye off-axis projection and lens distortion -- for a headset runtime Measured: `vf_build` exists in `runtime/_hdl_build/nx_vrframe.nx`, verified at emit. The submit-ready frame; the headset runtime itself is the named gap. Unreal, Godot and Unity ship OpenXR [unreal-features] [godot-docs] [unity-manual]; Bevy none on its mirrored pages. Adoption: `LIVE` — fully adopted (top of its ladder).	●	◉	◉	◉	○
REFEREE
game capability benchmark over a real 144-title open-source corpus, 26 axes, demand-weighted Measured exceed: `hasbit` in `runtime/_hdl_build/nx_gamebench.nx`, verified at emit. EXCEED with the why: no engine measures itself against a corpus of shipped games; every HAVE must name an artifact on disk or the gate kills it. Honest: 9 of 12 titles are SELF-GRADED-SUSPECT, 3 wired-loop measured at 863-888 permil -- the number to climb. Adoption: `REGISTERED-DARK` — PARTIAL: callable, authorised, no MCP invocation on record (a direct fork logs the runner, so this is not proof it never ran); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked). adoption REGISTERED-DARK	◉	○	○	○	○
vision forensics on the shipped wasm in our own VM -- blackout, frozen frame, magenta leak, seeded repro Measured: `abug` exists in `runtime/_hdl_build/nx_mineworld_autotest.nx`, verified at emit. Executes the real wasm and reads the framebuffer; any red is an exact seed and tick. Unreal automation and Unity's test framework test in-editor at index level; Godot through add-ons; Bevy none. Adoption: `SOURCE-ONLY` — PARTIAL: source exists, never compiled: /api/build it. adoption SOURCE-ONLY	●	●	○	●	○
RENDER
WebGPU as the DEFAULT delivery tier -- character and eye passes at parity, frame bit-compared to the CPU path Open — watching `runtime/nx_game_page_emit.nx` : `gpe_webgpu_default`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. GE1. Bevy already renders on WebGPU [bevy-news]; Godot states it does not support WebGPU [godot-web]; Unity's mirrored web page documents WebGL only [unity-web]. Contract: the default flips on a bit-compare against the CPU frame on real hardware, never on a lever. watching gpe_webgpu_default	○	○	○	○	◉
WORLD
chunked voxel streaming inside the live craft worlds (replacing the fixed 64x32x64 volume) Open — watching `runtime/nx_wasm_craft.nx` : `wc_chunk_stream`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. GE8. The chunk part exists (above); wiring it under the live raycaster with the frame-time envelope published is the contract. No rival ships voxel streaming natively. watching wc_chunk_stream	○	○	○	○	○
ASSET
glTF at full fidelity -- UVs, morph targets and animation clips carried beside the rig Open — watching `runtime/_hdl_build/nx_gltf2mesh.nx` : `g2_uv_anim`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. GE7. Every rival imports these natively [godot-docs] [bevy-features]; ours drops them today (the round-trip census 16=10+6+0 names the loss). Contract: the round-trip gate proves nothing is dropped. watching g2_uv_anim	○	◉	◉	◉	◉
TOOLING
hot reload of recipe planes into a running world without a rebuild Open — watching `runtime/nx_wasm_craft.nx` : `wc_hot_reload`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. GE10. Editors hot-reload assets and scripts by design [unreal-features] [godot-docs] [unity-manual]; Bevy hot-reloads assets [bevy-features]. Contract: the frame after an edit differs exactly where the plane changed. watching wc_hot_reload	○	◉	◉	◉	●
REFEREE
every benchmark title wired-loop measured -- no self-graded titles left on the ruler Open — watching `runtime/_hdl_build/nx_gamebench.nx` : `gb_wire_loop`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. GE4, the honesty rung: 9 of 12 titles are SELF-GRADED-SUSPECT today. Contract: every title carries a banked wiring artifact and the demand-weighted number is recomputed from wired loops only. watching gb_wire_loop	○	○	○	○	○
SYSTEMS
visual-novel genre loop composed from the certified parts (compositor, story VM, plot generator, save/load) Open — watching `runtime/_hdl_build/nx_gamebench.nx` : `gl_vn_loop`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. GE11, the north-star output class (Monster Girl Island): the parts exist above and no loop composes them yet. No rival ships a VN genre loop. watching gl_vn_loop	○	○	○	○	○
LOCOMOTION
gait-phased vertical stepping with gravity Measured: `mob_step_gait` exists in `runtime/nx_wasm_craft.nx`, verified at emit. Every rival steps and falls under gravity; our mobs ease height linearly (64 Q8/tick, nx_wasm_craft.nx:2768) so a climb glides and a drop floats -- the operator-reported class of 2026-08-26. Adoption: `LIB-WIRED importers=7 nonval=3` — fully adopted (top of its ladder).	●	●	●	●	●
WORLD
beach biome with ocean, shoreline and beach outfit flags Measured: `wsp_beach_ocean` exists in `runtime/nx_wasm_craft.nx`, verified at emit. The engine holds water blocks (craft census water permil nonzero) but the beach world spec carries no ocean region, shoreline slope or swimwear/nude-beach outfit flags; spec-data rows, never per-world code. Adoption: `LIB-WIRED importers=7 nonval=3` — fully adopted (top of its ladder).	●	●	●	●	●
the live worlds voxelise the staged procgen heightfield (hydrology, erosion, biomes) instead of inline noise Open — watching `runtime/nx_wasm_craft.nx` : `wc_worldpipe_bind`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. GE14. The procgen board's terrain rungs (wp_hydro_bake, wp_erode LANDED 2026-08-25, wp_biome_field) land on nx_worldpipe, and nx_wasm_craft does NOT import it (measured 2026-08-24, corpus_complete=1): Infinigen-class environment generation is landing on a heightfield the five live worlds never read. Unreal's Landscape and PCG feed the runtime world directly [unreal-features]; Godot and Unity ship terrain tools the runtime consumes [godot-docs] [unity-manual]; Bevy none. Contract: one import behind a recipe-row bind, the legacy path kept byte-identical as the KAT. watching wc_worldpipe_bind	○	◉	●	●	○

Risk register

Risk	Likelihood x impact	Mitigation
Capability presence reads as engine parity: 980 permil over parts while 9 of 12 titles are self-graded	certain x high	GE4 first among the core rungs; the page prints the wired-loop number beside the presence number and never the presence number alone.
The delivery default flips on a lever rather than a measurement	possible x high	GE1's done-rule is a bit-compare against the CPU frame on real hardware over the CDP wire; the flip is the receipt, the compare is the proof.
The editor rung rebuilds a renderer instead of editing planes	possible x high	GE5 is declared over the recipe and layout planes the worlds already read; a second renderer is the duplicate-ruler defect and REFUSES at review.
Rival bars rot: Godot and Bevy pinned, Unreal and Unity unpinned	likely x low	nx_barcheck re-reads the two pinned bars daily; the unpinned two carry their mirrored pages with pins and access dates, re-read at the next admission sweep.

On these two registers. Rows are declared in the domain's plan file and carry the debt id, which is the join key back to the sovereign debt plane — that plane, not this page, is the authority on state. Reconciling them automatically (the regen reading the plane and refreshing these rows) is a named, owed rung; until it lands, treat an id here as a pointer to look up, not a status to trust.

Honest verdict. Breadth is measured and real: 37 engine parts ground in source, three genuine exceeds carry a mechanism no rival ships (a skeleton GENERATED from anthropometric rules, one NishiLang source compiled to native AND wasm by OUR compiler, and a capability ruler over a corpus of real shipped games). Depth is where the field leads: every rival is an EDITOR first and we have none; they ship 3D rigid-body solvers, UDP transports and WebGPU-class delivery that are watch contracts here; and nine of twelve benchmark titles are still self-graded. The climb is the plan below: finish the delivery tier, land the rigid-body solver and UDP session, turn the self-graded titles into wired loops, then the editor.

Person · product · place — not yet measured for this domain

Every compare carries this layer. Declare knowledge/compare/gameengine.ppp (rows surface|nishi or c1..c4|label|url|connect naming OUR live surface and each rival's front door), run nx_ppp_probe domain gameengine, and this section fills itself on the next beat: the same ruler on both sides — privacy and CX (third-party hosts, tracker classes, cookies, security headers), design and longevity (design hygiene, computed WCAG contrast, render-blocking resources, unsized media, script weight, theme and motion queries), findability (landmarks, skip link, on-site search, breadcrumb, headings, internal links).

References

Beyond a link list. Every reference below resolves twice — the publisher's copy and, where banked, the estate's own non-rottable library mirror with a content pin — and carries its evidence class plus the exact claim on this page it grounds. Keyed marks like [key] in the matrix notes jump here. A dash means honestly absent, never assumed.

[unreal-features] Epic Games. Unreal Engine features page (Nanite, Lumen, Chaos, Niagara, MetaSounds, PCG, MetaHuman, Pixel Streaming, Enhanced Input, OpenXR named on the page). publisher · read in our library knowledge/fetched/cmp_gameengine_unreal-features.html · pin ha7271bcc095c6edfa41c77a32fc871a8c32cdfc6131da515bb6f634b1b76b8f7 · accessed 2026-08-23 · vendor-docGrounds: Unreal cells on the render, physics, animation, input, audio, navigation and tooling rows: documented capability presence on Epic's own page; no native web export (Pixel Streaming is server-rendered).
[ue-notes] Epic Games. Unreal Engine release notes (the 5.7 URL served the Unreal Engine 5.8 notes on the access date; the page names features introduced in UE 5.7 and expanded in UE 5.8). publisher · read in our library knowledge/fetched/cmp_gameengine_unreal-57notes.html · pin ha717bfb22989a6c36cd6e80262dca230fa045784bfb12ad1eebbe15d7dfff39a · accessed 2026-08-23 · vendor-docGrounds: The Unreal version named on this board (5.8) and the UNPINNED declaration: Epic publishes no machine-readable release registry.
[godot-features] Godot Engine. Features page. publisher · read in our library knowledge/fetched/cmp_gameengine_godot-features.html · pin h5c4403a5bdb18ac24b7360ff4719f3449df7a7f809b3451845e4d9c0c2497d12 · accessed 2026-08-23 · vendor-docGrounds: Godot's editor-first, web-export and XR presence on the bar row.
[godot-docs] Godot Engine. Documentation index, stable branch (physics, navigation, networking, audio, animation, XR, shaders, export, multiplayer, glTF, Jolt, AStar sections named). publisher · read in our library knowledge/fetched/cmp_gameengine_godot-docs.html · pin h7c56e57bda3e71149aa44ef9fd67ddf2616c664c17d4dc34af10f6c2397db162 · accessed 2026-08-23 · vendor-docGrounds: Godot cells on the physics, navigation, audio, animation, asset, input, multiplayer, VR and tooling rows: documented capability presence on Godot's own index.
[godot-web] Godot Engine. Exporting for the Web (stable): the export runs over WebGL 2 with the Compatibility renderer; the page states that Godot currently does not support WebGPU, a prerequisite for Forward+ and Mobile on the web platform. publisher · read in our library knowledge/fetched/cmp_gameengine_godot-web.html · pin h744684d34fde9d4e97a582056bb97f32ac193b71d07fc6a31a7615752a08d3a4 · accessed 2026-08-23 · vendor-docGrounds: Godot's WebGL2 web export (code 2) and WebGPU absence (code 0) on the delivery rows; the one-source native+wasm exceed's comparison column.
[godot-release] GitHub API. godotengine/godot releases/latest: tag_name 4.7.2-stable on the access date. publisher · read in our library knowledge/fetched/cmp_gameengine_godot-release.json · pin h3c304b65efccfc6564240ec474909a948ad24cc6f2cc38017b78a10e31b70a71 · accessed 2026-08-23 · mirrored-indexGrounds: The Godot 4.7 version on this board and the godot bar pinned in knowledge/barcheck.conf for the daily re-read.
[unity-engine] Unity Technologies. Unity Engine product page: the page states that Unity 6.0 is the latest long-term supported release. publisher · read in our library knowledge/fetched/cmp_gameengine_unity-engine.html · pin h27f2e7e1736fccf0e78b5bb4d1ce4af256b70ca0cff439e429d311b9a19d290e · accessed 2026-08-23 · vendor-docGrounds: The Unity 6 version on this board and the UNPINNED declaration (no machine-readable release registry).
[unity-manual] Unity Technologies. Unity 6 manual index (physics, multiplayer, input, XR, animation, audio, UI and scripting sections named). publisher · read in our library knowledge/fetched/cmp_gameengine_unity-manual.html · pin h17f350d0e904b49d9d26567363c8a644b741a0d21eb6777bd9993fc814b128ef · accessed 2026-08-23 · vendor-docGrounds: Unity cells on the physics, input, animation, audio, multiplayer, UI, VR and tooling rows at index level; navigation is coded at package level because it is not on the mirrored index.
[unity-web] Unity Technologies. Unity 6 manual, Web platform page (WebGL named throughout; no WebGPU on the mirrored page). publisher · read in our library knowledge/fetched/cmp_gameengine_unity-web.html · pin h612604bba1793c55deec9e1db960bebd7bc23db2f3a3a21e27c7d27128045788 · accessed 2026-08-23 · vendor-docGrounds: Unity's Web platform presence on the delivery rows (WebGL 1, WebGPU 0 as witnessed) and the one-source exceed's comparison column.
[bevy-home] Bevy. Home page: a data-driven game engine built in Rust on a custom Entity Component System, with renderer, UI and audio named as built-in features. publisher · read in our library knowledge/fetched/cmp_gameengine_bevy-home.html · pin h5b58e5933447b15a37ac8fd39fa6ebb1bc2e194978ed295fc9527af93c86f52e · accessed 2026-08-23 · vendor-docGrounds: Bevy cells on the input, UI, audio and animation rows and its browser presence; the ECS comparison on the bar row.
[bevy-features] Bevy. Quick-start introduction (the engine's own feature summary: ECS, Rust, UI). publisher · read in our library knowledge/fetched/cmp_gameengine_bevy-features.html · pin h29ddde25df964e0fe69441f98fb134b44908062f0edd7ddf0a540968d09f6f4f · accessed 2026-08-23 · vendor-docGrounds: Bevy's no-built-in-physics coding on the physics rows and its asset and hot-reload cells at the level its own intro documents.
[bevy-news] Bevy. News index: the Bevy 0.19 release announcement (written June 19, 2026) and the Bevy + WebGPU post. publisher · read in our library knowledge/fetched/cmp_gameengine_bevy-news.html · pin hde86be960fbed0ce4562dfaa9dd2167408d966bff14b277f82c26422d5df18ad · accessed 2026-08-23 · vendor-docGrounds: Bevy's WebGPU rendering (code 2 on the WebGPU rows) and the 0.19 version on this board.
[bevy-release] GitHub API. bevyengine/bevy releases/latest: tag_name v0.19.1 on the access date. publisher · read in our library knowledge/fetched/cmp_gameengine_bevy-release.json · pin he9469d145af5e249462687f1e157069bac161b900ad9203bb2f24a6884fc2b8b · accessed 2026-08-23 · mirrored-indexGrounds: The Bevy 0.19 version on this board and the bevy bar pinned in knowledge/barcheck.conf for the daily re-read.

generated by nx_swcompare_matrix (sovereign NishiLang organ) from knowledge/compare/gameengine.matrix · every Nishi cell verified against organ source at emit time · watch cells re-measured on every compare beat · zero JS, zero trackers