Senior C++ / C# engineer · 30 years shipping Last updated
A knowledge engine with no neural weights. Every answer carries a measured confidence, the evidence behind it, and a refusal when the evidence runs out. It is running in this page.
Three playable demos and a job-search desk - two of them running in this page, the Unity game in its own.
Measure a casement window by tape, voice or photo. The sheet fills in, the figures go on the photo, and you can fly around the window in 3D. A chat box on the page changes the app itself.
Open →Requirements, code and tests as one graph you fly through, with a guided tour and dictation beside it.
Open →Code and Unreal Blueprints as two views of one source, with a 3D city you can fly and games that run on their converted Blueprints.
Open → · The deck · How it works · The codeA toolkit for porting a Unity game to Unreal, with its whole manual on the page.
Open →AI pilots that fly, trade, fight and talk, over a knowledge store you can watch reason.
Open →Pong and an asteroid shooter, each running on its own converted Blueprint while you watch the nodes fire.
Open → · AsteroidsA knowledge engine with no neural weights, showing its reasoning as it answers.
Open →Generating the questions a requirement set has not answered yet.
Open → · Count what's missingMy whole CV crawls past and every character can be shot out of it. Break a company name and that job prints in full. It opens deliberately plain - stick with it until the first powerup.
Keys move · mouse aims · hold to fire · F for fullscreen
Play fullscreen →A job-search desk that runs on my own machine and answers through a tunnel: sign in, drop a résumé in, and it reads the PDF itself, searches the web for currently-open roles that actually match it, and tailors the application - showing you the whole thing before anything is sent. Asked for two matches, it came back with two live Ubisoft Montréal postings and justified each against real lines from the CV.
Built stdlib-only in one Python file · a Chrome extension signs you in as your real Google account with no OAuth client, no cloud project and no console · every login gets its own project, so nobody sees anyone else's · 76 tests
It only answers while my desktop is awake - it is my own Claude behind it, not a hosted service. If the page says the desk is not answering, that is what it means.
Open the desk →A tool to discover and monitor investment opportunities. [Implementation pending]
Coming soon · Status: system is currently offline
The AI squadron: pilots that fly, trade, fight and talk, over a knowledge store you can watch reason. This tab opens the one canonical build of the game - the same files as rj45thompson.github.io/starfighter - so nothing here can drift behind it again.
WASD to fly · space to fire · 1/2/3 upgrade · type in the terminal: help, ask ORION whats your story, voices on · every panel drags, pins and resizes from its corner grip
The tools are the point here; the game is what came out of them. Block Painter is a 33,000-line level and terrain builder that replaces the Unity interface for this project: terrain sculpting and splat painting across sixteen textures, prop snapping that respects colliders rather than bounding boxes, an eighteen-state tile system with staged multi-select, ridge and brush tools, and biome palettes.
Almost none of it is hard-coded. Tile looks, god rays and laser lines, depth of field, per-beat camera profiles, deploy and battle framing - all of it is configurable in the window, and the whole authored look saves to a named preset that loads back exactly as it was. Behind the window sits a 132-route HTTP bridge so scripts and agents can drive the editor headlessly, NUnit suites that run without opening Unity, a console gate that fails a change on new errors, and a check-in gate that blocks any asset committed without its metadata.
Below is an alpha: a small slice of the tactics layer of a title still to be announced, built entirely in that tool. It runs the real Unity build rather than a cut-down web port - the same renderer, post-processing and shaders as the desktop build - in the browser on WebGPU.
Chrome, Edge or Safari 26 - not Firefox, which has no WebGPU yet · the first load pulls the whole game, so give it a few minutes · it is served from my own machine, so the page says "offline" when that is off.
Play it →Port a Unity game to Unreal, and review it as a model, not a diff. u2ue is a toolkit that moves a Unity game to Unreal Engine 5. Its own tools convert what is not game logic - particle effects, scenes, UI, materials - and hold each result to Unity on numbers. An AI model ports the game's logic by the toolkit's written skill, and a reviewer reads a UML model generated from the toolkit's documents instead of the code line by line.
It has a page of its own: what it measured on a real port, the use case model to click through, the proof it runs, and the full manual.
Open u2ue → Go straight to the manualThings I built that did not exist before, and what each one is actually for. Every claim here links to the artifact, so none of it has to be taken on trust.
It answers from a graph it can show you, and when it does not know, it says so.
66.4 million facts across 512 shards, running in this browser tab with zero neural weights. Every answer carries a calibrated confidence and a trace you can step through. A Bloom filter is used the unusual way round: its job is to prove absence, so "not in the graph" is a real answer rather than a shrug.
Why an employer might care: this is eval and calibration discipline in a shipped artifact - abstention, measured confidence, golden-trace regression tests, and a debugger that replays a recorded run instead of recomputing it.
Try it on the Ask tab. The whole thing is the page you are reading.
How much more should you believe a fact when a second, unrelated source says it too?
Measured on 66,404,117 facts whose provenance is an explicit bitmask over 8 independently collected sources, holding Wikidata-truthy out as external truth and never counting it as an anchor:
| Independent sources | n | Agrees with held-out truth |
|---|---|---|
| 1 | 847,267 | 44.9% |
| 2 | 125,074 | 87.3% |
| 3 | 20,611 | 94.7% |
The part I would want a hiring manager to read: I first published this with better-looking numbers - 88.3% at one anchor, 100% at two. Those counted distinct shared objects rather than distinct provenance, on n=214 internal labels. I withdrew them and re-measured on four orders of magnitude more evidence. The shape held; the levels were optimistic. The retraction is written into the whitepaper rather than quietly dropped.
Full method and controls in the White papers tab.
A test set built so a model cannot pass it by being well-read.
100 adversarial problems for fabricated-relation hallucination: real entities joined by invented relations. The entities are all familiar, so recall does not help - the only way through is to check whether the relation actually exists. Released CC0 with a Croissant 1.0 record.
Why an employer might care: writing a bench that resists being gamed is the hard half of evaluation work. Un-curatable test sets, and "confident and wrong" treated as its own severity rather than folded into ordinary error.
A reasoning layer that has to show its working before it is allowed to answer.
Graph-controlled reasoning: claims are assembled along inspectable chains and checked before emission, rather than produced fluently and audited afterwards. Patent pending.
Why an employer might care: it is the same discipline as the knowledge engine, generalised - make the intermediate steps first-class objects so they can be tested, replayed and rejected.
8,124 conversations, kept with their full reasoning traces.
A reasoning-trace dataset released under Apache-2.0. The traces are the point: what was tried, what was rejected, and why, rather than only the final answer.
Why an employer might care: building and releasing a clean, licensed dataset is unglamorous infrastructure work that most people skip.
Write the examples; let a search find the function that satisfies all of them.
Currently broken, and worth being precise about why. Ask it for bubble sort and it hands back a correct one-line sort. That is the search doing its job: the examples constrain the output, not the algorithm. The deeper problem is the interface - nobody wants to type input/output pairs. It needs an English front end that shows the spec it derived, without quietly letting a language model write the answer.
The idea: instead of predicting code, search a fixed set of primitives for a program that satisfies every supplied example, verified by real execution. The measured system behind it is roughly 2,600 lines, tested against 224 MBPP+ tasks.
Why an employer might care: same principle as everything else here - verify by running it, do not trust a plausible-looking output.
A physics thought experiment, kept deliberately separate from the engineering.
Written up as its own repository. It is speculative by construction and is not offered as a result - it is here because it is mine and it is honest about what it is.
The written record. The paper is typeset and citable with a DOI; the rest are the datasets and source it refers to. Nothing here is a summary of something else - each link is the canonical copy.
The paper, as submitted: the benchmark, the wrapper, the measurements and the controls. Includes the correction where the earlier headline figures were withdrawn and re-measured on four orders of magnitude more evidence.
Read the PDF → DOI: 10.5281/zenodo.20221916 →The working document behind this page, kept in the repository in plain text so the diffs are readable. This is the source the paper above was built from.
WHITEPAPER.md →A 100-problem adversarial benchmark for fabricated-relation hallucination: real entities joined by invented relations. CC0, Croissant 1.0.
Dataset on Hugging Face →An 8,124-conversation reasoning-trace dataset, released Apache-2.0.
Dataset on Hugging Face →A physics thought-experiment written up in the open, separate from the AI work.
Repository →Pages about a game are read into a triple store, and a UML use case model is built out of it. Every step below cites the fact it rests on and how many independent domains back that fact - k=1 is one source, which the reasoner refuses to build on. Nothing here is written by hand.
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | join during the 2 minute starting period | it is the only window in which anyone may join; the server locks when wave 1 begins | proc:starblast/invasion_run/step/1 req:because it is the only window in which anyone may join; the server locks when k=1 |
| 2 | break asteroids in the hope of rockets and missiles | they only have A CHANCE to drop them, and drop no crystals at all; the wiki recommends getting the missiles. These are also the only asteroids that award points | proc:starblast/invasion_run/step/2 req:because they only have A CHANCE to drop them, and drop no crystals at all; the k=1 |
| 3 | fight wave 1 | 22 Green Chickens then 30 more then 5 Yellow Chickens, for 510 gems and no secondaries | proc:starblast/invasion_run/step/3 req:because 22 Green Chickens then 30 more then 5 Yellow Chickens, for 510 gems an k=1 |
| 4 | spend gems carefully on the tier climb | gems are finite in Invasion, since only aliens and asteroids drop them | proc:starblast/invasion_run/step/4 req:because gems are finite in Invasion, since only aliens and asteroids drop them k=1 |
| 5 | fight each wave's boss | wave 2 brings a Purple Chicken that splits twice; wave 3 a Fortress that spawns 5 Crabs every 25 seconds | proc:starblast/invasion_run/step/5 req:because wave 2 brings a Purple Chicken that splits twice; wave 3 a Fortress th k=1 |
| 6 | lay a mine field before the next wave arrives | mines have no arming delay here, so they can be placed against a boss directly | proc:starblast/invasion_run/step/6 req:because mines have no arming delay here, so they can be placed against a boss k=1 |
| Condition | Handling | Evidence | |
|---|---|---|---|
| 6a | a player joins after the starting period | the server locks at wave 1, so they cannot | proc:starblast/invasion_run/ext/1 req:handling the server locks at wave 1, so they cannot k=1 |
| 6b | the team breaks too many asteroids at once | broken asteroids split and move, and the field becomes dangerous | proc:starblast/invasion_run/ext/2 req:handling broken asteroids split and move, and the field becomes dangerous k=1 |
| 6c | a player loses all 3 extra lives | they get the Game Over screen and are removed from the run | proc:starblast/invasion_run/ext/3 req:handling they get the Game Over screen and are removed from the run k=2 |
| 6d | gems are spent badly early | they are finite, so a wasted early spend cannot be mined back | proc:starblast/invasion_run/ext/4 req:handling they are finite, so a wasted early spend cannot be mined back k=1 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | join a server that has only just started | early players hold a lasting advantage, because higher tiers beat lower ones | proc:starblast/survival_round/step/1 req:because early players hold a lasting advantage, because higher tiers beat lowe k=2 |
| 2 | mine asteroids for crystals | crystal yield in Survival is 1.35x | proc:starblast/survival_round/step/2 req:because crystal yield in Survival is 1.35x k=1 |
| 3 | buy the next tier as soon as the cargo fills | upgrading a lower tier's stats is not worth it, except energy regeneration | proc:starblast/survival_round/step/3 req:because upgrading a lower tier's stats is not worth it, except energy regenera k=2 |
| 4 | climb the ship tree, choosing a branch at each tier | each ship upgrades into one of two | proc:starblast/survival_round/step/4 req:because each ship upgrades into one of two k=1 |
| 5 | survive to the Survival period | it begins 30 minutes in, or when a player reaches Tier 7 | proc:starblast/survival_round/step/5 req:because it begins 30 minutes in, or when a player reaches Tier 7 k=1 |
| 6 | fight as the gravity field closes | the field pushes everyone outward until the map wrap forces them together | proc:starblast/survival_round/step/6 req:because the field pushes everyone outward until the map wrap forces them toget k=1 |
| 7 | be the last player alive | the server ends when one player is left | proc:starblast/survival_round/step/7 req:because the server ends when one player is left k=1 |
| Condition | Handling | Evidence | |
|---|---|---|---|
| 7a | the player runs out of lives | the ship downgrades a tier and keeps that tier's upgrades; it is not the end of the run | proc:starblast/survival_round/ext/1 req:handling the ship downgrades a tier and keeps that tier's upgrades; it is not t k=2 |
| 7b | the player becomes the leader | a trophy marker exposes their position to everyone, off-radar included | proc:starblast/survival_round/ext/2 req:handling a trophy marker exposes their position to everyone, off-radar included k=2 |
| 7c | other players team up | bouncing lasers exist to give a soloist a chance against a team | proc:starblast/survival_round/ext/3 req:handling bouncing lasers exist to give a soloist a chance against a team k=2 |
| 7d | the survival period starts while the player is below Tier 7 | nobody may upgrade to Tier 7 after it begins | proc:starblast/survival_round/ext/4 req:handling nobody may upgrade to Tier 7 after it begins k=2 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | join one of three factions | a team is open while its total shield+energy is under the all-team average plus 300, and it holds under ~30 players | proc:starblast/team_mode_round/step/1 req:because a team is open while its total shield+energy is under the all-team ave k=1 |
| 2 | mine asteroids for crystals | crystal yield in Team Mode is 2x | proc:starblast/team_mode_round/step/2 req:because crystal yield in Team Mode is 2x k=1 |
| 3 | upgrade the ship up to Tier 3 | Tier 3 is the ceiling until the station itself is upgraded | proc:starblast/team_mode_round/step/3 req:because Tier 3 is the ceiling until the station itself is upgraded k=2 |
| 4 | deposit crystals into the station depots | depositing takes time and the ship cannot move while it happens | proc:starblast/team_mode_round/step/4 req:because depositing takes time and the ship cannot move while it happens k=1 |
| 5 | spend the credits the deposit returned on pods and secondary weapons | credits are returned equal to the crystals deposited | proc:starblast/team_mode_round/step/5 req:because credits are returned equal to the crystals deposited k=1 |
| 6 | upgrade the station to level 4 with full gem capacity | this is what unlocks Tier 7 ships | proc:starblast/team_mode_round/step/6 req:because this is what unlocks Tier 7 ships k=2 |
| 7 | fully upgrade a Tier 6 ship before mining again | it maxes the cargo the player can carry | proc:starblast/team_mode_round/step/7 req:because it maxes the cargo the player can carry k=1 |
| 8 | destroy every enemy station's spawn ports and depots | a station falls when both are destroyed | proc:starblast/team_mode_round/step/8 req:because a station falls when both are destroyed k=1 |
| Condition | Handling | Evidence | |
|---|---|---|---|
| 8a | a teammate steals crystals | a full cargo cannot pick up more gems, which is the countermeasure | proc:starblast/team_mode_round/ext/1 req:handling a full cargo cannot pick up more gems, which is the countermeasure k=1 |
| 8b | the player is on their last life | buying a life may beat depositing, to avoid downgrading | proc:starblast/team_mode_round/ext/2 req:handling buying a life may beat depositing, to avoid downgrading k=1 |
| 8c | a single team dominates | the other two teams stay open to joining, and cross-teaming against the leader is a recognised response | proc:starblast/team_mode_round/ext/3 req:handling the other two teams stay open to joining, and cross-teaming against th k=1 |
| 8d | the player dies at Tier 7 | Tier 7 has zero lives in Team Mode, so the ship downgrades to Tier 6 | proc:starblast/team_mode_round/ext/4 req:handling Tier 7 has zero lives in Team Mode, so the ship downgrades to Tier 6 k=2 |
| 8e | the enemy attacks with heavy mines | projectiles do not set them off; leave them and the base drifts clear | proc:starblast/team_mode_round/ext/5 req:handling projectiles do not set them off; leave them and the base drifts clear k=1 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | pick an asteroid to mine | larger asteroids give more gems per damage dealt, but take longer and expose the miner | proc:starblast/mine_and_upgrade/step/1 req:because larger asteroids give more gems per damage dealt, but take longer and k=1 |
| 2 | shoot and ram the asteroid until it drops gems | in Team Mode only the ship dealing the most damage may collect them for the first few seconds | proc:starblast/mine_and_upgrade/step/2 req:because in Team Mode only the ship dealing the most damage may collect them fo k=1 |
| 3 | fly over the gems to collect them | a gem floats for a few seconds, then shrinks and disappears | proc:starblast/mine_and_upgrade/step/3 req:because a gem floats for a few seconds, then shrinks and disappears k=1 |
| 4 | stop before the cargo overflows | gems beyond the cargo limit are lost, and a full cargo cannot pick up any more | proc:starblast/mine_and_upgrade/step/4 req:because gems beyond the cargo limit are lost, and a full cargo cannot pick up k=1 |
| 5 | open the donation screen and spend the cargo | W key in Survival Mode, or enter the base depot in Team Mode | proc:starblast/mine_and_upgrade/step/5 req:because W key in Survival Mode, or enter the base depot in Team Mode k=1 |
| 6 | choose between the next tier, better stats, and an extra life | an extra life costs one full cargo | proc:starblast/mine_and_upgrade/step/6 req:because an extra life costs one full cargo k=1 |
| Condition | Handling | Evidence | |
|---|---|---|---|
| 6a | the ship's shield reaches zero while carrying gems | the gems are knocked out and the score they were worth is lost; anyone can pick them up, including the ship that dropped them | proc:starblast/mine_and_upgrade/ext/1 req:handling the gems are knocked out and the score they were worth is lost; anyone k=2 |
| 6b | the cargo is full and a bigger gem appears | a full cargo cannot pick up more, but losing one gem makes room and the excess then disappears | proc:starblast/mine_and_upgrade/ext/2 req:handling a full cargo cannot pick up more, but losing one gem makes room and th k=1 |
| 6c | a heavier enemy ship rams the miner off its own gems | the top-damage rule delays them only a few seconds, so gem stealing remains possible | proc:starblast/mine_and_upgrade/ext/3 req:handling the top-damage rule delays them only a few seconds, so gem stealing re k=1 |
| 6d | the player must stop playing mid-round | entering a depot and leaving preserves the ship, points, gems, secondaries and credits, provided the base survives | proc:starblast/mine_and_upgrade/ext/4 req:handling entering a depot and leaving preserves the ship, points, gems, seconda k=1 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | fill the Tier 1 cargo | a ship of level L holds 20L^2 gems | starblast/tier1 maximum capacity 20 gems k=2 |
| 2 | carry 80 gems into the upgrade | this tier's own capacity, once reached | starblast/tier2 maximum capacity 80 gems k=2 |
| 3 | or take the delta fighter | upgrades into pulse fighter, side fighter | starblast/ship_delta_fighter req:in_tier starblast/tier2 k=1 |
| 4 | or take the trident | upgrades into shadow x1, y defender | starblast/ship_trident req:in_tier starblast/tier2 k=1 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | fill the Tier 2 cargo | a ship of level L holds 20L^2 gems | starblast/tier2 maximum capacity 80 gems k=2 |
| 2 | carry 180 gems into the upgrade | this tier's own capacity, once reached | starblast/tier3 maximum capacity 180 gems k=2 |
| 3 | or take the pulse fighter | – | starblast/ship_pulse_fighter req:in_tier starblast/tier3 k=3 |
| 4 | or take the shadow x1 | – | starblast/ship_shadow_x1 req:in_tier starblast/tier3 k=2 |
| 5 | or take the side fighter | – | starblast/ship_side_fighter req:in_tier starblast/tier3 k=2 |
| 6 | or take the y defender | – | starblast/ship_y_defender req:in_tier starblast/tier3 k=2 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | fill the Tier 3 cargo | a ship of level L holds 20L^2 gems | starblast/tier3 maximum capacity 180 gems k=2 |
| 2 | carry 320 gems into the upgrade | this tier's own capacity, once reached | starblast/tier4 maximum capacity 320 gems k=2 |
| 3 | or take the crusader | – | starblast/ship_crusader req:in_tier starblast/tier4 k=2 |
| 4 | or take the mercury | – | starblast/ship_mercury req:in_tier starblast/tier4 k=2 |
| 5 | or take the pioneer | upgrades into howler | starblast/ship_pioneer req:in_tier starblast/tier4 k=2 |
| 6 | or take the side interceptor | upgrades into howler | starblast/ship_side_interceptor req:in_tier starblast/tier4 k=2 |
| 7 | or take the vanguard | upgrades into u sniper | starblast/ship_vanguard req:in_tier starblast/tier4 k=2 |
| 8 | or take the x warrior | upgrades into t warrior | starblast/ship_x_warrior req:in_tier starblast/tier4 k=3 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | fill the Tier 4 cargo | a ship of level L holds 20L^2 gems | starblast/tier4 maximum capacity 320 gems k=2 |
| 2 | carry 500 gems into the upgrade | this tier's own capacity, once reached | starblast/tier5 maximum capacity 500 gems k=2 |
| 3 | or take the aetos | upgrades into a speedster | starblast/ship_aetos req:in_tier starblast/tier5 k=2 |
| 4 | or take the bat defender | – | starblast/ship_bat_defender req:in_tier starblast/tier5 k=2 |
| 5 | or take the furystar | – | starblast/ship_furystar req:in_tier starblast/tier5 k=3 |
| 6 | or take the howler | upgrades into rock tower, h mercury | starblast/ship_howler req:in_tier starblast/tier5 k=2 |
| 7 | or take the shadow x2 | – | starblast/ship_shadow_x2 req:in_tier starblast/tier5 k=2 |
| 8 | or take the t warrior | – | starblast/ship_t_warrior req:in_tier starblast/tier5 k=2 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | fill the Tier 5 cargo | a ship of level L holds 20L^2 gems | starblast/tier5 maximum capacity 500 gems k=2 |
| 2 | carry 720 gems into the upgrade | this tier's own capacity, once reached | starblast/tier6 maximum capacity 720 gems k=2 |
| 3 | or take the a speedster | – | starblast/ship_a_speedster req:in_tier starblast/tier6 k=3 |
| 4 | or take the advanced fighter | – | starblast/ship_advanced_fighter req:in_tier starblast/tier6 k=3 |
| 5 | or take the barracuda | – | starblast/ship_barracuda req:in_tier starblast/tier6 k=2 |
| 6 | or take the condor | – | starblast/ship_condor req:in_tier starblast/tier6 k=3 |
| 7 | or take the h mercury | – | starblast/ship_h_mercury req:in_tier starblast/tier6 k=1 |
| 8 | or take the marauder | – | starblast/ship_marauder req:in_tier starblast/tier6 k=3 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | fill the Tier 6 cargo | a ship of level L holds 20L^2 gems | starblast/tier6 maximum capacity 720 gems k=2 |
| 2 | carry 980 gems into the upgrade | this tier's own capacity, once reached | starblast/tier7 maximum capacity 980 gems k=2 |
| 3 | or take the aries | – | starblast/ship_aries req:in_tier starblast/tier7 k=3 |
| 4 | or take the bastion | – | starblast/ship_bastion req:in_tier starblast/tier7 k=2 |
| 5 | or take the odyssey | – | starblast/ship_odyssey req:in_tier starblast/tier7 k=3 |
| 6 | or take the shadow x3 | – | starblast/ship_shadow_x3 req:in_tier starblast/tier7 k=3 |
| Step | Because | Evidence | |
|---|---|---|---|
| 1 | fill the Tier 7 cargo | a ship of level L holds 20L^2 gems | starblast/tier7 maximum capacity 980 gems k=2 |
| 2 | carry 1280 gems into the upgrade | this tier's own capacity, once reached | starblast/tier8 maximum capacity 1280 gems k=1 |
| Domain | Facts | |
|---|---|---|
| starblast.fandom.com | 434 | read through the browser pane - WebFetch returns HTTP 402 here |
| en.namu.wiki | 105 | |
| x4-foundations-wiki.fandom.com | 81 | read through the browser pane - WebFetch returns HTTP 402 here |
| steamcommunity.com | 66 | |
| x4.xuniverse.wiki | 37 | |
| example.org | 26 | |
| www.ludo.guide | 21 | |
| en.wikipedia.org | 16 | |
| iogameshub.com | 16 | |
| x4playershandbook.com | 8 | |
| starblastio.gamepedia.com | 6 | |
| wiki.egosoft.com | 4 | |
| example.net | 2 | |
| roguey.co.uk | 1 | |
| gameplay.tips | 1 |
A language model writes requirements well. Asked to
check its own coverage, it writes the list first and then measures against it — so the sweep
cannot come back low. This is the other half: gml audit extracts
the set from the syntax tree and subtracts. Same specification below, two denominators.
The specification swept a closed space of 141 terms and found nearly all of them owned. Every term in that space was written by the same pass that wrote the use cases, so anything it did not think of was never in the set. The number is not a lie. It is true about a denominator nobody else chose.
The other tab builds a model. This one checks a finished one. They catch opposite failures, which is why both are here — and the middle column below is the same model the other tab builds, run through this one.
The writing half · the other tab
Reads a corpus into a triple store and builds a UML use case model out of it, refusing to rest a step on a single source.
The counting half · this tab
Reads the source and the finished model into one store of eleven predicates and subtracts one set of citations from the other.
Omission is the harder half. A fabricated requirement leaves a sentence behind that somebody can go and check. A missing one leaves nothing — no text to be suspicious of — which is how a coverage sweep reports 99% and is wrong.
Two subjects, three models, one auditor. Every figure is output from
gml audit.
| kripke_planner.js387 lines · spec written for this file | index.html8,101 lines · the other tab's model, grounded in code | index.html8,101 lines · the same, grounded in documentation | |
|---|---|---|---|
| Declarations in the file | 213 | 6,492 | 6,492 |
| On the surface | 60 | 1,683 | 1,683 |
| Use cases in the model | 9 | 29 | 26 |
| Accounted for | 44 · 73% | 74 · 4% | 4 · 0.2% |
| Cites what is not there | 0 | 1 | 20 |
| Cites a local, not the surface | 0 | 0 | 2 |
| Chain breaks | 0 | 24 | 19 |
| A model written to cover one file, and it nearly does. What it misses is specific: four tuning constants, the frame's own fields, six exported functions. | 29 use cases cannot cover 1,683 declarations, and nobody claimed they would. The 4% is the scale reading — how much of a real file a model this size touches. | Same size model, and it resolves almost nothing. That is not a worse model. It is pointed at a different set. |
The twenty citations from the documentation-grounded model that resolve to
nothing in index.html. Read them: not one is invented. Every one is a real thing
the sources talk about — and none of them is a declaration.
Grounding in documentation and grounding in code are
different sets, and this is the seam between them. A requirement resting on
space station is resting on something the corpus states and the parser cannot see; a
requirement resting on spillGems is the other way round. Neither denominator is
the right one on its own, and the audit is what makes the gap between them countable instead
of arguable.
Every declaration in kripke_planner.js that sits in the module
body, plus every property hanging off one — found by descending from the file through
wrappers that declare nothing of their own, so an IIFE costs no levels. 60 of the file's 213
declarations. The rest are locals, and no specification owes an account of a loop counter.
| Symbol | Kind | Reads | Line |
|---|
The list of misses is the measurement. This is what the measurement costs — a builder handed a specification with a chain break does not stop. They invent whatever makes the precondition true, and every builder invents something different.
Exit code is non-zero while anything is open, so it drops into CI unchanged.
$ gml surface --source kripke_planner.js --root .
7x function plan depth 3 kripke_planner.js:206
3x property MAX_WORLDS depth 4 kripke_planner.js:36
...
60 on the surface · 213 declarations in all · 2 read nowhere
$ gml audit spec.json --source kripke_planner.js --root .
surface 60 declarations a specification owes an account of
accounted for 44 73%
never cited 16
CHAIN BREAKS (2) — a precondition nothing makes true
UC-E1-1 needs S:no_frame
UC-E2-1 needs S:frame_standing
NEVER CITED (16)
CREDIT_BANDS, DRIFT_LABEL, DRIFT_POLL_S, HULL_BANDS, PERSIST_THROTTLE_MS,
R, ROUTE_MAX_DEPTH, V, _setTestHost, _testHost, diamond, ensures,
fingerprint, lastWorld, propsNow, reachable
exit 1
Why there is no prose path. The first version of this searched a Markdown
specification for each symbol name in turn. A pattern match cannot tell the variable
frame from the English word, and it scored a name inside a pasted code fence as
accounted for. So a specification cites instead: ground UC-1 MAX_WORLDS is an edge, and
the whole audit is a difference between two sets of edges. Both sides — the syntax tree and
the specification — are read into one store of eleven predicates. Nothing here is a search.
Count how many independent sources assert the fact. That count maps to a probability through a curve fitted against a held-out source the system never consults when answering.
| independent sources | predicted | actual (held out) | n |
|---|---|---|---|
| 1 | 45.0% | 44.8% | 423,406 |
| 2 | 87.1% | 87.5% | 62,749 |
| 3 | 94.6% | 94.7% | 10,309 |
Fitted on one half of the entities and tested on the other, split by subject so no entity appears on both sides. Expected calibration error: 0.20 percentage points across 496,464 held-out facts. The curve predicts - it is not describing its own training data.
An anchor is a second source, not a second opinion. One source is close to a coin flip. A second independently collected source takes it to 87%. That lift survives controls for popularity, for shared lineage between sources, and for gaps in the reference set.
Australia -> capital
-> Canberra - the answer to this page's own headline example. Measuring the cap
rather than defending it is what removed it: it was discarding 1.58% of the graph, and 99.9% of
subjects never came near it. "Not recorded here" now genuinely means the sources did not record
it.BETA - under construction. This engine is being replaced by a rebuild with real entity identity (a store of things, not strings); what works and what is wrong changes as I work on it, up and down. The question below runs on a string-keyed graph and can merge namesakes; the rebuild fixes that.
A lookup answers one hop. This chains them, hop by hop, over 66 million facts - and when it cannot reach the target it abstains, goes and learns what else that thing is called, and tries again.
Try
is there a favorite color
who was Julius Caesar
capital of the country Melbourne is in
how many types of empire are there
Ask something above and this fills in as the search runs. It is the same graph read five ways, because one picture of it answers almost nothing. Structure is what connects to what. Evidence sorts nodes into shells by how many independent sources back them, best at the core, so how much of an answer rests on a single source is visible as a shape. Hops puts one plane per step away from your question, so depth is drift. Chains shows only the routes that actually completed. Grid is the same nodes as sortable rows. Click any node, in any of them, for every fact on file about it.
When a search completes, its best chain compiles here into
stepped pseudo-code: move the execution pointer back and forth and watch the variables the
engine actually measured - sources, curve points, composed confidence, shard ids. Nothing is
recomputed while you step (the time-travel-debugger rule: replay the record). The other listed
chains are real divergence points - routes this search also
completed (top 12 by composed confidence here, top 8 in the geometry rack - disclosed cuts; the
ANSWERS list above is never truncated) - click one to debug that route instead. The engine
uses this debugger itself: after every run it self-checks by re-stepping its own record
against the shards (CHECK lines in the trace) and repairs any hop whose measurement drifted - re-measured, recomposed, re-ranked, out loud. The record save/loads across visits (a replay of
stored values, never a hidden re-run), and re-run resume from here re-runs the real search
from any hop with that edge excluded - rewind-and-branch on the live engine. The picture is not only for you: once the layout settles, the engine
reads its own map to order the frontier (every re-rank is a VISION line in the trace, counted
in window.__visionFlips; ordering only, it can never change an answer - and its
benefit is counted, not yet benchmarked).
The same conclusion, as geometry - currently offline. Each completed chain used to be drawn above the graph as a floating ruler: one segment per hop, segment length = -log(p_hop), so multiplying hop probabilities becomes adding lengths and the most probable chain is literally the shortest ruler. It is not reachable right now: the graph panel was rebuilt as a tabbed control on 2026-08-28 and the geometry rack has not been ported onto it yet. It is on the burn-down list rather than quietly deleted, and this paragraph says so instead of describing a view you cannot open. Counting questions get their own program - LOAD the class, CHECK each member in the order it was actually read, RET the count.
Ask something and this panel will explain, in plain English, what the engine actually did for that question - how it read it, what it opened, what completed, and what the numbers mean. Nothing here is pre-written; it is generated from the same counters the trace shows.
Counting questions ("how many types of bear have brown hair") use a
second shipped artifact: an inverse membership index, 7,903,120 parent→child pairs
over 241,099 classes, built by re-reading the shipped shards. It adds no facts - membership is only stored one way (grizzly bear →is a→ bear) and the
shards are keyed by subject, so without it a class's members cannot be enumerated at all. A
count states what the graph records, names the read bound, and keeps "named for it"
separate from "attested by a fact".
Hand-written: a listed table of about fifteen question-word aliases, so
"who founded X" reaches founded by. Nothing about any specific subject is
special-cased and no answer is stored. A "no chain" result is not proof there is none - the trace shows exactly what was and was not opened.
args -> expected is not how anyone wants to request code. The fix is an English front end that shows you the spec it derived before searching - and it has to stay a translator, not a code generator, or this page would be claiming a search result it did not actually earn. Left visible rather than hidden, because what is here is what is running.The other half of the same idea, in a different domain: given input->output examples, search a fixed set of primitives for one that satisfies every example - verified by real execution, not predicted by a model. This box re-implements a small slice of it entirely in this page; the measured system is a ~2,600-line search engine tested against 224 MBPP+ programming tasks.
args -> expected
(JSON). Leave off -> expected on a line and the engine will compute it and ask
you to confirm - optional if English is enough to run a demo on.Try
reverse a list
sum a list
add two numbers
lowercase a string
impossible on purpose