u2ue experiment, in quarantine · 2026-10-27 to 10-28
Blueprint View
Game code drawn as Blueprint-style graphs to make it easier to understand, and Unreal Blueprints turned back into code, with requirements built from human friction first. It never writes the game, and it joins u2ue only if a measured report makes the case for it.
This review is the experiment as it stood early on 10-28. The online sample with its closed loop, the Pong hello world, the asteroid shooter (a whole game, playing on its converted Blueprint) and the city came after it, and are on the showcase and the city above.
Viability
Built and measured for right answers. Not yet measured with people.
Phases 1 to 7 and 9a are built, and a converter from Blueprint to code was added as a new requirement mid-run: read any method as a graph in five forms, find it, follow its calls, replay a battle and scrub it to the step a planted fault appears, set a value on a wire with no rebuild, change the sandbox through gates, and read real Unreal Blueprints as code. Every answer the experiment gives was held to a key computed another way. What it has not been measured for is friction: no person has used it, and that needs named testers and a baseline (IR-12).
Not real Blueprint assets
A Blueprint call node binds a UFunction (K2Node_CallFunction.h lines 77 and 158), and the model is plain C#. IR-3 asks for that to be confirmed.
Not live edits in a running editor
Hot reloading stays Off in the Unreal project in use, so a write never recompiles under an open editor. The same idea runs on a deterministic replay: a valve on a wire, a re-run in seconds, the new outcome beside the old.
Never a write to the game
Every change lands in a sandbox copy that records its game commit (cc93149), and every run that writes is wrapped by an audit hashing the game's folders: 22 of 22 audit records say 0 changes. The engine and the second game are only ever read, from copies.
The requirements, counted
The model is written as data (model/*.yaml), and the documents are generated from it. Generation refuses to run while the model has a hole. Every figure here comes from a gate run on 2026-10-27.
59
use cases: 6 epics, 34 user goals, 19 subfunctions
151
pathways, 59 main and 92 alternate, each with a stated outcome
228
requirements: 36 authored, 176 derived, 16 inferred and asked
431
cells in 7 closed spaces (the 7th: the engine's 113 Blueprint node classes), every one mapped or excluded with a reason
57
questions people would ask, each inverted into the use case that answers it
12 / 12
faults planted in the real model, each caught by its own rule
Built and measured, 2026-10-28
Every figure below was produced by a gate that has been shown to fail on a planted fault. The task rounds were run by Claude, so they say whether the answers are right, never how hard a person finds them.
4,201
methods of a game in production (its core and presentation assemblies) as graphs; every one prints back to its source as the same syntax tree
0 / 2,343
long wires drawn; the far reads are Get chips, and unchanged code moves 0 nodes between layouts
6 battles
fought headless, identical plain, with 22,569 probes and traced; a planted fault found by scrubbing in 4 of 6
0.84 s
the slowest whole battle with a valve doubling a damage wire, no rebuild (IR-6's interim bound: 2 s)
32 / 32
task-bank answers right in round 2, each against a key computed another way (round 1: 29 of 32, its 3 page failures fixed)
48 / 2 / 178
of 228 requirements measured / failed / not yet; nothing without evidence counts as met
1,270
graphs of a second game (Zombie Crossing, a MonoGame port) read with no path of the first game's, all round-tripping
68,882
nodes, each resolving to file, line and column in its source
Blueprint to code
Added mid-run as a new requirement: a converter from Blueprint to code. Requirements first (REQ-BPV-27, UC-BV34, BC-1 to BC-10 from the engine's 113 node classes), then the code, tested only on text the engine itself wrote: eleven Unreal 5.7.1 templates copied and exported by a headless commandlet with no window.
92
template Blueprints converted, 0 failed (one export was UTF-16, read by its byte-order mark)
275 / 275
methods printed as C#, C++ and pseudo-code; every one parses as C# (Roslyn)
6
nodes left as marked islands: 4 Timelines, an async action, a DMX plugin node; nothing reachable dropped
13
converter defects found by reading its own output, each fixed in the class (DEBUG.md D24-D36)
What the code means is read from the engine, not assumed: a function's outputs are out parameters and a pure node runs once per step (KismetCompiler.cpp); unset pins print what the compiler writes; ForEachLoop, ForLoop, WhileLoop, FlipFlop and DoOnce follow their own macro graphs, exported from the engine and read. The page has a From Blueprint tab: paste nodes, read them in every form. Not yet tried: a real clipboard copy, which only the editor makes.
Where the requirements come from
Writing more rows cannot prove a list complete. A closed space can: its cells come from somewhere other than the requirements, so a cell no requirement covers shows up as a hole. Each space has a different shape, because a space of one shape cannot see what another shape would catch.
Space
Shape
Cells
Accounted for
Source
S1
Every sentence of the design discussion
44
44 mapped
the discussion's text, copied byte for byte
S2
Cognitive Dimensions × 9 view surfaces
126
117 mapped, 9 excluded with a reason
Green and Petre 1996; the 14 dimensions read from Wikipedia
S3
Human-factors principles
30
30 mapped
from knowledge, not re-read this run
S4
Shneiderman's 7 tasks × 7 data types
49
47 mapped, 2 excluded with a reason
Shneiderman 1996, "The Eyes Have It"
S5
C# node families
59
59 mapped to a drawing requirement
extracted from NodeFamilies.cs by pattern
S6
Code evidence
10
10 mapped
the census and the gates
The use cases, as a hierarchy
Six epics at the top. Each user goal realises one step of its epic, and each subfunction realises a step or an alternate pathway of its user goal. The model checks every one of those links.
EPIC-1 · 7 steps · 2 alternate
Understand a piece of the game's logic without reading its code
UC-BV1Find where to look
UC-BV1.1List who calls, reads or implements this
UC-BV1.2Open a failing run's stack as a trail
UC-BV2Read a method as a graph
UC-BV2.1Read C# with its meaning
UC-BV2.2Draw each construct
UC-BV2.3Lay out a graph without long wires
UC-BV2.4Fold a long method into named groups
UC-BV7Read the logic in the form I prefer
UC-BV3See what a class inherits, overrides and implements
UC-BV3.1Find which implementation runs
UC-BV3.2Compare a base and an override
UC-BV4See the whole game's map
UC-BV5Watch a recorded run on the graph
UC-BV5.1Trace a run without changing it
UC-BV5.2Spot the slow nodes
UC-BV6Keep my place and notes
UC-BV33Share or keep a copy of what I see
EPIC-2 · 6 steps · 1 alternate
Find out why the game did something
UC-BV8Reproduce a recorded case
UC-BV9Find the step where a value went wrong
UC-BV9.1See where an error was raised
UC-BV9.2Scrub a run to a step
UC-BV10Compare two runs
UC-BV11See why a branch went the way it did
UC-BV12Try a what-if on a replay
UC-BV12.1Drop a valve on a wire
EPIC-3 · 6 steps · 1 alternate
Change or write logic in the sandbox by showing or saying
UC-BV13Change code on the graph
UC-BV13.1Write an edit into the sandbox's C#
UC-BV14Change code by saying it
UC-BV14.1Resolve what the person means
UC-BV15Write new logic by describing it
UC-BV16Review and keep a change
UC-BV16.1Run the gates on a proposed change
UC-BV16.2See a change's reach
EPIC-4 · 5 steps · 2 alternate
Learn an unfamiliar codebase
UC-BV17Find the entry points
UC-BV18Follow a guided tour of a recorded battle
UC-BV19Map a game word to code
UC-BV20Learn the view's notation
EPIC-5 · 6 steps · 2 alternate
Use the view with any body and any eyes
UC-BV21Operate the view by keyboard
UC-BV22Read the view without relying on colour
UC-BV23Enlarge everything
UC-BV24Use the view without motion
UC-BV25Read a graph with a screen reader
EPIC-6 · 7 steps · 3 alternate
Run the quarantined experiment and judge it
UC-BV26Take a sandbox snapshot
UC-BV26.1Refresh the sandbox from a newer game snapshot
UC-BV27Prove the quarantine holds
UC-BV28Measure the view's ergonomics
UC-BV29Gap-check the requirements
UC-BV29.1Mutation-test the gap checker on the real model
UC-BV30Keep the view honest
UC-BV31Report the experiment
UC-BV32Decide whether the view goes into u2ue
What the old gap checker missed
The model written earlier the same day passed every gate: 25 questions, 20 of 20 mapped, 0 source holes. Measured on those same files, this is what the gates never looked at. Re-running the fixed gates on the new model then found more misses inside the checker itself.
176 / 194
applicable ergonomics cells that the old requirements did not reach
14 / 14
alternate pathways that named no requirement (10 never said where they end)
22 / 44
sentences of the discussion never checked against a requirement
4 / 20
requirements mapped to a use case whose steps never carry them
5 / 16
inferred requirements the fixed checker still never asked, because they were cited only on pathways
14 / 19
defects fixed in the gap-check tools, each re-run on real documents; the other 5 were shell traps avoided, or reported to their owners (DEBUG.md)
Every one of those misses was found by holding a gate's count against an independent count, never by the gate itself. The interrogation tool now prints that comparison on every run: INFERRED 35 cite(s) in the text, 35 asked.
The knowledge graph
The same model is also built into a SQLite graph. The store declares its own completeness rules and checks what rules over YAML cannot: how many independent kinds of evidence back each requirement, and which requirements are written twice. SQLite was chosen by running four systems on the real store of another project, Anchor (10,711 entities, 20,196 edges). Node's built-in node:sqlite reads the same file.
System
Load
Find a hole
Reach
Anchor count
Reopen
File
SQLite (chosen)
110 ms
0.6 ms
1.4 ms
21 ms
5 ms
2 MB
NetworkX
90 ms
15.4 ms
24.2 ms
17.8 ms
851 ms
2.4 MB
igraph
37 ms
22.5 ms
6.9 ms
63.9 ms
152 ms
2.7 MB
DuckDB
66,635 ms
25.8 ms
33.2 ms
34.6 ms
36 ms
3.6 MB
201 sourced requirements by independent evidence families
172 on one family26
one familytwo familiesthree families
This is the model's weak spot. Most of the 172 are a published framework applied to this view, which is a sourced method but still a reading. Their second kind of evidence is meant to be people: plan phase 4 measures real tasks against them, and that has not run yet.
One graph, many forms
The design rule: the graph is stored in the node graph's own pseudo-language, and every view is generated from it. A reader picks Blueprint style, another visual style or C# text, and other code languages can follow. The stored form is trusted only while every graph prints back to its method's text.
flowchart LR
G["Game code, read only"] --> R["Reader: census vocabulary, 59 node families"]
R --> P[("Stored graph in its own pseudo-language")]
P --> B["Blueprint style"]
P --> V["Another visual style"]
P --> T["C# text"]
P -.-> L["Other code languages, IR-14"]
P --> RT{"Prints back to the method's text?"}
RT -->|no| X["Refused, never shown"]
Plan
Each phase is done when its observable holds, and each ends with the quarantine audit. Sizes are estimates: S about one session, M two to four, L five or more. Rows marked * are the smallest prototype that answers the discussion.
Phase
Builds
Done when
Writes
Size
0
Census, node vocabulary, the requirements model and its gates
Done 10-27: census exit 0 on both projects; model passes 17 rules; 12 of 12 mutations caught
this folder
done
1
Sandbox and quarantine audit
Done 10-28: 303 files from game commit cc93149; a planted outside write and a .. escape refused; every audit record 0 changes
Done 10-28: 4,201 graphs printing back; 0 long wires drawn against the 2,343 counted; unchanged code moves 0 nodes
graphs/
done
3
Browser view: forms, search, click-through, map, class view
Done 10-28: three named graphs looked at in each form; every name found; callers by method, a ranked class list, its source shown. No inheritance view yet
view/
done
4
Ergonomics measurement: task bank, baseline, results
Done for right answers 10-28: 57 questions, 32 tasks with keys, 25 absent with why; rounds 1 and 2 recorded, NOT HUMAN. Friction waits on IR-12
results/
half
5
Replay: record, watch, scrub, compare
Done 10-28 headless: digests identical three ways on 6 battles; a planted constant found by scrubbing. Not yet shown on the graph
runs/
done
6
Changes in the sandbox: graph edits, spoken or typed commands, review
Typed commands done 10-28: gates pass, a failure put back byte for byte, the game unchanged. Graph edits and spoken commands not built
sandbox/
half
7
Valves on a replay
Done 10-28: a damage wire doubled with no rebuild, slowest 0.84 s; the kept valve as an edit replays identically
runs/ sandbox/
done
8
Unreal editor view, only if IR-2 chooses it
Blocked on IR-2: the browser comes first unless that decision says otherwise
its own project
L
9
The verdict
Second game done 10-28 (Zombie Crossing, 1,270 graphs); this report written; whether the view joins u2ue is decided from it
this folder
decision
BC
Blueprint to code (added 10-28)
Done 10-28: 92 engine Blueprints, 275 methods, all parsing as C#; a paste box in the page. A real clipboard copy not yet tried
view/ runs/
done
Open product decisions
Sixteen requirements the chain needs and nobody has stated, asked at the 35 places they are cited. Each pathway that rests on one says what the view does until it is decided. These eleven are product calls.
IR-1
Which code is drawn first: the engine-free model and presentation, the Unreal host classes, or the Unity scripts? Until then, engine-bound code is drawn without live data and marked.
IR-2
Where does the view live first: a browser page or the Unreal editor?
IR-3
Confirm a Blueprint-styled view the toolkit owns rather than real Blueprint assets. Until then, a request for a real asset is explained and offered the styled view.
IR-4
Which way does execution flow: down the page like text, or left to right like Blueprint?
IR-5
What does the overview map show: modules and classes with calls, the battle flow, or both? Until then, modules and classes with calls.
IR-6
How fast must "instantly" be for a value change on a replay?
IR-7
Which edits does the graph itself support, and which go to a spoken or typed command instead?
IR-8
Which AI writes code from a command, where does it run, and who pays for it in the product?
IR-9
What counts as a bottleneck: time per node against which budget?
IR-14
Which second visual system, and which code languages beyond C#?
IR-15
Does the preview of a valve's effect need the game's own picture? That needs the Unreal port playing the replay in an instance of its own.
The other five hold a stated default until decided otherwise. IR-10: every change acts on the sandbox. IR-11: the sandbox records its game commit and lists kept changes before a refresh. IR-12: rounds without named testers are run by Claude and marked not human. IR-13: notes are kept per person. IR-16: results are kept in the experiment folder with their date, snapshot and tool version.
Three more from the build, each measured:
DR-1
The graphs draw 2.5 nodes per statement where the requirement aimed at 1.5. Fold more into a node (a condition as one box), or accept 2.5? Failed, left as it is.
LY-6
A big graph opens with every node shown; the requirement asked for at most 30 visible. Build fold and focus? Failed, not built.
BC5
One Ctrl+C in an Unreal editor: any Blueprint nodes copied and pasted into the page's From Blueprint tab, so the converter meets a real clipboard copy. Only the editor writes one.
Gates, 2026-10-27 and 10-28
PASSRound trip: 4,201 of 4,201 graphs of a game in production and 1,270 of 1,270 Zombie Crossing graphs print back to their source (planted deletion, swap and dropped argument each fail)
PASSCensus, keyword by keyword, and long wires: 0 differ; layout: 0 long wires drawn, 0 nodes moved, 0 undrawn
PASSConverter: 275 of 275 methods parse as C#; every value under the statement that reads it; 3 broken texts refused naming the line
PASSRound 2 of the task bank (NOT HUMAN): 32 of 32 answers right
PASSQuarantine audit: every record 0 changes to the game's folders and the game repo's model caches; hot reloading Off
PASSStructured checker: every use case, pathway, requirement, cell and question accounted for, by 17 rules