The Loop Is the Argument: What Roguelikes Actually Teach

Ask a NetHack player for advice and you will get rules. Never eat a kobold corpse. Always kick a locked door rather than opening it if you suspect a mimic. Do not pray twice in quick succession. Never engage a floating eye in melee, ever, under any circumstances, and if you have to be told why then you already have been.

Ask a player of almost any other game for advice and you will get routes. Go left at the fork, drop down, the shotgun is behind the crate. Take the ledge, wait for the second patrol, then vault.

That difference is the entire subject. It is not a matter of taste or vintage or what the community happens to be like. It falls directly out of three mechanical decisions made in 1980 for reasons that had nothing to do with pedagogy, and it is the most interesting thing the genre has to say about how games teach.

Three systems, one effect

The roguelike’s defining trio is procedural generation, permadeath and a short run. Take them one at a time and each looks like a difficulty knob. Put them together and they do something specific.

Procedural generation removes routes from the table. A hand-built level can be memorised. That is a legitimate skill and a real pleasure, and the whole speedrun culture is built on it, but it means the optimal way to learn a hand-built game is to learn that game’s particular geography. Generate the geography fresh each time and memorisation stops paying. What survives is knowledge that generalises: how the systems relate, what the odds are, which interactions are traps. The game has forced you to learn a grammar because it has denied you a sentence.

Permadeath makes the test summative. Checkpoints let you brute-force the local case — die, retry, adjust one variable, repeat, and you will eventually get through the room without ever understanding why. That is genuinely how most of us clear most games. Permadeath deletes the local case. When you die on floor twelve you do not resume on floor twelve; you resume at the top with a different dungeon, and the only thing you carry down is what you understood. Every other asset is confiscated at the door.

The short run tightens the loop. A run that ends in twenty to forty minutes means many hypotheses per hour. The learning rate is a function of how quickly you can be wrong.

Compose them and you have a machine whose output is generalisation. That is what a roguelike teaches: rules, because it has made rules the only portable currency. This is why the genre’s progression system is unusual to the point of being unique. In a roguelike, the thing that gets stronger is the player, and the game stores that upgrade nowhere. There is no save file for it. Your character sheet at hour forty looks identical to hour one. The difference is entirely inside your head, and it is real, and you can feel it — the specific vertigo of returning to a game you beat two years ago and discovering that the knowledge is still there.

Death, in this frame, does one job: it returns information. The run was a hypothesis, the death was the result, and the loop exists to run the experiment again with a better prior. Everything else people say about roguelike difficulty is downstream of that, and I have argued separately that difficulty is a design choice rather than a moral one — the roguelike’s difficulty is instrumental. It is there to make the experiment mean something.

The accident at the bottom of it

Here is the part that should make any designer uneasy. None of this was intended.

Michael Toy and Glenn Wichman built Rogue around 1980 on a Unix system at UC Santa Cruz, with Ken Arnold later rewriting the display code. They generated the dungeon procedurally because storing a hand-built dungeon was expensive on the hardware they had. The permadeath was of a piece with the same austerity — a save file was a resource, and the design that emerged treated one save as one life. The most pedagogically sophisticated structure in the medium arrived because a VAX did not have room for the alternative.

That is the same story as Silent Hill’s fog, which was a draw-distance limit before it was an aesthetic. Constraint produced a mechanic, the mechanic outlived the constraint, and thirty years of designers have been reverse-engineering an intention that was never there. It is worth holding onto when someone tells you that procedural generation is inherently anything — the limits of that surprise are real, and the technique was a storage decision before it was a philosophy.

The trail reached home computers quickly enough. Sword of Fargoal turned up on the C64 in the early eighties — procedural dungeons, a descent, a sword to find, a climb back out, and a death that took everything with it. I played it as a child without any idea that a genre was being founded around me, and what I remember is learning it the way you learn NetHack: in rules. Do not descend past your supplies. The map is not the map you saw last time.

The Berlin Interpretation and why definitions got angry

By 2008 the argument about what counted had got bad enough that people convened in Berlin at a roguelike development conference and wrote down a definition. The Berlin Interpretation lists high-value factors — random environment generation, permadeath, turn-based, grid-based, non-modal, complexity, resource management, exploration and discovery — and low-value ones like ASCII display and a single player character.

It is easy to mock as gatekeeping and it was doing something more useful than that. The Interpretation is an attempt to write down which parts of the trio are load-bearing, by people who had spent decades inside the machine. Turn-based matters because it makes every action a considered move in a legible state; that is what lets a rule be learned. Non-modal matters because a system with no special cases is a system you can reason about. Those are claims about the learning mechanism, dressed as a taxonomy.

Then Spelunky arrived in 2008 and broke it in the most productive way possible. Derek Yu kept procedural generation, permadeath and the short run, threw away turn-based and grid-based entirely, and demonstrated that the pedagogical engine runs perfectly well in real time. Spelunky teaches in rules — the shopkeeper never forgives, the arrow trap fires on the horizontal, the damsel is a resource — and it teaches them at platformer speed. The Interpretation had correctly identified the parts and slightly misidentified which were structural.

The roguelite trade

Then Rogue Legacy in 2013 popularised the thing that ate the genre: persistent upgrades between runs. Die, spend your gold, come back permanently stronger.

Be clear about what this does. It moves the progression out of the player’s head and into a stat sheet. Run forty succeeds partly because you understand the game better and partly because your character has more health than run one did, and the game cannot tell you which, and neither can you. The hypothesis has been contaminated. The run stops being an experiment and becomes a shift.

Be equally clear that it solves a real problem. The pure roguelike has a savage onboarding failure: the first ten hours produce no visible progress whatsoever, and “trust me, you are learning” is a lot to ask of somebody’s evening. Meta-progression makes the loop legible from outside. It also buys authored narrative, which is the whole reason Hades works — Supergiant used the persistent layer to make repetition into a story about repetition, and it remains the most elegant solution anyone has found to that problem. Hades also has a Mirror full of straight stat upgrades and an explicit God Mode that ramps your damage resistance every death, and it is still one of the best-designed games of its decade. Both things are true.

The interesting middle is where the meta-progression adds hypotheses instead of subtracting difficulty. Slay the Spire’s unlocks put new cards into the pool; you end up with a wider possibility space and exactly the same fragility. Balatro does the same thing with jokers — unlocking is a way of complicating the question rather than lowering the bar, and a thousand hours in you are still one bad ante from nothing. That is the version worth copying: the stat sheet stays flat, the design space grows, and the thing levelling up is still you.

The full argument about how the genre drifted is a separate piece, and the canon of the actual ones is where to start if this piece has made you want the undiluted version.

What it means

The roguelike is the only major genre that treats the player as the save file. It is a strange, slightly hostile proposition and it produces a specific kind of pleasure that nothing else does — the moment on run sixty where you decline a fight you would have taken on run six, for a reason you could articulate if anyone asked, and nobody is going to ask.

Everything the genre does well flows from refusing to let you memorise, refusing to let you retry, and asking again immediately. Three constraints, invented by accident on hardware that could not do better, which turned out to be the best teaching structure the medium has produced. The loop is the argument. Losing is how you hear it.