Burn-In
All Projects
Indie Game

Burn-In

An arcade of short browser games about how infrastructure really works. Each game teaches one idea: you build it, the game breaks it, and a judge scores what survives.

Game Design Education Networking Cloudflare Workers MCP Agentic Development

An arcade of infrastructure games

Burn-In is a set of short browser games about how infrastructure really works. Each game teaches exactly one idea. You build something, the game breaks it, and a judge scores what survives.

Learn how infrastructure really works by watching it fail: build it, run the test, see what survives.

There is no quiz and no lecture. The failure is the lesson.

The site is an 80s mall arcade. Walk in from the street and the floor is split into six zones: Server Hall, NOC, SOC, Office Floor, Platform Pod and Automation Lab. Each game is a cabinet in its zone. Server Hall’s cabinet is open; the rest say coming soon.

The Burn-In arcade floor: zone signs for Server Hall, NOC, SOC, Office Floor, Platform Pod and Automation Lab, with the Tidy Datacenter cabinet lit

How a run works

Every game follows the same loop:

  1. Build the thing: wire the fabric, pack the header, whatever the game is about.
  2. Run the test. The game breaks what you built, one failure at a time, in front of you.
  3. Earn stars on a strict ladder. No rung without the one below it, so the difficulty curve is the concept itself, and stalling on a rung tells you exactly what you haven’t got yet.
  4. Compare and share. Leaderboards per level, and a score card you can post.

The judge is deterministic, and the server re-runs it on every submission. A score the browser sends is ignored, not trusted. That one rule means a person and an AI agent are scored exactly the same way.

Tidy Datacenter, now in the arcade

Tidy Datacenter was game #1. It shipped on its own at tidydatacenter.net in September and moved into the Burn-In arcade at launch; the old address now takes you to its cabinet.

The idea: redundancy is a property of how you wire a fabric, not of how many cables you run.

You cable spine switches to leaf switches on a tile grid. Cables can’t share a tile unless you spend a bridge, and bridges run out, so the neat route and the cheap route are rarely the same route. Underneath, every port sits on a chip (an ASIC), every chip on a line card, every card in a switch, and any of them can fail and take everything on it with it.

Then the failure test runs, breaking one part at a time: cut cables, dead ports, a failed chip, a pulled line card, a whole spine, a spine and a card.

Tidy Datacenter's failure test on Prototype Slice: 32 cables, every scenario survived, five stars

RungWhat it asks
Wiredevery leaf reaches every spine, no port dangling
Link-safeno single cable or port failure costs a leaf its path
ASIC-safeevery bundle spread across the chips at both ends
Card-safethe same, at line-card granularity
Fabric-safelose a spine and a card, and every leaf keeps two uplinks

The part I most wanted to get right: the neatest board in Matched Pair looks perfect. Every link is up, every leaf reaches every spine, not a single crossing. It earns two stars: 12 of its 78 failure scenarios fail, every line-card failure among them. Pull any one card and a leaf loses its link to a spine; lose a spine and then a card on the one that’s left, and a leaf is cut off. Nothing warns you in advance. You find out when the test pulls the card you bunched your cables on.

Four levels so far: First Patch, Matched Pair, Patch Yard and Prototype Slice. Beyond stars, each board ranks on bridges spent, tiles used and tidiness, because those goals pull against each other and a single ranking would hide the trade.

What shipping taught

Ryan's hand-painted sketch of Tidy Datacenter's first board: two spines, four leafs and the tile grid between them

Tidy started as a hand-painted sketch of one board. The first public version had one level: 32 cables, 20–45 minutes, and no way to submit until all 64 ports were patched. About thirty people pressed Play. One finished.

The first level is now eight cables and a couple of minutes, with a walkthrough that puts coachmarks on the board instead of help text in a panel. The concept ladder didn’t change; only the size of the first bite did. The game wasn’t too hard. The on-ramp was missing, and the only way to find that out was to ship it and count.

What’s next

Header Drop, for the NOC, is in development. It’s about what makes an IPv4 header forwardable along a path. More games are planned for the other zones, and each has to clear the same bar: one idea, a test that breaks what you built, and a judge that scores it the same for everyone.

How it is built

Deliberately austere, and run mostly by agents.

  • Zero runtime dependencies. Plain ES modules, no framework, no build step. One Cloudflare Worker serves the arcade, the games and the API, with D1 for runs and leaderboards, on Cloudflare’s free plan.
  • Pure game cores. No DOM, no clock, seeded randomness. That’s what lets the Worker import the same code the browser ran and re-score a run in milliseconds. The Worker verifies; it never searches. Finding a solution is the player’s job, and replaying one is cheap.
  • Agents play by the same rules as people. An MCP server exposes every game through the contract the browser uses, so an agent’s run is judged exactly like a player’s. It’s also how agents playtest a new game before it’s released.
  • An agent-run project. Agents design, implement, review and merge after local CI, through project skills, subagents and hooks. A human approves anything irreversible: deploys, migrations, secrets, DNS and anything posted publicly.

Between the first commit on 16 September and 11 November 2026, that came to more than 1,500 commits and 280 merged pull requests. Tidy itself went from first commit to a live game with a leaderboard in about four hours.

Where it started: Root Cause

Burn-In didn’t start small. Its research phase was Root Cause: a datacenter management sim in Rust and Bevy, with power distribution, thermal zones, a leaf-spine fabric with real bandwidth math, cascading failures and a mystery underneath. Its AI assistant, CHIP, runs fully on-device through llama.cpp, with a router in front of four specialised agents using ReAct tool calling. It shipped with 80+ integration tests.

Root Cause was a deliberate experiment in agentic development: a genuinely complex system in a language and a domain I’d never worked in, with the architecture and decisions mine and the implementation executed by AI agents under my direction. The method held, and it’s the same method that runs Burn-In today.

Burn-In takes the opposite shape: one idea per game, small enough to play in a few minutes in a browser. Root Cause’s early-access alpha is still on itch.io if you want to see where it began.

Play Burn-In → Free, in your browser. Start with Tidy Datacenter; it takes two minutes to find out whether you really understand what fails together.

Related Projects