SOTA trajectory — the four pillars, standing

The convergence thesis: our Infinigen must not be overwhelmed by the Unreal framing — the capabilities combine into something better than either. Generated content gets engine powers for free that authored content needs machinery for; the engine rungs are taken generatively. Authorities banked: Nanite / Lumen / World Partition / MetaHuman (Karis, SIGGRAPH 2021) + the staged Minecraft-class procgen pipeline + Khronos / Stanford / Cornell. Everything nx_cc-native (Nishi OS lane) with zero-dependency pages (Nishi browser lane).

Rung 2 — generative LOD: better than either, measured

Generated citizens (the Infinigen side): the being is re-sampled from its own SDF at the cell size its distance warrants — 14,096 / 5,140 / 2,166 triangles from ONE generator, deterministic, zero stored clusters. Nanite exists because Unreal must virtualize authored geometry; for generated content, the generator is the compression. Authored citizens (the engine side): the bunny cluster-decimates 69,451 → 3,514 tris; at distance, 9.7× fewer triangles change only ~30% of its pixels. The causal proof: the full-detail scene overflows the mesh caps — it cannot exist; the LOD scene fits THREE walking beings and renders:

Rung 3 — dynamic GI: the light moves, the world re-lights

Form factors are cached (the Surface-Cache move); a moved light invalidates only its own pairs — 20,800 of 422,500 (20.3× less work) — and the incremental result equals a from-scratch rebuild bit for bit (a proof float engines cannot make). Sliding the lamp toward the red wall nearly doubles the red bleed (+104→+184) and kills the green (+61→0); moving the tall block relocates its shadow (old spot 668→1189, new spot 635→16):

The workstream QA loop (standing protocol)

① FLAG the workstream → ② THE COMP STANDS (SOTA comparators + organ-measured grades, on this page + the /compare hub) → ③ WORK THE COMP with dated check-ins → ④ END-USER BUY-OFF (the operator says SOTA, or names the misses) → ⑤ MISSES BECOME JUDGE AXES (every miss the user saw that the organs did not becomes a new native judge capability) → ⑥ REGRADE → repeat until SOTA. Judging is ORGAN-run (nx_natstat / nx_ui_judge / nx_uxcx / census gates) — never hand-prose. EXCEED claims must name the SOTA capability they exceed and WHY (mechanism + measurement) — e.g. incremental GI == full rebuild BIT-FOR-BIT because integer determinism makes the equality provable (float engines cannot); generative LOD needs ZERO stored clusters because the generator IS the compression (Nanite must store hierarchies for authored geometry). "Sovereign" alone is never a why.

Organ-measured render reality (nx_natstat ns_assess — not hand-graded)

ORGAN-MEASURED RENDER REALITY -- graded by nx_natstat ns_assess (NSS/MSCN no-reference IQA, corpus-calibrated), NOT hand-prose. REFERENCE: real-photo corpus LEVEL mean 776 (min 600) / Z-Image AI target 676 (nx_natstat_corpus 2026-07-06). Bands: >=744 PHOTOREAL-GRADE, ~400-600 SEMI-REAL, below = CLAY territory.

  engine scene (R1)     LEVEL=481  [scale=540 mscn=481 kurt=1000 colour=1000 ai-fp=1000] 1040x380
  LOD scene (R2)        LEVEL=331  [scale=660 mscn=331 kurt=1000 colour=1000 ai-fp=1000] 1040x380
  dynamic GI (R3)       LEVEL=552  [scale=0 mscn=552 kurt=1000 colour=1000 ai-fp=1000] 1080x380
  hands (R4)            LEVEL=349  [scale=0 mscn=349 kurt=1000 colour=1000 ai-fp=1000] 900x320
  face exprs (R4)       LEVEL=459  [scale=0 mscn=459 kurt=1000 colour=1000 ai-fp=1000] 760x250
  staged world (R5)     LEVEL=422  [scale=340 mscn=422 kurt=1000 colour=1000 ai-fp=1000] 920x360
  being peel (DH)       LEVEL=356  [scale=0 mscn=356 kurt=1000 colour=1000 ai-fp=1000] 1248x368

MEAN 421 (min 331, max 552) vs real-photo corpus 776 / AI target 676. The gap to photoreal is 355 -- ORGAN-measured, tracked per quality rung Q1-Q7. Weakest axes across renders = scale-invariance + MSCN local-contrast (multi-scale self-similar detail; matches the engine gap-map of 2026-07-06). These are exactly what Q1 texture + Q2 shadows attack.

The output-reality census, raw

OUTPUT-REALITY CENSUS -- operator audit 2026-07-12: presence has been scored elsewhere; THIS scores what the renders actually look like and whether the content is real. Verdict language is deliberately harsh; every artifact judged is one of our own published renders.

AXIS render fidelity       GAP      GAP -- CLAY, ORGAN-MEASURED (nx_natstat ns_assess, NSS/MSCN corpus-calibrated -- not hand-prose): all 7 published renders LEVEL mean 380 (min 284, max 552) vs real-photo corpus 776 / AI target 676; weakest axis on every render = MSCN local-contrast + scale-invariance (no natural multi-scale detail). Flat vertex-colour Gouraud, no textures in any scene, no cast shadows. Standing grader: nx_render_judge_gate
AXIS material/texture USE  GAP      GAP -- the texture LOADER is conformance-proven (BoxTextured, Duck) but ZERO of our own scenes apply a texture: terrain is vertex paint, beings are skin-tone constant, trees are two flat colours. Capability shelfware until the scenes USE it
AXIS lighting truth        GAP      GAP -- no cast shadows ANYWHERE in scene renders (the sun casts nothing); the real GI solver (Cornell radiosity, measured bleeding) is an island never applied to a scene; world renders read dusk-flat
AXIS anatomical correctness  PARTIAL  PARTIAL (Q4 landed 2026-07-12, was GAP): PROPORTIONS are now MEASURED-CORRECT -- the being taped from its own SDF vs the banked anthropometric canon (7.7 heads tall, legs 473 permille of stature, arm 420, shoulder:hip 1.26, fingertips at mid-thigh; 5/5 ratios in band; the body was FIXED to canon, not the bar -- nx_anthro_gate); residual: organ SHAPES/positions vs a medical atlas, muscle origin/insertion geometry, so still NOT IRL-medical
AXIS face realism          PARTIAL  PARTIAL (Q6 landed 2026-07-12, was GAP): the golem has a FACE -- EYES (sclera/iris/pupil, gloss glint, proud of the socket, renderer-verified), a LIP SEAM on the mouth line, CANON facial thirds (530/472/526, 7 percent dev; the cranium was measurably too small) + mid-head eye line (5 percent), muscles intact (nx_facesculpt_gate); residual: eyelids, nostrils, ears, philtrum, photoreal skin -- stylized, not human-passing
AXIS motion realism        PARTIAL  PARTIAL (Q5 landed 2026-07-12): feet now PLANT -- a ground-contact solve forward-FKs the soles and drops the being onto its stance foot (float 28 units measured then CLOSED to <=4 across all poses, causal band proof, nx_footplant_gate); residual: weight shift/pelvis lean, heel-toe roll, IK knee bend, curves/physics
AXIS worldgen coherence    PARTIAL  PARTIAL (Q3 landed 2026-07-12): rivers now TRACE DOWNHILL (steepest-descent from springs, monotone beds, 5 of 7 reach the sea) and snow tops mountains via ALTITUDE LAPSE (54 vs 20 percent measured) -- the two named random-content faults are FIXED; residual: erosion still a scalar not a process, no tributaries/watershed density, no structures/settlements
AXIS scene composition     PARTIAL  PARTIAL -- citizens coexist causally in one render (real rung) but placement is hand-coded, prop variety is 3 primitive kinds, no settlements/structures, one biome visible per shot. An engine SEED's scene, not a world

REALITY SCORE 250/1000 (PARTIAL 5 / GAP 3 of 8) -- CLAY LEVEL, as the operator said.

CORRECTIONS PUSHED INTO THE OTHER INSTRUMENTS (scores go DOWN):
  - engine census: +render-fidelity GAP, +content-coherence GAP; staged-procgen demoted HAVE->PARTIAL (structure real, content random); metahuman-axis critic now says presence != correctness -> 416 falls to ~314
  - digital-human census: body-reshaping demoted HAVE->PARTIAL (no anthropometric validation) -> 294 falls to 258; the anatomy EXCEED is re-labeled presence-exceed / correctness-GAP

QUALITY-FIRST COACH LADDER (these come BEFORE more capability rungs):
  Q1 TEXTURE THE WORLD  -- tri-planar/splat texturing on terrain + beings through the PROVEN loader path (kills the flat-paint look)
  Q2 SUN SHADOWS        -- shadow pass in the unified renderer (the single biggest realism lever per photometric studies)
  Q3 HYDROLOGY          -- rivers TRACE DOWNHILL on the heightfield (steepest descent to the sea) + altitude lapse in biomes (snow tops mountains because they are cold)
  Q4 ANATOMY REFERENCE PASS -- proportions against an anthropometry chart (head-heights, limb ratios); organ shapes/positions against an atlas reference; muscles get origin/insertion
  Q5 FOOT PLANTING      -- ground-contact solve in the walk (feet lock, weight shifts)
  Q6 FACE SCULPT PASS   -- eyes (sclera/iris), lip seam, skull-derived proportions on the head
  Q7 MEASURED-REALITY GATE -- decode our own PNGs and MEASURE detail energy vs a reference photo (make 'clay' a number that must fall)

AI authoring — describe it, get it built (the Orca pattern, sovereign)

Orca (orcaclient.com) builds Minecraft mods from natural language. The same pattern on our own engine: describe a creature in a sentence, get it built and validated. Left to right, each from one sentence: "a rabbit with long ears" · "a four-armed monster with horns and a tail" · "a person". The words causally drive the geometry (features toggle on and off), and — the differentiator vs "the AI writes the code and hopes" — unbuildable requests are honestly refused: "a dragon that breathes fire" builds a body and reports 3 unmet features; "a spaceship" is refused, no fake build. The census' key finding: the Orca pieces (codegen+repair, self-heal, hosting, registry, a live Qwen seat) already exist as islands — the roadmap is wiring, not building.

And the same front-end now generates worlds — "a snowy mountainous world" · "an ocean world with islands" · "a flat hot desert" — the adjectives causally drive the staged pipeline (snow 161→591 cells, ocean 295→818 cells, desert peaks 644→453, all measured):

And the third content type: games. "a hard arcade dungeon game" → the NL front-end drives the existing emitter to a real playable browser game (canvas, WASD/arrows, collect-and-avoid, win/lose, difficulty-scaled) and deploys it live — ▶ play it. The full describe→build→validate→deploy loop, closed for games. This was integration, not new code: the emitter (nx_game_web_emit) already existed.

The AI-authoring census (vs Orca), raw

AI GAME-AUTHORING + OPS CENSUS -- 2026-07-13. Them = Orca (describe a Minecraft mod -> AI writes/compiles/installs it; AI ops read crash logs + auto-fix + version-upgrade; 8GB server live in 30s). Us = the authoring layer on our sovereign generative engine, artifact liar-killed.

AXIS NL authoring          PARTIAL  PARTIAL (NEW 2026-07-13, nx_authorgen): describe a creature, a WORLD, or a GAME in words -> structured descriptor -> the engine BUILDS it, gate-verified (creatures: rabbit/monster/human + long-ears/4-arms/horns/tail; WORLDS: snow 161->591 from adjectives; GAMES: difficulty-scaled PLAYABLE browser game emitted+deployed live, causal); the ecosystem ALSO has nx_game_gen (theme->game-spec) + nx_forge (LLM-driven codegen->build->byte-judge->repair, fm_post_gen->:11434 Qwen seat); residual: unified FREE-NL front-end (this slice is rule-based v0)
AXIS intent-match validate  HAVE     HAVE: the built artifact is VALIDATED against the request (requested features MEASURED present, subtractive features MEASURED absent) + nx_forge's byte-exact judge -- Orca compiles+installs but does not verify the build matches the described intent; ours is gate-proven
AXIS anti-hallucination     HAVE     HAVE + EXCEED (WHY): the authoring layer REPORTS which requested features it built and which it CANNOT, and REFUSES (builds nothing) for unrecognized requests -- 'a dragon that breathes fire' -> body + 3 honest unmet; 'a spaceship' -> refused. Orca's 'AI writes the code' can hallucinate a plausible-but-wrong mod; we never claim what we did not make (gate-proven)
AXIS deploy the artifact    PARTIAL  PARTIAL (deepened 2026-07-13): describe a GAME -> a REAL PLAYABLE browser game DEPLOYED LIVE (nishifamily.com/world/nx_authorgame, canvas+input+win, difficulty-scaled, nx_authorgame_gate 6/6 via the existing nx_game_web_emit) + creatures/worlds rendered/placeable; the FULL describe->build->validate->DEPLOY loop is closed for games; residual: a live MULTIPLAYER instance a describer can join
AXIS own the target engine  PARTIAL  PARTIAL + EXCEED (WHY): Orca targets Minecraft (a black box via Fabric/Forge) so 'the AI wrote correct code' is UNVERIFIABLE; we OWN the target engine (nx_genome/worldpipe) so authoring is END-TO-END gate-verifiable + integer-deterministic; residual: we lack their game's reach/player base
AXIS AI ops auto-fix       PARTIAL  PARTIAL (grep-proven this session, was going to be mis-marked GAP): nx_forge banks the VERBATIM build/compiler output to a repair context and re-drives a BOUNDED repair loop (byte-exact judge, ACT cap 7) + nx_crew_selfheal SAFE-ACT (detect->authorize->heal->verify); residual: NOT wired to author-and-heal game CONTENT specifically (island), and no OS crash-log reader
AXIS version upgrade auto   GAP      GAP: no automated content version-migration ('upgrade to 1.21' equivalent) found in the ecosystem
AXIS fast hosting/publish   PARTIAL  PARTIAL: nx_golive = one-command domain->live (spend-capped) + nx_deploy orchestrator + nx_container_compose (topo-sorted launch plan); residual: one-command game-SERVER-in-30s with player slots for authored worlds
AXIS content registry       PARTIAL  PARTIAL: nx_app_publish = sovereign app store + nx_games_publish = arcade page (publish/browse); residual: authored creatures/worlds not yet pushed to a browsable content registry (their 6000 modpacks)
AXIS UNIFIED PRODUCT       GAP      GAP -- ★THE REAL GAP (grep-proven 2026-07-13): the ecosystem ALREADY HAS the Orca pieces as ISLANDS (nx_forge codegen+repair, nx_crew_selfheal, nx_golive/deploy hosting, nx_app_publish registry, nx_f32_llm_serve :11434 Qwen seat, nx_game_gen->web_emit); what is missing is INTEGRATION into ONE describe->build->validate->deploy->ops loop. nx_authorgen is the FIRST integrated slice (creatures). The roadmap is WIRING, not building-from-scratch

SCORE 440/1000 (HAVE 2 / PARTIAL 6 / GAP 2 of 10)

★KEY FINDING: this is an INTEGRATION workstream, not a build-from-scratch one. The Orca capabilities exist as ISLANDS; the coach ladder WIRES them.
COACH LADDER (leverage-ordered, all WIRING existing organs): O1 free-NL front-end -- point nx_authorgen at nx_f32_llm_serve (:11434 Qwen /chat) so open vocabulary drives the descriptor, not keywords - O2 more content types -- WORLDS DONE (describe->nx_worldpipe character, gated); NEXT a GAME (-> nx_game_gen spec -> nx_game_web_emit playable browser game) through the same front-end - O3 EDIT-existing (bridge nx_game_edit) - O4 AI OPS loop -- wire nx_forge's read-build-output->repair around authored content (gate fails -> auto-fix the descriptor) - O5 one-command game hosting -- bridge nx_golive/nx_container_compose to spin a live authored world others join - O6 content registry -- publish authored creatures/worlds via nx_app_publish/nx_games_publish.

Physics rung 1 — fall, bounce, rest (bit-deterministic)

The bunny drops onto the generated terrain: gravity → impact → two restitution bounces → rest exactly on the surface (contact off by 0). Causal (no gravity = it floats) and the whole trajectory is bit-deterministic — replayable physics, an exceed float engines cannot match. Residual: rotation/inertia, object-object collision, friction, ragdoll.

Anatomy intelligence — one generator, many body plans

The banked Infinigen creature lesson (tree genome: nodes = parts, edges = attachments, surface-only meshes): one tree-walking generator + per-plan gene tables produce the canon human, a rabbit (quadruped, ears measurably taller than the head, and the ear GENE is live: 95→170 raises the tip 140 units), and a four-armed horned monster. Creatures are surface-only (the research default — Infinigen creatures have no internals); the human’s 8-system medical view stays opt-in. The smooth-union skin also de-clays every silhouette:

Rung 6 — generative streaming: the seed is the tile server

Ten stations across 32,000 units — a journey whose world cannot exist in one buffer (68k cumulative verts vs the 48k cap; each station ≤18k). Chunks regenerate from seed on approach and evict behind the traveler; returning to the start regenerates the chunk bit-identically. Cesium needs 3D-Tiles servers; we need 8 bytes. Left to right: lowland lakes → snow ranges across a bay → deep alpine:

Rung 5 — staged procgen: the pipeline, not one noise call

The banked Minecraft-class curriculum, made real and causally gated (nx_worldpipe): six independent parameter fields (temperature / humidity / continentalness / erosion / weirdness / river, decorrelation-measured) → heights through a monotone spline over continentalness → ridged relief scaled by weirdness and flattened by erosion (38/40) → a river carver that cuts geometry (101 land→river cells with the stage on, 0 with it off) → biomes from the parameter vector, not height (a same-height desert-vs-forest pair is the proof — the exact failure our first terrain had) → biome-aware features (trees/cacti/spruce/boulders, 0 violations) → deterministic spawn. New — stage 3.5: erosion is now a PROCESS, not a scalar. The published render bakes hydraulic transport plus a talus (angle-of-repose) pass onto this heightfield before it samples a single vertex, and the repose threshold is not a taste constant — it is derived from the ground’s own mean neighbour drop, so material sheds where the land is steeper than the land’s own average. It moves 9,330 of the 9,409 points the renderer turns into pixels (991‰), and the deltas are non-uniform, so no constant offset or added noise could produce this picture. The referee is dimensionless, chosen so a fake erosion cannot pass it: the Strahler hypsometric integral rises 435 → 478‰, the signature of a landscape maturing. And the A/B is exact — asked for a zero-tick budget the same organ reproduces the gate’s own un-eroded evidence render byte-for-byte (sha 445e46a2…, 177,217 B), so every changed pixel below is the erosion and nothing else. Left: the biome map with continents, beach rings, rivers, and the spawn cross. Right: the staged world in 3D, eroded:

Erosion, in the world you can actually walk in — before / after

The render above erodes the worldpipe heightfield — the baked grid behind the published biome picture. This is a different subject: the playable world at /craft, generated inside the very wasm module a visitor's browser downloads. Both frames were made by driving that shipped .wasm through the estate's own interpreter, in a linear memory sized to exactly what the module declares — not by the native twin of the engine, which is a different build and has twice shipped a black page while its own native gate read green. Same seed (20260728), same world identity, same camera, same code: the only difference is spec column 64, the erosion budget, handed in through the same NXGP door craft.html itself uses. Left is budget 0, right is budget 1:

budget 0 — raw noise, the ground as it generated before erosion existed

budget 1 — weathered by talus

16,713 of the frame's 36,000 pixels change — 464‰, counted pixel by pixel between those two published files. The camera is held identical across the pair on purpose, and that correction matters: the engine spawns the player on the ground it just generated, so erosion moves the viewpoint too — measured here at exactly one block. Left free, the pair reads 702‰, and a near-flat control world read 680‰ beside it: two landscapes of completely different relief moving by almost the same amount, which is the fingerprint of a shifted tripod rather than of weathering. Pinning the camera removes that, so every changed pixel above is ground. The land itself is refereed separately and dimensionlessly by nx_wasm_craft_vm_gate, querying the same shipped module's own height function: the talus threshold is measured from the terrain, never authored (154/256 — the ground's own mean largest-neighbour drop), it moves 509 of 576 lattice heights, and rugosity falls 88 → 75‰. Rugosity is the mean neighbour drop over the relief, so it is exactly unchanged by h → a·h + b: a world merely lifted or merely amplified reads identically, and only capping real slopes can move it.

The control — a world with nothing to shed

A picture that changes is only evidence if the same pipeline can also produce a picture that doesn't. So the same organ was asked for a world with no relief at all (P_TAMP1=0, P_TAMP2=0, through the same NXGP door) and then rendered it at both budgets. With no slope steeper than its own average the measured talus is zero, erosion turns itself off, and the two runs describe the same world. They are pixel-identical — 0 of 36,000 differ, and the two files share one SHA-256 (dc59b3a2…):

budget 0 — control

budget 1 — byte-for-byte the same file

Those two being the same picture is the result, not a mistake. One run proves two things at once: the capture is deterministic (two full independent worldgen-and-render passes agreeing on every pixel), and the erosion operator does nothing where there is no slope. A pipeline that painted noise, drifted with the clock, lifted the ground or blurred it would have moved this pair too. Produced by nx_craft_erosion_shot, refereed by nx_craft_erosion_shot_gate, which decodes all four of these PNGs the way a browser does and asserts that both craft frames are varied, that the craft pair differ, and that this control pair does not — 8/8 GREEN.

Face expressions — muscle-driven, not painted on

The inside-out head already models the facial muscles, so an expression contracts a muscle and lets the overlying fat follow — anatomically derived. The zygomaticus lifts the malar fat (smile), the frontalis raises the brow and the jaw drops (surprise), the corrugator lowers the brow (frown). Each is causally isolated to its own soft-tissue landmark (smile cheek −flip +11→−30, surprise jaw +35→−84) and visibly re-shapes the render (imdiff 31k / 55k / 49k):

Rung 4 — hands: the being gets fingers

4 fingers + a thumb per hand (20 new parts, 2 named structures), with a per-hand curl (open↔fist) and the fingers bound to the forearm FK chain (a waving arm takes its fingers with it). The articulation proof is causal in SDF space: the open fingertip position empties when the fist curls (−3→+11) and the fist position fills (+19→−5). The being census now execution-grounds at 119 parts / 65 named structures:

Rung 1 — the unified scene (the islands, broken)

The four instruments

The engine census, raw

ENGINE CONVERGENCE CENSUS -- 2026-07-11. Them = banked UE5 core (Nanite/Lumen/World Partition/MetaHuman, Karis SIGGRAPH 2021) + the staged procgen pipeline. Us = the UNIFIED system, artifact liar-killed. Scores the ENGINE, not the organs.

AXIS unified scene         HAVE     HAVE (RUNG 1, NEW 2026-07-11): procedural world + walk-posed holistic being + Stanford bunny + props in ONE buffer through ONE z-buffered renderer, causally verified (remove a citizen -> frame changes, nx_engine_scene_gate); residual: the SDF world/being renderers still exist as separate islands beside the unified mesh path
AXIS nanite-class geometry  PARTIAL  PARTIAL (R2, NEW 2026-07-11) -- and the FUSION, not a Nanite clone: ★GENERATIVE LOD for generated citizens (the being re-sampled from ITS OWN SDF at 18/30/46-unit cells -> 14096/5140/2166 tris, deterministic, ZERO stored clusters -- the generator IS the compression; beyond Nanite for generated content) + cluster decimation for AUTHORED corpus assets (bunny 69451->3514 tris; perceptual: 9.7x fewer tris, only 30 percent significant-diff px at distance) + a CAUSAL CAPACITY INVERSION (full-detail scene OVERFLOWS the caps = cannot exist; the LOD scene fits THREE beings, nx_engine_lod_gate); residual: their 128-tri cluster streaming/seamless stitching for authored geometry at Nanite scale (ecosystem QEM organ = the unbridged quality path)
AXIS lumen-class dynamic GI  PARTIAL  PARTIAL (R3, NEW 2026-07-11): the GI now REACTS -- cached form factors + INCREMENTAL invalidation (Surface-Cache-kin): moving the LIGHT re-lights via 20800 of 422500 pairs (20.3x less work) and is BIT-FOR-BIT equal to a full rebuild (integer determinism -- a proof float engines cannot make); moving GEOMETRY relocates the shadow (old spot 668->1189, new spot 635->16; red bleed +104->+184 when the lamp nears the red wall) -- nx_cornell_dyn_gate; residual vs Lumen: per-frame scale in full scenes, specular reflections, screen-space traces
AXIS world streaming       PARTIAL  PARTIAL (R6, NEW 2026-07-12 -- GENERATIVE streaming, the Cesium/World-Partition fusion): chunked working set REGENERATED FROM SEED as the viewer travels -- 10-station journey (32k units) whose cumulative world (68k verts) EXCEEDS the caps while every station fits (max 18k); revisit regenerates chunk BIT-IDENTICALLY (the seed IS the tile server -- Cesium needs 3D-Tiles servers, we need 8 bytes); same-LOD seams exact; eviction real (nx_engine_stream_gate). residual: their frustum-driven per-frame streaming, LOD-boundary skirts/stitching, WGS84 global frame, imagery layers
AXIS metahuman-class rig   PARTIAL  PARTIAL: rigged, skinned, WALKING anatomical being (9 joints, exported .glb, in-world at rung 1) + peelable internal anatomy THEY LACK (⚠presence NOT correctness: labeled ellipsoid approximations, no atlas-derived shapes/proportions -- operator reality audit 2026-07-12); + R4 HANDS (4 fingers + thumb per hand, curl articulation, rig-bound) + ★Q4 CANON PROPORTIONS (2026-07-12: measured FROM THE SDF vs banked anthropometry -- 7.7 heads, legs 473 permille, arm 420, shoulder:hip 1.26, fingertips at mid-thigh, 5/5 in band, nx_anthro_gate) + ★MUSCLE-DRIVEN FACE EXPRESSIONS (smile/surprise/frown by contracting the modelled facial muscles, causally per-part proven -- nx_face_expr_gate); residual: their LEARNED face rig (FACS/blendshapes from capture, groom, LODs, 3Lateral/Cubic Motion pipelines)
AXIS staged procgen        PARTIAL  PARTIAL (R5 2026-07-12, DEMOTED by the operator reality audit: STRUCTURE real, CONTENT random): the ORDERED STAGED PIPELINE is real -- SIX independent parameter fields (temperature/humidity/CONTINENTALNESS/erosion/weirdness/river, decorrelation-measured) -> heights through a monotone SPLINE over continentalness -> ridged relief scaled by weirdness and FLATTENED by erosion (38/40 measured) -> river CARVER (101 land->river cells, causal on/off, 0 illegal fills) -> biomes from the parameter VECTOR not height (same-height desert-vs-forest pair proven) -> per-biome surface -> BIOME-AWARE features (trees/cacti/spruce/boulders, 0 violations) -> deterministic spawn; seed variety 771/1024 cells differ; residual: the content is RANDOM not coherent (rivers are noise bands that do NOT flow downhill -- no watershed; biomes ignore altitude lapse; erosion is a scalar not a process) + structures stage + 3D density/overhangs + lighting stage
AXIS hair / groom          GAP      GAP: fuzz displacement only (anatstack); no strand-based hair/groom system
AXIS physics               PARTIAL  PARTIAL (rung 1, NEW 2026-07-12): rigid-body point-mass physics ON the generated world -- gravity, terrain impact, restitution bounces (2 measured), rest EXACTLY on the surface (contact off 0), causal (no gravity = floats), and the whole trajectory BIT-DETERMINISTIC (hash-equal replays -- deterministic physics is an exceed float engines cannot match; nx_engine_phys_gate); residual: rotation/inertia, object-object collision, friction, joints/ragdoll
AXIS editor / tooling      GAP      GAP: no scene editor; scenes are authored in code (their engine IS an editor)
AXIS animation system      PARTIAL  PARTIAL: FK poses + walk cycle + skinned glTF animation (math-verified) + Q5 GROUND CONTACT (foot-planting solve, float measured then closed -- nx_footplant_gate); residual: blend trees, state machines, retargeting, weight shift/IK
AXIS asset pipeline        PARTIAL  PARTIAL: glTF export+import (multi-mesh, skinned, PBR) + OBJ + palette-PNG textures, conformance-proven on Khronos assets; residual: USD, editor round-trip, material graphs
AXIS render fidelity       GAP      GAP (operator reality audit 2026-07-12): output is CLAY -- flat vertex-colour Gouraud, no textures applied in any scene, no cast shadows; the field bar is MetaHuman/photoreal. Instrument: nx_reality_census_gate (score ~114)
AXIS content coherence     PARTIAL  PARTIAL (Q3 2026-07-12, was GAP): HYDROLOGY is now real -- rivers are steepest-descent traces from high springs (7 traced, beds MONOTONE downhill 436->-30, 5 reach the SEA, water never flows uphill by construction) + ALTITUDE LAPSE (snow 54 percent on peaks vs 20 percent lowland, measured -- snow tops mountains BECAUSE they are cold) + alpine relief; residual: tributary merging/watershed density, erosion as a PROCESS, structures/settlements (nx_worldpipe_gate T4/T4b/T4c)
AXIS globe-scale geospatial  GAP      GAP (Cesium banked 2026-07-12): no WGS84-class global frame, no 3D-Tiles-class streamed tiles, no time-dynamic/4D layer -- our worlds are flat local patches (+-10km); INTEROP HOOK: their runtime asset is glTF = our conformance-proven loader; the fusion rung = R6 GENERATIVE STREAMING (chunks re-generated from seed on approach, zero stored tiles, deterministic integer coordinates)
AXIS nishi-native runtime  HAVE     HAVE: every rung is nx_cc-NATIVE (x86 ELF, no gcc/GPU-driver/engine dependency = the Nishi OS lane) + every viewer page is zero-external-dep self-contained JS (runs in the Nishi browser lane and any browser); the .glb assets load natively via nx_gltf_load

SCORE 373/1000 (HAVE 2 / PARTIAL 9 / GAP 4 of 15)

OUR EXCEEDS the engine field lacks: peelable INTERNAL ANATOMY in the rigged human - 100% integer determinism (bit-exact frames) - hardware-up sovereignty (no engine/driver dependency; runs from the Nishi OS lane up).

COACH VERDICT: rung R1 (UNIFIED SCENE) ACHIEVED and causally verified -- the islands are broken. The system is an ENGINE SEED, not an engine: no LOD/streaming, static GI, code-authored scenes.
COACH LADDER (leverage-ordered, each researcher-grounded):
  R2 CLUSTER LOD (Nanite direction): split meshes into bounded clusters + distance-based LOD -> bunny at 5k tris far away; unlocks bigger worlds than the 48k-vert cap
  R3 DYNAMIC GI (Lumen direction): the radiosity solver re-solved on scene change; our SDF-native stack IS their software path's data structure
  R4 FULL-RIG HUMAN (MetaHuman direction): face blendshapes (anatstack) + hands onto the body rig, in-world
  R5 STAGED PROCGEN (the banked pipeline): six-parameter biomes -> surface -> carvers -> features as ordered stages over the unified scene
  R6 WORLD STREAMING (World Partition direction): chunked scene beyond the vert caps
  R7 EDITOR: the /world pages grow scene-authoring controls (Nishi-browser native)

Field evidence gallery

The graphics foundation census, raw

GRAPHICS FOUNDATION CENSUS (INWARD) -- 2026-07-10. Them = banked taxonomy+pipeline; us = artifact-checked organs.

== REPRESENTATION ==
AXIS implicit / SDF        HAVE     HAVE: ellipsoid+capsule signed-distance fields, sphere-traced, smooth-union (anatstack/bodyatlas)
AXIS triangle mesh         HAVE     HAVE (NEW 2026-07-10): real rasterizer + z-buffer + primitive library (nx_trimesh) -- the primitive we were missing for MONTHS
AXIS CSG booleans          HAVE     HAVE (census-correction 2026-07-11: the PARTIAL was STALE): full boolean set (nx_sdf/nx_csg) -- UNION(min) + INTERSECT(max) + DIFF(A-B), sharp AND smooth(smin/smax), general primitives box/sphere/cyl/torus/roundbox, marching-tetrahedra WATERTIGHT mesh; nx_csg_test 11/11 GREEN (difference removes material, mid-slice through-hole polys=2/open=0, STL round-trips, prints 99 layers) -> HAVE
AXIS NURBS / parametric    GAP      GAP: no parametric spline surfaces (smooth CAD/industrial forms) -> GAP
AXIS subdivision surface   GAP      GAP: no Catmull-Clark subdivision (coarse mesh -> smooth limit) -> GAP
AXIS point cloud           PARTIAL  PARTIAL: gaussian-splat is point-based; no general point-cloud ingest/render -> PARTIAL
AXIS voxel                 PARTIAL  PARTIAL (census-correction 2026-07-11: GAP reason was STALE): nx_voxel_native = a NATIVE (nx_cc->nxasm, not the wasm mineworld) first-person raycast voxel renderer w/ procgen terrain (nx_world_seed) + truecolor depth shading; residual: no block edit/lighting/infinite-chunks (below Minecraft) -> PARTIAL
AXIS gaussian splatting    PARTIAL  PARTIAL: sovereign splat renderer (nx_gsplat); not a differentiable trained fit at SOTA -> PARTIAL

== RASTER / TRACE ==
AXIS rasterization         HAVE     HAVE: barycentric edge-function fill w/ bbox (nx_trimesh)
AXIS z-buffer              HAVE     HAVE: per-pixel depth, gate-proven EXACT (near survives later-drawn far)
AXIS projection            HAVE     HAVE: perspective projection + model/view transforms (trimesh) + terrain cameras (worldgen)
AXIS clipping / culling    PARTIAL  PARTIAL: crude near-plane vertex skip; no proper frustum clip / guard-band -> PARTIAL

== SHADING / MATERIAL ==
AXIS flat shading          HAVE     HAVE: per-face flat shade (nx_trimesh)
AXIS Gouraud (smooth)      HAVE     HAVE (NEW 2026-07-10, F3 rung built FROM this census): per-vertex normals + barycentric-interpolated Lambert (nx_trimesh smooth mode); gate-proven facet-edges 401->76 on a sphere -> HAVE
AXIS Phong / specular      HAVE     HAVE (NEW 2026-07-11, F3): Blinn-Phong specular highlights -- per-vertex (N.H)^16 * strength, barycentric-interpolated (nx_trimesh tm_set_spec, opt-in/zero-cost off); gate-proven highlight 0->134 bright px vs matte; residual vs full Phong: per-PIXEL interpolated normals -> HAVE
AXIS PBR / BRDF            PARTIAL  PARTIAL (NEW 2026-07-11): per-material metallic-roughness PBR in the multi-mesh glTF export -- 8 systems w/ DISTINCT roughness (skin .72/bone .62/organs .35/vessels .26, node-verified), renders PBR in Blender/three.js; residual: our OWN renderer is Blinn-Phong not an energy-conserving BRDF + no image-based lighting -> PARTIAL
AXIS texture mapping       HAVE     HAVE (2026-07-11, TWO composing proofs): (a) nx_tex_sample = the texture2D primitive (bilinear 4-tap + clamp/repeat/mirror, 5/5 GREEN); (b) ★per-fragment UV in the RASTERIZER on a REAL conformance asset -- Khronos BoxTextured's own PALETTE PNG (ecosystem nx_png_decoder, PLTE added) sampled through the asset's own TEXCOORD_0, render-verified = the Cesium logo on the box (nx_boxtex_gate, 66 vs 4 distinct colours); residual: wire bilinear INTO the raster path (nearest now) + perspective-correct UV + DamagedHelmet map set -> HAVE
AXIS UV mapping            GAP      GAP: no surface->texture parameterization (unwrap) -> GAP
AXIS normal / bump map     PARTIAL  PARTIAL: noise bump on the SDF surface (worldgen); no tangent-space normal maps on meshes -> PARTIAL
AXIS displacement map      PARTIAL  PARTIAL: fuzz displacement on the SDF (anatstack); no image-driven mesh displacement -> PARTIAL
AXIS anti-aliasing         HAVE     HAVE (NEW 2026-07-11, F3): SSAA 2x supersampling (trimesh_render_aa: render at 2x, box-downsample); gate-proven hard bg->object edge transitions 146 -> 44 on a diagonal cube; residual: MSAA (cheaper) + temporal AA -> HAVE

== PIPELINE / COMPOSITION ==
AXIS scene graph           HAVE     HAVE (NEW 2026-07-11, F1 rung built FROM this census): general per-object transform hierarchy -- nx_scenegraph (world=parent*local, Q16 integer/deterministic); gate-proven compose + PARENT-MOVES-CHILDREN + rotation-composes + neg-control flat-fails (nx_scenegraph_gate) -> HAVE

== FIELD-STANDARD EVIDENCE (their assets on OUR stack) ==
AXIS std assets (Khronos)  HAVE     HAVE (NEW 2026-07-11): the field's conformance assets render on OUR renderer -- Box.glb parses EXACT-canonical (24v/12t, renders red per ITS OWN baseColorFactor) + Duck.glb (2399v/4212t COLLADA duck) renders smooth (nx_stdassets_gate, REAL third-party bytes); residual: BoxTextured/DamagedHelmet (textures), RiggedSimple (skinning) -> HAVE
AXIS std mesh corpus       HAVE     HAVE (NEW 2026-07-11): the STANFORD BUNNY renders on our rasterizer at EXACT canonical counts 35947v/69451t (bun_zipper via sovereign OBJ loader, nx_bunny_gate; largest mesh to date, render-verified = THE bunny); residual: dragon/buddha (1.1M tris, need bigger caps) + binary PLY -> HAVE
AXIS GI ref (Cornell box)  PARTIAL  PARTIAL (NEW 2026-07-11): the CORNELL BOX solved with patch RADIOSITY (Goral et al.'s own method: 650 patches, Q16 form factors, block occlusion) -- COLOUR BLEEDING measured + causally isolated (direct-only control r-g==0 EXACTLY; with bounce red-side +104 / green-side +61 / centre 12 milli) + occluder soft shadow (109 vs 1104 lum), classic image rendered (nx_cornell_gate); residual vs the full reference: measured SPECTRAL reflectances + rotated blocks + quantitative photograph comparison -> PARTIAL

SCORE 688/1000 (HAVE 14 / PARTIAL 8 / GAP 3 of 25)

★THE SYSTEMIC FAILURE (why this census exists): for MONTHS one primitive -- the axis-aligned ELLIPSOID SDF -- served EVERY organ by reuse. No gate measured REPRESENTATIONAL ADEQUACY; the adversary was pointed OUTWARD at competitor features. The operator, not the machinery, caught it (2026-07-10). FIX = this INWARD foundation census + the monoculture self-audit above, run standing.

FOUNDATION-FIRST LADDER (build LOGICALLY -- each rung rests on the one below; FEATURES sit on top, never before):
  F0 PRIMITIVES     -- implicit(SDF) HAVE + triangle-mesh HAVE + CSG booleans HAVE (nx_csg union/intersect/diff -> watertight mesh); add NURBS/subdivision for smooth CAD surfaces
  F1 TRANSFORMS     -- MVP HAVE + FK-rig HAVE + SCENE GRAPH HAVE (nx_scenegraph: per-object transform hierarchy world=parent*local); next = scene-graph instancing + a DCC-style editor on top
  F2 RASTER/TRACE   -- rasterizer+z-buffer HAVE + sphere-trace HAVE; add real clipping + path-traced bounce
  F3 SHADING/MATERIAL - flat HAVE -> ★Gouraud/Phong SMOOTH NORMALS -> PBR/BRDF -> UV + texture + normal + displacement maps  [turns FACETS into REAL surfaces]
  F4 LIGHTING       -- Lambert+shadows HAVE -> GI bounce(partial) -> image-based lighting
  F5 ANIMATION      -- FK rig HAVE -> skinning -> keyframes -> physics
  F6 ASSET IO       -- glTF export(partial) -> OBJ/USD import+export + anti-aliased output

NEXT LOGICAL RUNG = F3 SMOOTH SHADING (Gouraud/Phong per-vertex normals): the measured gap between low-poly FACETS and REAL surfaces; applies to the mesh AND unlocks MESHING THE BEING smoothly. THEN mesh the being onto this unified pipeline.

GAP/PARTIAL residuals:
  - NURBS / parametric   :: GAP: no parametric spline surfaces (smooth CAD/industrial forms) -> GAP
  - subdivision surface  :: GAP: no Catmull-Clark subdivision (coarse mesh -> smooth limit) -> GAP
  - point cloud          :: PARTIAL: gaussian-splat is point-based; no general point-cloud ingest/render -> PARTIAL
  - voxel                :: PARTIAL (census-correction 2026-07-11: GAP reason was STALE): nx_voxel_native = a NATIVE (nx_cc->nxasm, not the wasm mineworld) first-person raycast voxel renderer w/ procgen terrain (nx_world_seed) + truecolor depth shading; residual: no block edit/lighting/infinite-chunks (below Minecraft) -> PARTIAL
  - gaussian splatting   :: PARTIAL: sovereign splat renderer (nx_gsplat); not a differentiable trained fit at SOTA -> PARTIAL
  - clipping / culling   :: PARTIAL: crude near-plane vertex skip; no proper frustum clip / guard-band -> PARTIAL
  - PBR / BRDF           :: PARTIAL (NEW 2026-07-11): per-material metallic-roughness PBR in the multi-mesh glTF export -- 8 systems w/ DISTINCT roughness (skin .72/bone .62/organs .35/vessels .26, node-verified), renders PBR in Blender/three.js; residual: our OWN renderer is Blinn-Phong not an energy-conserving BRDF + no image-based lighting -> PARTIAL
  - UV mapping           :: GAP: no surface->texture parameterization (unwrap) -> GAP
  - normal / bump map    :: PARTIAL: noise bump on the SDF surface (worldgen); no tangent-space normal maps on meshes -> PARTIAL
  - displacement map     :: PARTIAL: fuzz displacement on the SDF (anatstack); no image-driven mesh displacement -> PARTIAL
  - GI ref (Cornell box) :: PARTIAL (NEW 2026-07-11): the CORNELL BOX solved with patch RADIOSITY (Goral et al.'s own method: 650 patches, Q16 form factors, block occlusion) -- COLOUR BLEEDING measured + causally isolated (direct-only control r-g==0 EXACTLY; with bounce red-side +104 / green-side +61 / centre 12 milli) + occluder soft shadow (109 vs 1104 lum), classic image rendered (nx_cornell_gate); residual vs the full reference: measured SPECTRAL reflectances + rotated blocks + quantitative photograph comparison -> PARTIAL

shape kernel · peelable being · walking in-browser · full PBR being · the holistic being