She was the only one who could read it. Now she's dead, and it's still running.

A rune-tape program runs the pressure ward that keeps the Drifted City aloft. It ran correctly for eleven years. Last night it killed the engineer who maintained it.

You have her listing. Her logs. Her stepper.

Find the instruction that did it.

You never write a line of code. You read one.

Faultfinder is a deduction game with a debugger for a magnifying glass. Every case opens as three panes: her annotated listing on the left, the machine's live state in the middle, and on the right what the city actually observed. A pressure reading that held at zero for nine seconds. A door that reported closed while it stood open.

Your tools are a debugger's, not a programmer's:

• Step one instruction and watch exactly one thing change.

• Break on a line, or on a condition: stop when PRESSURE drops below four.

• Watch a register and read its whole history as a strip beside the tape.

• Rewind. The entire trace is recorded. The scrub bar runs both ways.

• Inject a different reading from the outside world and re-run it. Some faults only wake for one input in a thousand.

Then you commit. Name one line. Name one fault from a fixed vocabulary: off-by-one boundary, uninitialised register, wrong branch polarity, overwritten value, unit mismatch, missing bounds check. Then name the moment the harm was done. Get all three right and the report writes itself, one clause at a time.

Every case has exactly one answer. That is not a promise. It is a proof.

Faultfinder's cases aren't designed and playtested into fairness. They're machine-verified before they ship. Each one is built by taking a correct program, applying a single seeded fault, and then proving by exhaustive simulation across the whole input space that the faulty program fails, that reverting that one instruction fixes it, and that no other single change can.

If a case has a second defensible answer, the pipeline rejects it and you never see it. No designer ever adjudicates whether your reasoning was fair. The machine already did.

The program is a character document.

M. VOSK kept this ward for eleven years. She annotated her own tape in pencil, translating each rune for herself in her first year, because nobody had taught her either.

Her glosses thin as the cases go on. Her comments get terser. There is a line she commented out, years ago, with the note leave this.

You are the first person in eleven years to read her carefully. You are eleven years late.

For the specific pleasure almost no game has dramatised

If you have ever written software, you know the feeling of a bug collapsing into obviousness. The moment a mess becomes a sentence. Faultfinder makes that collapse the win condition and puts a body underneath it.

And if you haven't: you don't need to. Nothing here asks you to author anything. The blank page is the wall that keeps most players out of programming games, and this game does not have one. Her handwritten gloss sits beside every rune in the first case. Hover translates anything, always. No case is ever gated on remembering.

In the demo

• Seven cases, 35 to 70 minutes, on one machine: the pressure ward on the city's underside

• A fourteen-instruction rune-tape, taught by using it

• Six classes of fault, each hiding in a different way

• Full rewind, conditional breakpoints, register watches and input injection

• Her story, told entirely in marginalia and log fragments

Wishlist Faultfinder to hear when the full ward opens.

From Endpaper

A solo studio in Somerset. Built in Godot.