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.

SpaceShapeCellsAccounted forSource
S1Every sentence of the design discussion4444 mappedthe discussion's text, copied byte for byte
S2Cognitive Dimensions × 9 view surfaces126117 mapped, 9 excluded with a reasonGreen and Petre 1996; the 14 dimensions read from Wikipedia
S3Human-factors principles3030 mappedfrom knowledge, not re-read this run
S4Shneiderman's 7 tasks × 7 data types4947 mapped, 2 excluded with a reasonShneiderman 1996, "The Eyes Have It"
S5C# node families5959 mapped to a drawing requirementextracted from NodeFamilies.cs by pattern
S6Code evidence1010 mappedthe 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.

SystemLoadFind a holeReachAnchor countReopenFile
SQLite (chosen)110 ms0.6 ms1.4 ms21 ms5 ms2 MB
NetworkX90 ms15.4 ms24.2 ms17.8 ms851 ms2.4 MB
igraph37 ms22.5 ms6.9 ms63.9 ms152 ms2.7 MB
DuckDB66,635 ms25.8 ms33.2 ms34.6 ms36 ms3.6 MB

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.

PhaseBuildsDone whenWritesSize
0Census, node vocabulary, the requirements model and its gatesDone 10-27: census exit 0 on both projects; model passes 17 rules; 12 of 12 mutations caughtthis folderdone
1Sandbox and quarantine auditDone 10-28: 303 files from game commit cc93149; a planted outside write and a .. escape refused; every audit record 0 changessandbox/ audit/done
2Graph reader, pseudo-language store, stable layout, round-trip gateDone 10-28: 4,201 graphs printing back; 0 long wires drawn against the 2,343 counted; unchanged code moves 0 nodesgraphs/done
3Browser view: forms, search, click-through, map, class viewDone 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 yetview/done
4Ergonomics measurement: task bank, baseline, resultsDone 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-12results/half
5Replay: record, watch, scrub, compareDone 10-28 headless: digests identical three ways on 6 battles; a planted constant found by scrubbing. Not yet shown on the graphruns/done
6Changes in the sandbox: graph edits, spoken or typed commands, reviewTyped commands done 10-28: gates pass, a failure put back byte for byte, the game unchanged. Graph edits and spoken commands not builtsandbox/half
7Valves on a replayDone 10-28: a damage wire doubled with no rebuild, slowest 0.84 s; the kept valve as an edit replays identicallyruns/ sandbox/done
8Unreal editor view, only if IR-2 chooses itBlocked on IR-2: the browser comes first unless that decision says otherwiseits own projectL
9The verdictSecond game done 10-28 (Zombie Crossing, 1,270 graphs); this report written; whether the view joins u2ue is decided from itthis folderdecision
BCBlueprint 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 triedview/ 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
PASSKnowledge graph: 0 failing gaps; 172 single-family requirements listed, not failing
PASSMutation test: 12 of 12 faults planted in the real model caught; 2 that only the graph can see listed
PASSuml.py check on the generated use cases: every named identifier resolves
PASSCoverage: 228 of 228 features carry a defined use case
PASSSource gate: all 44 sentences of the discussion cited by a requirement
PASSOption space: 36 cells, every PRESENT opened and read
OPENInterrogation: 35 questions, all of them the 16 decisions above, by design until they are answered