Interactive Fiction (Bandersnatch Style): How to Format a Branching Script

Prompt: Dark Mode Technical Sketch, a complex flowchart showing branching narrative paths with decision nodes, multiple endpoints, and looping connections, script pages at key nodes, thin white hand-drawn lines, solid black background, high contrast, minimalist, no 3D renders, no neon colors --ar 16:9

The viewer makes a choice. Cereal or no cereal. The narrative branches. One path leads to a memory; the other leads to a breakdown. Thirty minutes later, both paths converge—or don't. There are five possible endings. Or twelve. Or three that matter and nine that loop back.

This is interactive fiction. It's not new—Choose Your Own Adventure books date to the seventies—but Black Mirror: Bandersnatch made it a mainstream film format. And now you're being asked to write one. A branching script where the audience controls (or thinks they control) the story.

Here's the problem: standard screenplay format assumes linearity. Scene 24 follows Scene 23. The reader moves forward through pages. But an interactive script isn't linear—it's a web. The same scene might have three different lead-ins. A choice on page fifteen might determine what happens on page forty-five. The script isn't a document; it's a map.

Formatting this requires new conventions. Tracking it requires new tools. Conceiving it requires a different kind of storytelling brain—one that thinks in branches, not lines.

---

The Fundamental Shift: From Story to System

In traditional screenwriting, you craft a story. Beginning, middle, end. The audience receives it passively.

In interactive fiction, you craft a system. Multiple beginnings, multiple middles, multiple ends. The audience participates—making choices that determine which story they see.

This changes everything.

Character arcs become conditional. The protagonist might grow—or regress—depending on which path the viewer takes. You can't assume a single arc; you must design multiple arcs, each coherent.

Scenes become nodes. A scene isn't just a moment in a sequence; it's a node in a network. It might be reached from three different paths. It must make sense regardless of how the viewer arrived.

Endings become plural. You don't write an ending; you write endings. And the endings must feel earned, not arbitrary. The viewer must believe their choices led to this outcome.

In interactive fiction, the viewer isn't watching a story. They're navigating a space.

This metaphor matters. You're building a space with rooms and doors. Some doors lock based on earlier choices. Some rooms loop back. The viewer explores—and exploration feels different than viewing.

---

Formatting Conventions: Making the Map Readable

There's no single industry-standard format for interactive scripts. Different platforms (Netflix, YouTube, game engines) have different requirements. But common conventions include:

Scene IDs instead of scene numbers. Because scenes don't follow a linear order, they need unique identifiers that aren't positional. "SCENE_A3" rather than "Scene 42."

Choice points marked explicitly. When the viewer must choose, the script marks it: [CHOICE POINT]. The options follow, each linking to a destination scene.

Destination tags. Every choice specifies where it leads: "IF viewer chooses A → SCENE_B2. IF viewer chooses B → SCENE_C1."

Conditional entry text. A scene might play differently based on how the viewer arrived. The script uses conditionals: "IF arrived from SCENE_A3, begin with ALTERNATE OPENING."

Endpoint markers. Scenes that end the experience are marked: [ENDING – TYPE: TRAGIC] or [ENDPOINT: LOOP BACK TO SCENE_D1].

A sample interactive scene might look like:

---

SCENE_B3: INT. STEFAN'S BEDROOM – NIGHT

Conditional: If viewer chose "destroy the computer" in SCENE_A7, begin with ALTERNATE OPENING A.

Stefan sits on the edge of his bed. The room is dark. Rain against the window.

STANDARD OPENING: He stares at the computer. Still running.

ALTERNATE OPENING A: The computer is gone. Broken glass where it used to sit.

STEFAN (to himself) It doesn't matter. It's already inside.

[CHOICE POINT]

The viewer sees text on screen: "What does Stefan do?"

OPTION 1: "Call Dr. Haynes" → SCENE_C4 OPTION 2: "Go to Colin's flat" → SCENE_D1 OPTION 3 (only if: viewer chose "take the pills" in SCENE_A2): "Take more pills" → SCENE_E2

---

This format is more annotated than traditional scripts. It has to be—because the production team needs to understand not just what happens but when each thing happens based on prior choices.

---

The Flowchart: Your Second Script

No interactive fiction project survives without a flowchart. The flowchart is a visual map of the entire experience—every scene, every choice, every path.

Software tools help: Twine (free, designed for interactive fiction), Miro or Figma (for visual mapping), dedicated interactive video platforms (Eko, Branch). But even paper works for small projects.

The flowchart shows:

• All scenes as nodes
• All choices as branching points
• All paths as lines connecting nodes
• All conditions annotated on paths (e.g., "only if X was chosen")
• All endpoints clearly marked

Without the flowchart, the script is unreadable. With the flowchart, the team can see the whole structure—and the writer can identify problems.

Common problems the flowchart reveals:

• Dead ends: Paths that lead nowhere
• Orphan scenes: Scenes that can't be reached from any path
• Convergence failures: Scenes that should feel continuous but require contradictory prior choices
• Exponential explosion: Too many branches creating an unproduceable number of scenes

---

Prompt: Dark Mode Technical Sketch, a narrative flowchart with clear branch points, convergence nodes, and multiple endpoints labeled, thin white lines, black background, minimalist, no 3D renders --ar 16:9

Three Structural Strategies: Containing the Complexity

Interactive scripts can theoretically branch infinitely—but production can't. Every branch means more content to write, shoot, and edit. The math gets ugly fast: two choices with two options each means four paths. Five choices means thirty-two paths.

Writers use structural strategies to contain the explosion:

Strategy 1: The Bottleneck

Branches diverge, then converge at bottleneck scenes. Whatever the viewer chose, they end up in the same place—but the experience of arriving felt different.

Example: Stefan can call Dr. Haynes or go to Colin's flat. Both choices lead to the same next scene (Stefan at the studio), but with different emotional contexts.

Bottleneck benefits: Fewer total scenes. Easier to track. Still feels meaningful.

Bottleneck risks: If the viewer notices the convergence, it can feel like choices don't matter.

---

Strategy 2: The Diamond

The story opens linear, branches into multiple paths at a key choice, then converges for a shared finale—but the finale varies based on which path was taken.

Example: Stefan takes path A or path B through Act Two. Both lead to the same final scene, but the dialogue and ending differ based on which path.

Diamond benefits: Limited branching but meaningful variation. Endings feel personalized.

Diamond risks: The middle paths must feel distinct enough to justify the structure.

---

Strategy 3: The Garden

The story is loosely structured, with many small loops and dead ends. The viewer explores, discovering content in any order. There may be a "true" ending, but reaching it requires specific choices.

Example: The experience is thirty minutes, but there's ninety minutes of content. Viewers see different thirds depending on their choices.

Garden benefits: High replay value. Feels exploratory and open.

Garden risks: Hard to write coherently. Viewers may feel lost or frustrated.

---

A Table: Choice Types and Their Functions

Choice Type	What It Does	Use When
Cosmetic	Changes minor details; no narrative impact	You want the viewer to feel involved without adding branches
Thematic	Reveals character but leads to same outcome	You're exploring character rather than plot
Branch	Creates genuinely different paths	The divergence matters narratively
Loop	Returns the viewer to a previous point	You want to allow do-overs or emphasize inevitability
Gate	Unlocks future choices based on past behavior	You're tracking viewer "state" across the experience
Endpoint	Ends the experience	You've reached a conclusive narrative moment

Mixing these choice types keeps the experience varied without requiring endless content.

---

The "Trench Warfare" Section: What Goes Wrong

Failure Mode #1: Illusion of Choice Is Too Obvious

The viewer makes a choice, but nothing visibly changes. The next scene is the same regardless. They feel cheated.

How to Fix It: Even if paths converge, make the choice feel meaningful. Different dialogue, different framing, different character reactions. The viewer should sense that their choice mattered, even if the destination is the same.

Failure Mode #2: Exponential Explosion

The script has so many branches that the word count triples, the shoot budget explodes, and the project is unproduceable.

How to Fix It: Use bottlenecks and convergence aggressively. Design the structure before writing scenes. Limit meaningful branches to three to five per experience.

Failure Mode #3: Incoherent Arrivals

A scene can be reached from two different paths—but the scene assumes the viewer knows something only one path reveals. The result is confusion.

How to Fix It: Review every scene for path independence. If a scene requires prior knowledge, either gate it (only reachable from certain paths) or write conditional dialogue that adjusts.

Failure Mode #4: Arbitrary Endings

The viewer makes a choice, and suddenly the experience ends. The ending doesn't feel earned—it feels like they hit a wall.

How to Fix It: Every ending should feel like a culmination, not an interruption. Even "bad" endings should be narratively complete. The viewer should think: "My choices led here. This makes sense."

Failure Mode #5: Linear Disguised as Interactive

The script branches, but every branch leads to the same ending. The interactivity is a veneer over a linear story.

How to Fix It: If you're making interactive fiction, commit. At least one major choice should produce genuinely different outcomes. Otherwise, just make a linear film.

---

Prompt: Dark Mode Technical Sketch, screenplay pages with conditional entry markers and IF/THEN notations, showing how scenes adapt to prior choices, thin white lines, black background, minimalist, no 3D renders --ar 16:9

Writing for Interactivity: Craft Considerations

Interactive fiction requires all the skills of traditional screenwriting—character, dialogue, structure—plus new ones:

Modularity. Scenes must function as independent units. You can't assume the viewer saw the previous scene, because there might be three "previous scenes" depending on the path.

State awareness. You're tracking what the viewer has done. If they made a certain choice in Act One, Act Three might reference it. This requires careful bookkeeping.

Emotional consistency. Even if the plot diverges, the emotional journey should feel coherent. The viewer shouldn't feel like they're jumping between different movies.

Player (viewer) psychology. What makes choices feel meaningful? Agency. Consequence. Surprise. You're designing an experience, not just telling a story.

Replayability. Will viewers return to see other paths? Design content they'll want to find. Hide easter eggs. Make alternate endings substantively different.

---

Platform-Specific Considerations

Different platforms have different capabilities:

Netflix (Bandersnatch model): Choices appear on screen during playback. The platform handles branching. You deliver a branching script and video segments; the platform assembles.

YouTube (choose-your-own adventure style): Choices are clickable links at the end of videos. Each branch is a separate video. Less seamless, but no special platform support required.

Game engines (Unity, Unreal): Full interactivity including dialogue trees, stat tracking, and complex branching. Scripts often use specialized tools like Ink, Yarn Spinner, or Twine.

Interactive video platforms (Eko, Wirewax): Designed specifically for branching video. They have proprietary formats and editors.

Your formatting may need to adapt to the platform's requirements. Always confirm technical specs before writing.

---

The Perspective: Interactivity Is Story, Not Gimmick

The danger with interactive fiction is treating interactivity as the point. It's not. Story is still the point. Interactivity is a tool—a way to make the audience feel implicated in the narrative, to explore themes of choice and consequence, to create an experience that lingers because the viewer feels responsible.

Bandersnatch works because it's about control—and the choices the viewer makes reflect the theme. The interactivity isn't decorative; it's meaningful.

When you design interactive fiction, ask: Why is this interactive? What does the audience's participation add? If the answer is just "it's cool," the project will feel hollow. If the answer connects to theme—to what the story is about—the interactivity becomes part of the storytelling.

The best interactive fiction makes you think about your choices long after you've stopped clicking.

[YOUTUBE VIDEO: A deep dive into the narrative design of Black Mirror: Bandersnatch, analyzing how the writers structured branches, handled convergence, and made choices feel meaningful.]

---

Further reading:

• For guidance on creating alternate endings in non-interactive formats, see creating alternate endings: narrative branching in a psychological thriller.
• If you're working in games, explore writing video games: branching narratives.
• Twine, a free tool for interactive fiction, has documentation at twinery.org{:rel="nofollow"}.