← All projects

Senior C++ / C# engineer · 30 years shipping Last updated

R.J. Thompson

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.

facts in the graph
66,404,117
distinct subjects
12,172,957
calibration error
0.20 pp
neural weights
0
show for
Ask anything · watch it think BETA
Résumé Breakout
Star Fighter
Level builder ALPHA
Job Desk
Deal Finder BETA
Unity → Unreal BETA
Closed loop fly-through →
All projects
The work
Requirements gathering BETA
Count what's missing BETA
Tools

Casement Sheet

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 →

Closed loop fly-through

Requirements, code and tests as one graph you fly through, with a guided tour and dictation beside it.

Open →

Blueprint View

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 code

u2ue: Unity to Unreal

A toolkit for porting a Unity game to Unreal, with its whole manual on the page.

Open →
Games

Star Fighter

AI pilots that fly, trade, fight and talk, over a knowledge store you can watch reason.

Open →

Blueprint games

Pong and an asteroid shooter, each running on its own converted Blueprint while you watch the nodes fire.

Open →  ·  Asteroids

Résumé Breakout

A CV that crawls past, where every character can be shot out of it.

Open →
On this page

Ask anything, watch it think

A knowledge engine with no neural weights, showing its reasoning as it answers.

Open →

Deal Finder

The deal finder, in its own tab here.

Open →

Requirements gathering

Generating the questions a requirement set has not answered yet.

Open →  ·  Count what's missing
Code and data

anchor-demo

The source of this site, including every page listed here.

Open →

closed-loop-kit

The closed loop requirements kit behind the fly-through.

Open →

blueprint-view-source

The Blueprint View prototype, MIT licence.

Open →

correlation-anchor-theory

The anchor law paper and its code.

Open →

BossBench

A benchmark dataset on Hugging Face.

Open →  ·  WarShip

Résumé Breakout

My 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 →

Job Desk

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 →

Deal Finder

Beta System Down

A tool to discover and monitor investment opportunities. [Implementation pending]

Coming soon  ·  Status: system is currently offline

Star Fighter

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

Play fullscreen →

Block Painter LEVEL BUILDER

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 →

u2ue UNITY → UNREAL

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 manual

Things 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.

A knowledge engine that abstains instead of guessing

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.

The anchor law

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 sourcesnAgrees with held-out truth
1847,26744.9%
2125,07487.3%
320,61194.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.

BossBench

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.

Dataset on Hugging Face

TDRE - Truth-Directed Reasoning Engine

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.

WarShip

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.

Dataset on Hugging Face

Program search BETA

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.

CART - Correlation Anchor Theory

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.

correlation-anchor-theory on GitHub

R.J. Thompson - senior C++ / C# engineer, 30 years shipping. Email  ·  PDF résumé  ·  LinkedIn  ·  GitHub

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.

BossBench v1 and a Substrate-Grounded Wrapper for LLM Refusal Discipline and Self-Extending Capabilities

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 →
peer-citabletypeset archived

Verified Knowledge Extraction from Language Models

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 →
sourcemarkdown

Datasets and code

BossBench v1

A 100-problem adversarial benchmark for fabricated-relation hallucination: real entities joined by invented relations. CC0, Croissant 1.0.

Dataset on Hugging Face →
benchmarkhallucination CC0

WarShip

An 8,124-conversation reasoning-trace dataset, released Apache-2.0.

Dataset on Hugging Face →
reasoning tracesApache-2.0

Correlation Anchor Theory

A physics thought-experiment written up in the open, separate from the AI work.

Repository →
physicsthought-experiment
These link to the primary artifacts rather than re-hosting copies, so what you read here is whatever the canonical record currently says.

Requirements gathering

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.

1120facts
11use cases
69steps cited
0inferred
27steps at k=1
23links
15source domains
0/92 events · run clock 0.000s
SYSTEM TRACE
MODEL BEING BUILT
0use cases
0steps cited
0on one domain
0links
Two angles, run side by side. 4 harvested cases were read from pages that describe somebody doing something, so they have a named actor, ordered steps and real failure branches. 7 derived cases were walked from the fact graph: the order is forced by the facts, but no bill of materials says who acts, so their actor is printed as INFERRED rather than guessed.

EPIC-1 · a whole run

UC-01 · A team survives an Invasion runharvested

Level sea (user goal)
Primary actor player
Trigger a team of up to 6 joins an Invasion server
Includes UC-02 (text)

StepBecauseEvidence
1join during the 2 minute starting periodit is the only window in which anyone may join; the server locks when wave 1 beginsproc:starblast/invasion_run/step/1 req:because it is the only window in which anyone may join; the server locks when k=1
2break asteroids in the hope of rockets and missilesthey 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 pointsproc:starblast/invasion_run/step/2 req:because they only have A CHANCE to drop them, and drop no crystals at all; the k=1
3fight wave 122 Green Chickens then 30 more then 5 Yellow Chickens, for 510 gems and no secondariesproc:starblast/invasion_run/step/3 req:because 22 Green Chickens then 30 more then 5 Yellow Chickens, for 510 gems an k=1
4spend gems carefully on the tier climbgems are finite in Invasion, since only aliens and asteroids drop themproc:starblast/invasion_run/step/4 req:because gems are finite in Invasion, since only aliens and asteroids drop them k=1
5fight each wave's bosswave 2 brings a Purple Chicken that splits twice; wave 3 a Fortress that spawns 5 Crabs every 25 secondsproc:starblast/invasion_run/step/5 req:because wave 2 brings a Purple Chicken that splits twice; wave 3 a Fortress th k=1
6lay a mine field before the next wave arrivesmines have no arming delay here, so they can be placed against a boss directlyproc:starblast/invasion_run/step/6 req:because mines have no arming delay here, so they can be placed against a boss k=1

Extensions — real branches the source described, not warnings about thin evidence

ConditionHandlingEvidence
6aa player joins after the starting periodthe server locks at wave 1, so they cannotproc:starblast/invasion_run/ext/1 req:handling the server locks at wave 1, so they cannot k=1
6bthe team breaks too many asteroids at oncebroken asteroids split and move, and the field becomes dangerousproc:starblast/invasion_run/ext/2 req:handling broken asteroids split and move, and the field becomes dangerous k=1
6ca player loses all 3 extra livesthey get the Game Over screen and are removed from the runproc:starblast/invasion_run/ext/3 req:handling they get the Game Over screen and are removed from the run k=2
6dgems are spent badly earlythey are finite, so a wasted early spend cannot be mined backproc:starblast/invasion_run/ext/4 req:handling they are finite, so a wasted early spend cannot be mined back k=1

Where these facts came from

DomainFacts
starblast.fandom.com434read through the browser pane - WebFetch returns HTTP 402 here
en.namu.wiki105
x4-foundations-wiki.fandom.com81read through the browser pane - WebFetch returns HTTP 402 here
steamcommunity.com66
x4.xuniverse.wiki37
example.org26
www.ludo.guide21
en.wikipedia.org16
iogameshub.com16
x4playershandbook.com8
starblastio.gamepedia.com6
wiki.egosoft.com4
example.net2
roguey.co.uk1
gameplay.tips1
k counts domains, not pages. Two pages on one site are one source. The measured curve behind that: one source is 44.9% correct, two is 87.3%, three is 94.7%. That is why a step marked k=1 is shown as a warning rather than a fact.

Count what's missing

Beta Ongoing Runs below last measured . JavaScript only; the surface rule and the finding set are still moving.

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.

Reported by the writer
99%
139 of 141 owned by a use case · 0 unclaimed

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.

60on the surface
44cited
16never cited
2chain breaks
213declarations in all

Two systems, and they are not rivals

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.

Requirements gathering

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 question it asks
Does this claim rest on enough independent sources?
What it catches
Fabrication — a plausible claim with one source, or none
Its unit
k, the number of independent domains behind a fact
Its blind spot
A requirement nobody wrote. There is no claim to check the sources of

The audit

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.

The question it asks
What does the model never account for at all?
What it catches
Omission — and a citation that resolves to nothing
Its unit
The surface: declarations in the module body, found not assumed
Its blind spot
Whether a requirement is any good. It counts; it does not read

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.

Three runs

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 file2136,4926,492
On the surface601,6831,683
Use cases in the model92926
Accounted for44 · 73% 74 · 4%4 · 0.2%
Cites what is not there01 20
Cites a local, not the surface002
Chain breaks02419
  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.

What the documented run cited

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.

acceleratecargo capacitycontrolsdeathendgame warningenergy regenextra lifegame modegems as shieldgravity fieldobjectiveround endspace stationspend gemssteersurvival objectivetier upupgrade categoriesupgrade costweapons

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.

The denominator, printed so it can be argued with

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.

SymbolKindReads Line

What it forces a writer to invent

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.

The run

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.

How the number is computed

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 sourcespredictedactual (held out)n
145.0%44.8%423,406
287.1%87.5%62,749
394.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.

The law

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.

What this is. The whole graph - 66,404,117 facts over 12.2 million subjects - sharded so your browser fetches only the piece it needs. It is a lookup over recorded relations, not a chatbot: it reports what sources asserted, and when nothing asserts anything it says so instead of inventing.

Two limits, stated rather than hidden. (1) Subjects are matched by surface text, not a disambiguated entity id, so a name shared by more than one real thing (many towns are named "Berlin") can appear merged under one heading. Every fact shown is still real and independently sourced - it may just belong to more than one thing with that name. (2) There is no per-subject cap: every one of the 66,404,117 facts is here, and a well-documented subject keeps all of its edges (Australia carries 975). An earlier build capped each subject at 80 facts and, by doing so, silently deleted 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

Watch it think

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.

SEARCH TRACE - every fact the engine actually reads 0 steps
ANSWERS SO FAR - every completed chain, ranked live as it is found0

Step debugger - the conclusion as a program

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.

What just happened

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.

idle - ask a question above and every step will be narrated here, live