Skip to content
Techniques & Technology

Branching Narrative

Your story, your choices

Branching narrative lets player decisions shape story outcomes, from minor dialogue variations to completely different endings, creating personalised experiences at massive development cost.

cross-platformnarrativedesignstructure1979–present

Overview

Choice and consequence. Branching narrative promises that player decisions matter — not just in the moment, but across the entire story. The technique ranges from cosmetic dialogue variations to genuinely divergent plot paths with different endings. Heavy Rain (2010) offered radically different outcomes including main-character deaths; The Witcher series tracked consequences across multiple games; Fallout: New Vegas (2010) provided four distinct major endings with dozens of intermediate variations. Every branch multiplies development cost — voice, art, scripting, QA — exponentially.

The roots are in Edward Packard’s Choose Your Own Adventure book series (1979), which spawned hundreds of paper-and-binding gamebooks. Steve Jackson and Ian Livingstone’s Fighting Fantasy (1982 onwards) merged the format with light RPG mechanics. Computer games inherited the structure and added complications like state tracking, NPC relationships, and skill-driven branching.

Fast facts

  • Origins: Choose Your Own Adventure books (Edward Packard, 1979); Fighting Fantasy (1982).
  • Computer pioneer: Infocom text adventures (1980s) with limited branching.
  • Modern pioneer: Quantic Dream’s Fahrenheit / Indigo Prophecy (2005) and Heavy Rain (2010).
  • Challenge: Exponential content growth; foldback structure manages cost.
  • Modern approach: Systemic consequences (reputation, world state) rather than tree branches.

Branch types

Decisions vary in scope and consequence:

Type Scope Examples
Cosmetic Dialogue variations only — same outcome Most NPC banter
Tactical Immediate combat / scene outcome “Take the high road or the low road through the cave”
Strategic Long-term consequences within the game Witcher faction-leader choices
Structural Different story paths or endings Heavy Rain character deaths; New Vegas endings
Cross-game Decisions persist across sequels Mass Effect trilogy save imports

Structural patterns

Designers manage branch complexity through patterns:

Pattern Description Example
Foldback Branches diverge briefly then reconverge Most TV-cinematic games — Telltale style
Parallel paths Genuine multiple paths through the same act The Witcher 2 Act 2 (different cities)
Delayed consequence Choice now matters later Mass Effect survival across trilogy
Butterfly effect Small choice, large later impact Until Dawn deaths
Hub-and-spoke Central state, branching missions, return Mass Effect Citadel hub
Linear with detail variation Same beats, different texture per playthrough Most Telltale games
True branching Genuinely different content tree Detroit: Become Human (visualised as a flowchart)

State tracking

System Complexity Examples
Binary flags Simple on/off “killed Gandalf? Y/N”
Numeric values Relationship meters, stats Mass Effect Paragon/Renegade
Quest states Multi-stage tracking Most RPGs
World state Global variables affecting many systems Witcher 3 — many world flags
Reputation tables Faction-keyed numbers New Vegas — 10+ factions tracked
NPC relationship matrices Per-character per-state values Dragon Age approval system

Notable implementations

Game Year Achievement
Choose Your Own Adventure (book series) 1979+ The pre-digital pioneer
Fighting Fantasy (book series) 1982+ Branching + dice mechanics
Façade 2005 First major AI-driven branching dialogue
Fahrenheit / Indigo Prophecy 2005 Quantic Dream’s modern cinematic branching debut
Mass Effect trilogy 2007-2012 Multi-game branch persistence
Heavy Rain 2010 Major-character permadeath; flowchart visualisation
Fallout: New Vegas 2010 Four major endings, dozens of mid-game branches
The Witcher 2 2011 Act 2 splits into two completely different cities / storylines
The Walking Dead 2012 Telltale’s emotional-choice formula
Until Dawn 2015 Butterfly-effect horror; eight playable characters can all live or die
The Witcher 3 2015 Massive open-world branching; 36+ endings
Detroit: Become Human 2018 Most visible branching — in-game flowchart display
Disco Elysium 2019 Branching as character-internal monologue
Pentiment 2022 Obsidian’s 16th-century narrative; branching across decades
Citizen Sleeper 2022 Systemic + branching; tabletop RPG-style

Development economics

Cost factor Impact
Writing Multiplied by branches; lots of unread content per playthrough
Voice acting Expensive per line; harder to record across multiple takes for branches
Testing Combinatorial paths; QA must cover every reachable state
Art assets Unique scenes / lighting / character expressions per branch
Localisation Multiplied by branches × number of languages
Cinematic capture Mocap sessions become exponentially expensive

The “5-7% rule” is industry shorthand: only ~5-7% of a branching game’s content is seen by the average player on a single playthrough. Studios design around this — designing replayable systems rather than truly unique branches.

Player perception

The illusion of branching is often more cost-effective than actual branching:

Reality Player experience
Cosmetic branching disguised as structural Often works — players feel choice mattered without testing
Foldback to common scenes Effective — players don’t compare with other paths
Delayed payoff Satisfying when consequences appear hours later
Replay revelation Returning to play differently is its own genre of satisfaction
True structural branching Most resource-intensive; only some games can afford

The “spotlight illusion” — show the player consequences for their choices, while hiding alternative branches — drives most TV-cinematic games. Telltale’s “[Character] will remember this” notification is the canonical example.

Modern approach: systemic narrative

Modern games move away from explicit branch-trees toward systemic narrative:

  • Emergent stories from interactions between systems (Crusader Kings, Dwarf Fortress, RimWorld)
  • Reputation systems that influence many small interactions (Witcher 3, New Vegas)
  • Factional state machines rather than discrete plot trees (Pentiment, Disco Elysium)
  • AI-augmented — using LLMs to generate dynamic dialogue around scripted beats (experimental; AI Dungeon, various 2024+ indies)

Systemic approaches sidestep the exponential-content problem at the cost of less authored specificity.

See also