Nishi Family › World › Graphics Evidence

Sovereign Graphics — Evidence Chain

→ BEYOND-METAHUMAN PROGRAM (live): /world/metahuman — procedural humans past MetaHuman: the capability ruler, the honest distance, and the face built inside-out one measured unit at a time.

OUR OWN stack — language → compiler → IR → rasterizer → shader-VM → OS → browser → driver, zero third-party (no WebGPU, no WebGL, no three.js, no canvas) — to state of the art on Windows and Linux. Every claim below is backed by a rendered artifact and a gate; nothing is asserted. Measured 2026-07-18/19/20, never claimed.

804primitive breadth /1000 (presence, NOT fidelity)

~200photoreal-human fidelity /1000 (HONEST)

CLAYhuman render ~406 vs photo 776 — gap ~370

13 gatesfirst-byte · Gx-1 · Gx-1b · Gx-1c · Gx-4 · Gx-5 · Gx-6 · Gx-7 · Gx-8 · Gx-9 · Gx-PBR · SSS · eye GREEN + eyeballed

⚠ Honest distance to SOTA — we are clay, not MetaHuman

The 804 above measures breadth of graphics primitives present (a BRDF exists, a rasterizer exists, a z-buffer exists). It is not photoreal-human parity, and reading it as SOTA would be self-flattery. On output reality, our best human render is CLAY (~406–421/1000) against a real-photo corpus mean of 776 — an organ-measured gap of ~370, tracked by the realism loop. Photoreal-human fidelity therefore sits near 200/1000, not 804 — rungs 1–2 of the climb (SSS skin, eye shader) are shipped, each gate-proven and eyeballed.

North star, stated plainly: MetaHumans (Epic’s photoreal external digital humans) set the external bar — and our own benchmark is higher still: an IRL anatomically-correct being, inside and out (MetaHumans don’t render internals). We are far below both today. The gold GGX sphere further down is a necessary primitive, nowhere near sufficient: a MetaHuman needs subsurface-scattering skin, strand-based hair, cornea/iris eye shaders, scanned material maps, and facial micro-geometry layered on top.

photoreal-human axis (MetaHuman / inside-and-out being parity)	verdict
skin subsurface scattering (BSSRDF)	PARTIAL — SSS shading proven (wrap+reddening); scan-accurate profile + texture remain
strand-based hair + groom	GAP
eye shader (cornea refraction, iris, sclera)	PARTIAL — cornea/iris/sclera shader proven vs doll-eye on 5 measured cues; lids/lashes/tear-film/vessels remain
teeth + gums	GAP
facial micro-geometry (pores, wrinkle maps)	GAP
scanned material maps (photogrammetry)	GAP
internal anatomy render (bones, organs, muscle)	PARTIAL — mesh exists, clay render
muscle / tendon deformation	PARTIAL — skinning, no muscle sim

Scores DROP when audited — that is the system working (the clay-audit standing rule: output reality ≥ capability presence). The realism loop and nx_photoreal_critic are the hard judges; we climb against their score, not the eyeball. The benchmark subject itself: the anatomically-correct being.

First rung of the climb — subsurface-scattering skin

Two spheres, same skin tone and light: left is hard Lambert clay with a grey terminator, right is subsurface-scattering skin with a soft reddish terminator where light wraps and scatters — Same albedo, same light, by `nx_gx_sss_skin_gate` (GREEN 4/4 + eyeballed). **Left = clay** (hard Lambert — the terminator snaps to grey, plastic). **Right = subsurface scattering**: light **wraps** past the terminator and **reddens** there, because red penetrates skin deepest and scatters back out. Measured: the SSS sphere lights **26,244 px vs 23,021** (wrap) and carries **55% more warmth** (ΣR−B 2,004,452 vs 1,297,533). This is the #1 clay→flesh lever. Honest: it is the SSS *shading model*, not photoreal — a single untextured sphere still has no pores, texture, or hair, so a detail-scoring critic rightly ranks it below a real photo. Shading rung done; texture + pores + hair remain.

Second rung of the climb — the eye (cornea · iris · sclera)

Two rendered eyeballs: left a doll eye with a broad soft highlight and flat pale iris; right the sovereign eye shader with a sharp catchlight, dark limbal ring, radial iris fibers, corneal magnification and warm sclera — By `nx_gx_eye_gate` (GREEN 7/7 + eyeballed, 2026-07-20). **Left = doll eye** (broad bloom, flat pale iris, no limbal ring). **Right = the eye shader**, measurably better on **5 cues**: sharp specular catchlight (111 px top-band vs 10,368 broad), dark **limbal ring** (boundary luminance 40 vs iris 149 / sclera 175), **radial iris fibers** (angular delta 23 vs 0), **corneal refraction magnifying the iris** (4,984 px vs 2,417 at the same geometric radius), and **warm sclera** (ΣR−B 3,209 vs 0). Honest residual: lids, lashes, tear-film meniscus, scleral vessels — in isolation the eye still reads CG; this is the *shader* rung, proven.

The trunk, re-proven — from the first byte up

Seven-panel strip proving the graphics stack bottom-up: magnified first pixel, scanline gradient, checksum checker field, rasterized triangle, z-buffer overlap where near cyan wins over far red, specular lit sphere with dark terminator, and SSS versus clay spheres — `nx_gx_firstbyte_gate` (GREEN 9/9, 2026-07-20): the whole sovereign chain proven bottom-up in ONE artifact — T1 byte 0 written and held → T2 per-byte RGB addressing → T3 linear scanline gradient (mid=128) → T4 framebuffer checksum exact (8,172,450) → T5 triangle raster within 0.3% of analytic area (6,866 px vs 6,850) → T6 z-buffer rejects 3,001 far fragments (near cyan wins though far drawn last) → T7 lit-sphere hotspot 255 / terminator 12 → T8 SSS wraps past clay (+680 lit px) → T9 the shipped PNG’s own first byte = 137 (PNG magic), read back from disk. Every deeper gate (GGX, browser compositing, the eye) stands on this trunk.

The game substrate — Gx-1c: <canvas> + the per-frame loop

The Nishi-Browser now has a first-class <canvas> element — a sourceless render surface a fetched page simply declares. The layout engine gives it a real CSS-sized box in flow; each frame the game loop updates world state, renders it through the real nx_swgpu mesh pipeline (no inline rasterizer — the DRY fold), and the browser repaints the whole page. Gate nx_gx1c_canvas_gate GREEN 7/7 + eyeballed, with a neg-control (a canvas-less page finds no surface) and the engine regression suite (Gx-1b) re-run GREEN on the edited engine. Measured: 143 ms/frame — envelope: 512×384 swgpu mesh render + full 1000×1000 browser repaint + PNG encode per frame (interactive play would skip the PNG encode; this is the substrate proof, not a real-time claim). Below: frame 0 and frame 3 of the same page — the world state (yaw) advanced and the surface repainted in place.

The Nishi Browser rendering a page whose canvas element shows the sovereign software GPU's humanoid facing the camera, frame 0 — **Frame 0** — the fetched page declares `<canvas>`; the browser lays it out in flow (box idx 9 at 44,216, paragraph correctly below) and blits the swgpu render (humanoid facing camera, per-pixel lit) through its own image pass.

Frame 3 — same page, three ticks later: yaw advanced, the figure turned to profile, the browser repainted. 2,177 sampled pixels changed frame-0→3 (measured in-gate). This is the sovereign game loop: state → render → present, ours from the first byte.

The first playable — Gx-4: walking through a sovereign world

The substrate now carries a game. An input script — forward, forward, turn left, forward, turn right, forward — drives a player across a generated heightfield world; every tick reads input → advances player state (position, heading, eye riding the ground) → builds the player-relative mesh → renders it through the real nx_swgpu pipeline in three altitude-band material passes (grass, rock, snow) sharing one z-buffer → blits into the page's canvas → the browser repaints. Gate nx_gx4_walk_gate GREEN 6/6 + eyeballed; both upstream gates (nx_swgpu_gate 5/5, nx_gx1c_canvas_gate 7/7) re-run GREEN, so the new multi-pass renderer is proven additive.

The sovereign exceed, demonstrated: the gate replays the identical input script twice and gets a byte-identical frame checksum (19,387,962 both runs). All-integer, no float, no GPU driver non-determinism — deterministic replay by construction, which is what makes lockstep multiplayer, replay files, and reproducible testing free rather than hard. Measured: 20 ms per world tick (841-vert, 3-pass banded terrain at 512×384), with the full 1000×1000 browser repaint + PNG encode adding 187 ms on top — the PNG encode is the gate's evidence step, not something interactive play would pay.

The Nishi Browser showing a page whose canvas holds a 3D world: a snow-capped mountain with a rocky midsection rising from a green grass plain under a dark sky — **Tick 0** — the player spawns on the grass plain facing the mountain. Three material bands by altitude (grass → rock → snow cap), per-pixel lit off real height-gradient normals, z-buffered across all three passes, under sky. This is the floor law satisfied: a lit 3D world, not terminal rectangles.

The same world after the walk script has run: the camera has advanced and turned, showing the mountain slope from a new vantage — **Tick 5** — after walking forward four times and turning both ways, the camera stands somewhere new and the world has re-composed around it (6,382 pixels changed on the first forward step alone). The snow slope carries visible shading gradation. **It did not, until today:** this frame previously had **50.4% of its pixels (99,090 of 196,608) clamped to flat white** by unbounded highlights — the snow was a featureless void. The tonemap below fixed it; the count is now **zero**. Still honest: input is a *scripted* event sequence (a gate has no interactive event loop), and the world has no entities, collision, or win state yet — this is a first playable, not a finished game.

Gx-9 — save/load, and a test only determinism makes possible

This one was chosen by measurement, not taste: our own gamebench ruler scores 26 capabilities against 12 real ingested game titles and ranks save/load persistence as the #1 blocker — it gates 11 of the 12. So it was next.

The test most engines cannot run. A normal save test checks that fields round-trip. Because our pipeline is bit-deterministic, we can assert something far stronger: saving and reloading must be indistinguishable from never having saved. Play seven ticks and keep playing to fourteen, checksumming every frame. Then play the same seven, save, load into a zeroed state, and resume — and require every frame of the resumed span to match. Result: identical checksums (10822020 both), 0 differing bytes, 0 differing state fields. That catches the whole class of "the save forgot a field" bugs, which round-trip tests structurally cannot see.

The other half is refusal. A damaged save must fail with a reason, never half-apply — a partially-loaded save strands the player in an impossible world and reads as a game bug forever. Corrupt a payload byte → refused with a checksum error and the caller's state left untouched. Claim a future format version → refused rather than misparsed. Missing file, undersized buffer → each its own code. The whole game state is 120 bytes.

A game view after loading a save: a gold beacon still to be collected hangs against the sky above a snow slope — A session resumed from disk — the next beacon still uncollected, exactly as it was. Gate `nx_gx9_saveload_gate` GREEN 6/6.

A test that first passed for the wrong reason. The initial version compared only the final frame of each run, got "0 differing bytes", and passed. It was hollow: at the last tick the player stands on the peak with the remaining terrain below the viewport, so it was comparing two identical empty skies. Adding a non-vacuity guard — the reference frame must contain real world, now 36,153 pixels of it — turned the pass RED and forced the honest fix: checksum every tick of the resumed span. A green gate that cannot fail is not evidence, and this one proved it on itself.

Gx-8 — ambient occlusion, and the trap it had to avoid

Direct light carries no proximity information, so a shape resting on a surface and one hovering above it shade identically — which is why our beacons and figures read as pasted onto the scene rather than sitting in it. sg_ssao adds cavity darkening from the finished depth buffer, so it costs nothing in the rasterizer's inner loop and cannot regress it.

The trap: the obvious implementation asks "is my neighbour nearer than me?", and that greys out every floor — on any receding surface the downhill neighbour is always nearer. Real engines dodge it with per-pixel normals, which we would have to write from the inner loop. Instead this samples opposite pairs: in a genuine cavity both sides are nearer; on a plane or slope one is nearer and the other is farther, scoring zero. Same effect, no normal buffer, no inner-loop cost. The gate proves both halves — the crevice-rich figure darkens, and a large receding plane comes back 0 darkened pixels out of 86,978. Passing either alone is easy; passing both is the point.

Two identical rendered figures side by side; the right one has darker shading in the seams where limbs meet the torso and between the legs, while open surfaces look the same — Same figure, without occlusion (left) and with (right). The seams where limbs meet the torso, the neck junction and the gap between the legs darken; open surfaces are untouched. Only **6% of body pixels** change and **zero pixels brighten** — occlusion is subtractive by construction, and selective rather than a global dimmer. Gate `nx_gx8_ssao_gate` GREEN 5/5. It costs **~4 ms/frame**, which the game now pays.

Landing this also let us pay down our own debt: the rasterizer body had been duplicated into the multi-pass variant (~100 lines, two places to fix any shading bug). It is now one function with a clear flag — and the refactor was proven rather than assumed, because the walk and game gates' determinism checksums held bit-exact across it.

Gx-7 — it becomes a game: entities, collision, a win condition

Walking around is not a game. Three things make it one, and all three are now live: entities that exist in world state, collision that changes that state, and a win condition the player can actually reach. Five beacons stand on the approach to the mountain; the loop each tick is input → player state → collision resolve → build the mesh from whatever is still alive → render → HUD → browser repaint. The render is a pure function of game state, so a beacon vanishing when you collect it is a rendering fact rather than a separate animation someone has to keep in sync. Gate nx_gx7_game_gate GREEN 7/7 at 17 ms/tick.

Determinism survives gameplay — the part that matters. Replaying the same input script reproduces byte-identical frames and identical collision outcomes (beacons collected on exactly the schedule 0→1→2→3→4→5). That is what makes lockstep multiplayer, replay files and reproducible bug reports free rather than hard, and it is not something a floating-point GPU pipeline gives you.

A game view in the browser: a green plain leading to a snow-capped mountain, with five gold diamond beacons receding into the distance in correct perspective, and five empty slots in a heads-up display at the top — **Start.** Five beacons recede in correct perspective toward the mountain, z-buffered against the terrain, with five empty HUD slots. Nothing collected yet.

The same game mid-session: three heads-up display slots now lit, two gold beacons remaining ahead, the camera looking up a snow slope — **Mid-session.** Three slots lit, two beacons left. The camera is looking up the rising slope — the pitch is aimed at the terrain ahead of the player, not at their own elevation. The first version keyed off the player's height and buried the camera in the hillside; the eyeball caught it, the measurements did not.

The won game: all five heads-up slots lit, a green banner across the top, the player standing on the snow cap of the mountain — **Won.** All five collected, banner up, standing on the snow cap you climbed to reach the last one. Reaching this required **camera pitch**, added this round: without it a raised camera stares flat out over falling ground and frames nothing but sky — which is exactly what the first win frame showed, and how the gap was found.

Gx-5 — real near-plane clipping, and a claim we had to retract

The pipeline used to cull triangles that crossed the camera plane: sg_project marks a vertex invisible once its view depth goes negative, and the rasterizer then dropped the whole triangle. sg_project_clip replaces that with real Sutherland–Hodgman clipping at the near plane, interpolating position and normal at the crossing (position-only would band the lighting along the cut) and emitting one or two replacement triangles. Gate nx_gx5_nearclip_gate GREEN 6/6; nx_swgpu_gate 5/5, nx_gx1b 4/4 and nx_gx1c 7/7 all re-run GREEN.

Side by side comparison: on the left the old culling path renders an empty background with no floor at all; on the right the new clipping path renders the green floor filling the lower half of the frame — **Left = the old cull. Right = clipping.** Identical scene: one floor built from two big triangles spanning from behind the eye to far ahead. Because each triangle has a vertex behind the camera, the old path discarded **the entire floor** — it renders **0% of the frame**. Clipping restores it at **43%**. This is the case that actually bites: level floors, walls and skybox faces are routinely two triangles apiece.

⚠ A claim we retracted, and how. This page previously stated that the white region in the Gx-4 tick-5 frame was near-plane culling. That was wrong, and our own gate refuted it. On a fine mesh the clipper still runs — it interpolated 112 new vertices on the walk terrain — yet moved zero pixels, because straddling triangles on a dense mesh project entirely off-screen. We proved it by switching the first playable to the clipper and checking its determinism checksum: it stayed bit-identical at 19387962. So near-plane culling could not have caused anything visible there. Measuring the frame instead found the true cause: half of it is clamped to pure white by unbounded highlights. The clipping fix is real and load-bearing for coarse geometry; the diagnosis attached to it was not. Both the fix and the correction are recorded, because a benchmark that quietly edits its own history is worth nothing.

Gx-6 — a tonemap, because half of every bright frame was being thrown away

The renderer used to end with a hard clamp: anything brighter than 255 simply became 255. On a real game frame that destroyed 50.4% of the image — every snow pixel collapsed onto one value, so a sunlit slope rendered as a flat white void. A blown-out surface scores worse than a dim one with any detail-scoring critic, so this was capping fidelity directly. sg_tonemap replaces the clamp with an extended Reinhard curve in fixed-point integer math, exposure-compensated so midtones keep their level, with the white point derived from the pipeline's own peak radiance so the brightest material lands just under 255 and cannot clip by construction.

measurement	before (hard clamp)	after (tonemap)
distinct output levels across the radiance range that used to clip	1	60
pixels clamped to pure white, real game frame (Gx-4 tick 5)	99,090 of 196,608 (50.4%)	0
distinct shading levels on the brightest material	flat	160
transfer curve (in→out)	64→64, 255→255, 360→255	64→64, 128→115, 192→158, 255→196, 360→254

Two rendered figures side by side, a near-white snow-albedo figure and a warm skin-albedo figure, both showing smooth shading gradation across their curved surfaces rather than flat blown-out areas — The worst case (left, snow albedo — the material that used to flood) and an ordinary material (right, skin). Both hold **160 distinct shading levels** with **zero blown pixels**. Gate `nx_gx6_tonemap_gate` GREEN 7/7, including a **monotonicity proof** across the whole range — brighter in is never darker out, so no detail can invert — and a check that the curve does not crush ordinary materials while rescuing bright ones.

What we did not do: we did not raise the fidelity number for this. Removing a defect that was destroying detail is not the same as proving new photoreal capability, and the honest judge of output reality is the independent realism loop, not us. Fidelity stays at 200 until that critic re-scores it. The transfer curve above is published in full precisely because tonemapping trades midtone brightness for highlight detail, and that trade should be visible rather than asserted.

Hard evidence — Gx-1: our 3D, in our browser

A z-buffered 3D cube rendered by the sovereign software GPU, composited into the Nishi-Browser's own chrome and content framebuffer — Rendered by `nx_gx1_browser3d_gate` (GREEN 4/4, independently eyeballed): a z-buffered, hidden-surface 3D cube — 3 depth-sorted faces — composited into OUR browser chrome + content viewport framebuffer, written by our canonical PNG encoder. No WebGPU, no WebGL, no canvas, no third-party: every pixel is ours. This is the sovereign answer to “state of the art in the browser.”

Hard evidence — Gx-1b: the LIVE browser renders a page with 3D

The Nishi Browser rendering a fetched HTML page whose image element is filled by the sovereign software GPU's 3D render — The **live Nishi-Browser engine** (br_layout → br_shot_png) fetched, parsed, and laid out a real HTML page — heading, paragraphs, and an image element — and painted the sovereign SW-GPU 3D cube into that element through the browser's OWN image paint path (page.bimg). Gate `nx_gx1b_page3d_gate` GREEN 4/4 + eyeballed. This is `nishi-browser-3d-surface` = **HAVE**: a fetched page drives the 3D, in our browser, zero third-party.

Hard evidence — Gx-PBR: energy-conserving GGX materials

Five gold metallic spheres rendered with the Cook-Torrance GGX microfacet BRDF, roughness sweeping 0.30 to 0.90 left to right; the specular highlight broadens and softens as roughness increases while total energy is conserved — Five metallic gold spheres, roughness **0.30 → 0.90** (left → right), rendered by `nx_gx_pbr_ggx_gate` (GREEN 4/4 + eyeballed) with the full **Cook-Torrance GGX microfacet BRDF** — GGX/Trowbridge-Reitz normal distribution D, Schlick Fresnel F, Smith geometry G, spec = D·F·G / (4·N·V·N·L) — entirely in **all-integer Q20 fixed-point** (no float, deterministic), 2×2 supersampled. As roughness rises the highlight broadens and dims: **energy is conserved** — the microfacet-model hallmark. This is `pbr-material` = **HAVE**: the same energy-conserving BRDF UE5 / Unity / Filament use, rebuilt as ours, zero third-party. Residual: image-based lighting + scanned material maps.

Evidence built on evidence — the chain

Gx-1 render (this page — gate 4/4 + eyeballed) → rests on graphics foundation 688/1000 (nx_graphics_census_gate: mesh · shading · skinning · glTF · GI · textures — each a rendered artifact) → rests on sovereign SW-GPU 583 (nx_swgpu_sota_census) + sovereign GPU stack 343 (nx_sovgpu_census) → rests on the Nishi Atlas lineage (nx_eco_graph: 16,577 organs, roots-to-god) each link is an artifact + a gate, not a claim — remove any artifact and its axis liar-kills to GAP.

Atlas node: organ card for nx_graphics_board (parents · children · lineage) · recombination: nx_atlas_discover proposed 12 novel unproven pairs from this graph — discovery of new opportunities, built on the same evidence graph.

The 23 axes — each verdict is a rendered artifact

axis	verdict	evidence artifact
software-raster-core	HAVE	nx_swgpu.png — tiled 512x384 per-pixel-lit SW GPU
sdf-raymarch	HAVE	nx_sdfbody.png — threaded raymarcher x13.15
trimesh-zbuffer	HAVE	nx_trimesh.png — barycentric raster + exact z-buffer
smooth-shading	HAVE	nx_phong.png — Gouraud + Blinn-Phong
pbr-material	HAVE	nx_gx_pbr_ggx.png — Gx-PBR PROVEN: energy-conserving Cook-Torrance GGX BRDF (D·F·G), integer/deterministic
texture-mapping	HAVE	nx_boxtex.png — per-fragment UV on Khronos BoxTextured
anti-aliasing	HAVE	nx_aa.png — SSAA 2x
global-illumination	PARTIAL	nx_cornell.png — Cornell radiosity colour-bleed
skinning-animation	HAVE	nishi_being_walk.glb — 9-joint FK walk
asset-io	HAVE	nx_bunny.png — glTF/OBJ, Stanford bunny 35947v
scene-graph	HAVE	nx_scene_graph.txt — transform hierarchy
parametric-subdiv	PARTIAL	nx_bezier_patch.stl — Bezier + Loop subdivision
nishios-native-surface	HAVE	nx_swgpu.png — renders on our CPU/NishiOS, integer/deterministic
nishi-browser-3d-surface	HAVE	nx_gx1b_page3d.png — Gx-1b PROVEN: the LIVE browser laid out a fetched page + painted the 3D into its image element
game-loop-canvas-surface	HAVE	nx_gx1c_f0.png — Gx-1c PROVEN: first-class <canvas> + per-frame swgpu loop in the live browser (143 ms/frame measured)
first-playable-game	HAVE	nx_gx4_walk_t0.png — Gx-4 PROVEN: input-driven deterministic walk through a lit banded 3D world (20 ms/tick, byte-identical replay)
game-entities-collision-winstate	HAVE	nx_gx7_game_t0.png — Gx-7 PROVEN: entities in world state, collision that mutates it, a reachable win condition, deterministic
ambient-occlusion	HAVE	nx_gx8_ssao.png — Gx-8 PROVEN: cavity darkening that leaves receding planes untouched (0 of 86,978 neg-control px)
save-load-persistence	HAVE	nx_gx9_resumed.png — Gx-9 PROVEN: reload is byte-identical to never having saved; damaged saves refused with a reason
mobile-portability	GAP	Gx-2: hardware-agnostic ~25-op IR + aarch64
windows-linux-gpu-accel	GAP	Gx-3: sovereign submit on the RTX 5080 native (Windows/Linux) — built vs spec models; no FPGA required
directx-compat-d3d11	PARTIAL	warp_shaded.ppm — pixel-exact vs Microsoft WARP through the real D3D11 API (runs on Windows)
tensor-core-neural-render	GAP	HMMA/IMMA/QMMA ISA bit-exact vs NVIDIA (compute-proven); render-on-silicon pending

Windows + Linux — no FPGA required

Windows: our sovereign d3d11.dll is loaded and called by a foreign Windows process through the real Direct3D 11 COM API — device, context, buffers, programmable shaders (executing real fxc-compiled DXBC), and textures all render pixel-exact versus Microsoft’s WARP reference (evidence: warp_shaded.ppm, warp_textured.ppm). It runs on Windows today.
Linux & NishiOS: the same all-integer, deterministic software GPU (nx_swgpu / nx_sdfrender) runs on any CPU — no discrete GPU, no vendor driver, no FPGA. Bit-exact reproducible by construction.
Acceleration: real-silicon GPU exec targets the RTX 5080 natively on Windows/Linux (sovereign submit; the cross-vendor NVIDIA/AMD/Intel command stack is built + gated vs spec models). Not FPGA — your machines.

Beyond state of the art — research opportunities + what to fetch

VM-executed programmable shaders (our VM is the shader core — the unique sovereign move) · neural rendering via cooperative-vectors on our bit-exact tensor-core encoder · 3D Gaussian Splatting at SOTA · Nanite-class virtualized micropolygon geometry · Lumen-class real-time GI · PBR image-based lighting + scanned material maps (the energy-conserving GGX BRDF itself now shipped — Gx-PBR).

Fetch targets for the researcher: 3DGS real-time radiance fields · Nanite cluster-LOD / micropolygon software raster · Lumen GI (software + hardware RT) · cooperative vectors / neural shaders (DirectX SM6.9) · mesh shaders + GPU work graphs · ReSTIR · DirectSR / DLSS / FSR · OpenPBR / GGX reference.

Live instruments — verify it yourself

MCP tool nx_graphics_board → this benchmark as JSON /compare/graphics/board the QA-loop realism comp /world/foundation /swgpu atlas card procedural generation — the Infinigen direction

Honest ROI — non-fake

Realized today = $0 (graphics is FUNCTIONAL / pre-product, no revenue — the truth, not a gap). Projected savings, contingent on shipping a product (source-noted estimates, never measurements): avoids Unity Pro ~$2,200/yr/seat + runtime fee, Unreal 5% royalty above $1M revenue, cloud-GPU render ~$1-3/GPU-hr, and vendor lock-in. The measurable exceed today is strategic — bit-exact deterministic render (pixel-exact vs WARP), one-owner stack, never-brick — not yet monetized. The full basis is filed for the PM cockpit to price.

Measured, never asserted · every credited axis cites a real artifact · no-wave guard armed (all-HAVE = RED) · zero-JS, renders in Waterfox and any standards browser. Generated from gate-proven censuses, 2026-07-18/19/20.