Why Procedural Generation Is the Most Honest Plot Generator in Game Design

The first time my Dwarf Fortress settlement starved to death because a river dried up in the second winter, I spent forty-five minutes on the wiki trying to understand hydrology. I was not having fun. Nobody looking at me hunched over that screen would have called it enjoyment. But I was doing something no authored narrative has ever made me do: trying to figure out what a system meant by what it had done to me.

That river drying up was not a scripted event. No designer placed it in the timeline of my save file. The world’s history had been generated from a seed, and somewhere in the simulation of rainfall, elevation, and drainage, a combination of factors produced a drought that hit my specific settlement in my specific second winter. The game did not tell me a story about famine. It created the conditions for famine and then watched what I did.

Here is the thing that almost nobody gets right about procedural generation. The common framing is that it produces infinite possibility—endless worlds, endless levels, endless replayability. That framing is a marketing pitch, not a design argument. The most mechanically honest uses of procedural generation in game design do not produce stories at all. They produce situations—premises that demand interpretation. The system authors what happened. The player authors what it means. The gap between those two acts of authorship is where the most honest game narratives live.

The Difference Between a Story and a Situation

Think about what a plot generator actually does. Not the fantasy version that writes your novel for you, but the real version that writers have used for centuries: a tool that produces a premise—a protagonist, a conflict, a set of constraints—and then gets out of the way. Reedsy’s plot generator describes this division explicitly in its own framing: it helps writers find their story by generating a structured outline around what the writer already knows, with stakes and conflict built into the structure. The generator does not write the story. It generates the scaffold that demands one. Its emphasis on stakes as what separates a plot from a sequence of events, and its iterative lock-and-regenerate workflow, mirror something procedural games do when they function well: they converge on meaning through constraint, not through prescription.

That same discipline applies to narrative structure: before publishing, editors need a way to test events, claims, and consequences actually follow one another, which is where a novel plot generator that fits the project can function as a planning aid rather than a substitute for domain evidence.

This is structurally identical to what the best procedural games do. Dwarf Fortress’s world generation produces a history—a timeline of wars, migrations, beast attacks, political upheavals—that the player inherits without choosing. That history is a premise. When you embark on a site that was once the location of a dwarven civilization wiped out by a forgotten beast two centuries ago, the game has not told you a story. It has handed you a situation and said: what do you do with this?

The answer is not scripted. The answer is whatever you build, literally and figuratively. You might reclaim the ruins as an act of cultural restoration. You might loot them. You might build your fortress on the bones of the old one and never mention it to anyone. The game does not care which you choose, and that indifference is what makes the choice meaningful. An authored narrative would have an opinion. A generated situation does not. It simply exists, and you exist in relation to it.

What Screenwriting Format Teaches About Procedural Constraint

There is a useful parallel here that most game designers never think about. Screenwriting format—the industry-standard structure of scene headings, action lines, and dialogue formatting—is one of the most rigid constraint systems in any creative medium. As StudioBinder’s screenwriting guide lays out, a screenplay demands Courier 12-point font, specific margins, scene headings that establish interior or exterior space and time of day, and a page-to-screen ratio of roughly one minute per page. These are not suggestions. They are constraints every working screenwriter operates within.

But screenwriters do not experience these format rules as limitations on creativity. They experience them as a framework that channels creative energy into a producible structure. The scene heading (INT. APARTMENT – NIGHT) is not a creative act. It is a premise-generating act. It establishes where you are, when you are there, and implicitly demands that something happen. The screenplay format is a constraint engine that produces situations requiring narrative resolution.

Procedural generation in games works the same way when it is designed well. The system generates constraints—a river dries up, a faction declares war, a ritual requires a resource you do not have—and those constraints demand narrative resolution from the player. Bad procedural games treat the generator as a substitute for the writer, producing endless content that does not require interpretation. Good procedural games do something different, on purpose: they treat the generator as a constraint engine that produces premises the player must resolve through play.

Dwarf Fortress: History as Premise

Dwarf Fortress generates centuries of history before you ever place a single workshop. Civilizations rise and fall. Megabeasts lair in specific mountains. Wars are fought over specific grievances. Every artifact, every engraving reference, every migrant who arrives at your fortress with a backstory—that migrant was a prisoner of war who escaped, that engraver’s parent was killed by a troll in a specific cave—comes from a simulated history that exists whether you interact with it or not.

Tarn Adams has said in multiple interviews and in the game’s own documentation that the goal was never to produce a story but to produce a world that contains stories. The distinction matters. A story has a shape: beginning, middle, end, thematic throughline. A world that contains stories is a substrate. It is the soil from which stories grow when a player’s actions intersect with the simulation’s outputs.

When my fortress fell to a goblin siege because I had spent too much effort on a decorative dining hall and not enough on military training, the game did not narrate my hubris. No cutscene about the fall. It produced a situation: goblins at the gate, a poorly trained militia, a dining hall that would never be used. The story—my hubris, my misplaced priorities, the tragic irony of the beautiful room built for a population that would be dead within the season—was authored entirely by me, in the gap between what the system generated and what I chose to do about it.

This is what makes Dwarf Fortress’s procedural generation honest in a way most authored game narratives are not. An authored narrative about a fortress falling because of misplaced priorities would be a story about hubris. It would have an opinion about hubris. It would frame the dining hall as a symbol, the siege as comeuppance, the fall as tragedy. Dwarf Fortress does none of this. It generates a world where rivers dry up and goblins attack and your choices have consequences, and it leaves the meaning entirely to you. That is not a failure of narrative. It is a more honest narrative architecture than most games with scripted stories can manage.

Caves of Qud: Faction Systems as Narrative Collision

Caves of Qud approaches the same structural problem from a different angle. Where Dwarf Fortress generates history, Qud generates faction relationships. The procedural world is populated by factions—baboons, snapjaws, goatmen, various mutant cultures—that have dynamic relationships with each other and with the player. These relationships shift based on player actions in ways that produce narrative collisions no scripted story could anticipate.

The key mechanical insight: Qud’s faction system does not produce stories about factions. It produces situations where faction interests collide with player goals, and the player must interpret the collision. When you kill a baboon because it was blocking your path to a ruin, and the baboon faction’s opinion of you drops, and suddenly baboon patrols are hostile on sight, the game has not told you a story about the consequences of violence. It has generated a situation—your path is now harder because of a choice you made—and left you to decide what that means.

The brilliance of this approach is that it produces narrative without authorial intent. The developers of Qud did not write a story about a player who alienated the baboon faction. They built a system where alienating factions has mechanical consequences, and those consequences produce narrative weight through the player’s experience of them. This is the same structural logic that interactive fiction designers use when they build branching story systems: the system does not predetermine which branch the player will find meaningful. It creates the conditions under which meaning can emerge.

The difference—and it matters—is that Qud’s faction system can produce narrative collisions no branch designer would have thought to script. A player who befriends the goatmen, uses them as allies against a rival faction, and then discovers that the goatmen’s territorial expansion has cut off a trade route the player depended on is experiencing a story that no authored narrative could have anticipated. The system generated the premise. The player authored the meaning. The gap between those two acts is where the narrative lives.

Cultist Simulator: Verb-Crafting as Desperation Engine

Cultist Simulator takes the most radical approach of the three. Where Dwarf Fortress generates history and Qud generates faction relationships, Cultist Simulator generates narrative through the juxtaposition of verbs and nouns in a system that the player barely understands for the first dozen hours. The core loop: place cards into verb slots—study this, talk to this person, explore this location—and watch the system produce outputs you must interpret to survive.

The procedural element is not in the world generation but in the narrative texture. Each playthrough draws from a pool of possible followers, influences, and obstacles, and the specific combination you encounter produces a unique set of narrative premises. When your first cultist is a reluctant scholar who demands books you cannot find, and your second is a wounded veteran who wants violence you are not equipped to provide, the system has generated a situation: two followers with incompatible needs and limited resources to satisfy either. The story—how you manage their competing demands, what you sacrifice, what you lose—is authored by you from the premise the system provided.

Alexis Kennedy has talked about this design philosophy in interviews about Cultist Simulator and his earlier work on Fallen London. The goal was never to produce a narrative the player consumes. The goal was to produce a system that generates desperation, because desperation is the emotional state in which people naturally construct narrative. When you are desperate, you narrate. You tell yourself stories about why this is happening, what you should have done differently, what you will do next. The system does not need to provide the narrative. It needs to provide the conditions under which the player will generate it themselves.

This is why Cultist Simulator’s opacity is a design feature rather than a flaw, even though most players quit before they understand the system well enough to experience it as such. The opacity forces interpretation. When you do not understand why a ritual failed, you construct a theory. When you do not know what a follower will do if you give them a specific influence, you make a choice based on incomplete information and then narrate the outcome to yourself. The system is a novel plot generator in the most literal sense: it generates the premises for narratives that the player then writes through play.

The Gap Between Generated Situation and Player-Authored Meaning

Here is where the structural parallel to interactive fiction and narrative system design becomes direct. Every narrative designer faces the same fundamental problem: how do you create a system that produces situations demanding interpretation without predetermining the interpretation? Branching dialogue systems solve this by offering multiple authored interpretations and letting the player choose which one feels most true. Procedural games solve it by generating situations that no one—designer or player—anticipated, and letting the player construct the interpretation in real time.

Both approaches have strengths. Authored branching can produce thematic depth and emotional precision that procedural systems cannot match. A well-written dialogue choice in Disco Elysium carries specific philosophical weight that no generated situation could replicate, because the weight comes from the specificity of the language, and language is the one thing procedural generation cannot reliably produce at the level of a skilled human writer.

But procedural systems can produce something authored branching cannot: genuine surprise that emerges from the interaction of systems rather than from a designer’s plan. When Dwarf Fortress generates a world where a dragon lairs in the ruins of a civilization your own civilization was once allied with, and you discover this only when your miners breach a cavern they should not have breached, the narrative weight of that discovery comes from the fact that no one planned it. The system produced a juxtaposition of elements—dragon, ruins, alliance history, mining accident—that no branch designer would have thought to script, and the meaning of that juxtaposition is yours to construct.

This is why the best procedural games feel like they were designed by a combative co-author rather than a random number generator. A combative co-author gives you premises that resist easy interpretation. They hand you a situation and refuse to tell you what it means. They create constraints that force you to improvise. They produce material you must shape into narrative through the act of playing. A random number generator gives you noise. A combative co-author gives you structured difficulty—premises that have shape, that point toward meaning, that resist closure.

The difference between noise and structured difficulty is the difference between a procedural game that feels like a slot machine and one that feels like a story generator. Slot machines produce outcomes without meaning. Story generators produce premises that demand meaning. The best procedural games are story generators in the most literal sense: they generate the structural conditions under which stories emerge, and then they get out of the way.

Why This Matters Beyond Procedural Games

The argument I am making is not just about procedural generation. It is about what narrative design in games can learn from the best procedural systems. The lesson: the most honest narratives in any game—procedural or authored—are the ones that create the largest gap between situation and meaning, and then trust the player to cross that gap.

Most authored game narratives do the opposite. They close the gap. They tell you what the situation means before you have had a chance to decide for yourself. A character dies and the music swells and another character delivers a eulogy that tells you exactly how to feel. A moral choice is presented and the game’s UI color-codes the good and bad options so you know which one the designer approves of. A twist is revealed and a character explains its significance in case you missed it. These are not bad techniques—they are standard narrative craft—but they are techniques that assume the player cannot be trusted to generate meaning from premise. They assume the player needs the designer to tell them what the story means.

The best procedural games make the opposite assumption. They assume that if you give a player a situation with real stakes—your fortress is starving, your faction ally has betrayed you, your ritual has produced something you did not expect—the player will generate meaning without being told to. They trust the player to be a narrator, not just a consumer. And in doing so, they produce narratives that feel more honest than most authored stories, because the meaning was not predetermined. It emerged from the intersection of system and player, and it could have emerged differently.

This is the structural problem narrative designers face when building branching story systems, and it is the same reason the best procedural games feel like arguments rather than entertainments. They argue that meaning is not something you deliver to a player. It is something a player constructs when you give them enough material and get out of the way. The procedural generation is not the story. It is the premise. The player is the story. And the gap between them is where game narrative, at its most honest, actually lives.

So the next time a game generates a situation that seems unfair, that seems arbitrary, that seems like it could not possibly have been planned—ask yourself what the system is arguing. Not what it is saying, because systems do not say things. What it is arguing, through the constraints it has placed on you and the interpretations it has refused to provide. The answer, if the system is designed well, is that the system is arguing you should be trusted to mean something without being told what to mean. That is a rarer argument in game design than it should be. And it is one no authored narrative, no matter how well written, can make in quite the same way.