Skrib

Cutscene Scripts vs. In-Engine Dialogue Formats | Skrib

Six content types, not two. When screenplay format is correct, what a dialogue table needs, string IDs, source of truth and what breaks on export.

George Sermon•Nov 7, 2026•9 min read
Cover image for “Cutscene Scripts vs. In-Engine Dialogue Formats | Skrib” on the Skrib blog

New game writers ask what format a game script uses, and get a confident answer that turns out to be wrong at their studio.

The confusion is reasonable, because the question assumes something that isn’t true of the medium.

In film, one document serves everyone. The screenplay goes to the director, the actors, the crew, the budget, the schedule. One format, one artefact, one source of truth.

In games, no single document does that. A cinematic goes to a director and a cinematics team. A conversation goes to an engineer, a VO director, a localisation vendor and QA - and each of them needs different information about the same line.

Which means format isn’t determined by what the content is. Format follows the consumer. Ask who reads this and what decision they make from it, and the shape falls out.

Our video game writer’s handbook covers where this fits in the wider craft.

Six content types, not two

The cutscene-versus-in-engine split in the title is the common shorthand and it’s too coarse to work from. In practice there are at least six, and each sits differently on the same spectrum.

Read the middle column. Format tracks how much of the moment is authored versus generated. Fully authored linear content can use a document. Anything conditional needs a schema, because a document can’t express a condition.

The scripted in-game sequence is the awkward one - the player is walking while two characters talk, the conversation can be interrupted, and it needs both prose and trigger data. Most studios handle it badly, and it’s worth agreeing a shape for it early.

When screenplay format is correct

Rarely, and specifically.

Use it for linear pre-rendered or in-engine cinematics with a director, a fixed camera plan and no player input. That’s genuine film production and the conventions exist because they work - our spec script formatting guide covers the layout, and there’s no reason to invent a different one.

Two adjustments games require:

  • Add a shot or beat ID to every unit, so audio, cinematics and QA can reference the same moment.

  • Note engine constraints inline - whether a location exists, whether a character has that animation, whether the camera can physically be where the page implies.

Where screenplay format actively fails: anything conditional. The moment a line only plays if a flag is set, prose stops being able to hold the information, and writers who force it end up with parenthetical conditions nobody downstream can parse reliably.

What a dialogue table actually needs

The practical payload, and the thing almost nobody publishes.

Two columns get skipped and shouldn’t be. Addressee costs nothing and prevents a whole category of translation error - the specifics are in localization-friendly writing. Status is what stops a recorded line being quietly edited after a voice session, which is the most expensive small mistake in the discipline.

Direction should be brief and playable. A short intent an actor can act on, not a paragraph of interiority. The same principle applies here as in any script: describe what the character is doing, not what they’re feeling.

String IDs

The most consequential decision in this article, usually made carelessly in week two and lived with for four years.

A good ID is self-describing and sorts usefully:

DLG_MARA_ACT2_BETRAY_03
BRK_GUARD_SPOT_07
UI_INVENTORY_FULL
CIN_OPENING_SHOT12_LINE04

What makes them work:

  • A type prefix - DLG, BRK, UI, CIN - so filtering by content type is trivial

  • Speaker or system next, so an actor’s lines group together when sorted

  • Structural position, so IDs cluster by scene or system

  • A number with leading zeros, so 10 doesn’t sort before 2

  • No spaces, no punctuation, uppercase - they will end up in code

What breaks them:

  • IDs encoding the line’s content. DLG_MARA_I_TRUSTED_YOU becomes a lie the moment the line is rewritten, and lines are always rewritten.

  • Renumbering. Once an ID has been recorded against or referenced in a bug, it’s permanent. Insert _03B rather than shifting everything.

  • Inconsistent depth. Some IDs with four segments and some with seven makes bulk operations painful.

What each department needs

The same line, five different requirements.

Engineering wants unique stable IDs, unambiguous conditions and a schema that doesn’t change shape mid-project. Adding a column is fine; renaming one breaks tooling.

Audio and VO want speaker, direction, pronunciation for invented words, and - critically - grouping by character rather than by scene.

Cinematics want action, camera intent, who is on screen and rough timing.

Localisation wants context, character limits and do-not-translate terms attached to the row, not filed elsewhere.

QA wants IDs they can put in a bug report and a status column telling them whether a line is final.

The point of listing these: a single export can’t satisfy all five, and pretending otherwise is why studios end up with four divergent copies of the same script.

The VO session problem

An operational constraint that reorders your whole document, and one writers routinely discover too late.

Voice actors are booked by the hour, and they record all of their lines at once - across scenes, across acts, across the whole game, out of context.

What this means for the writer:

  • Export by character, not by scene. Your beautifully sequenced script is the wrong shape for the session.

  • Supply context per line, because the actor has none. What just happened, who they’re talking to, what they want.

  • Group emotionally where you can. Recording twelve rage lines then twelve grief lines is kinder and faster than alternating.

  • Flag pickups. Lines added after a session cost a new booking, so late additions get scrutinised or cut.

  • Provide pronunciation for every invented name, and do it before the session rather than during.

Bark pools amplify all of this, since a single trigger can carry twenty variants per character - the sizing consequences are covered in barks and ambient dialogue.

Source of truth

The most common structural failure in game narrative production, and it’s not a formatting problem exactly.

Whatever the engine reads is the truth. If dialogue is loaded from a database and you’re maintaining a document alongside it, the document is already stale - and everyone downstream will eventually be working from a different version than the build.

Three workable arrangements:

Database-first. The tool is authoritative; documents are exports. Cleanest, and least comfortable for writers who want to draft in prose.

Document-first with export. Writing happens in documents, a defined process pushes to the database. Workable if the export is automated and one-directional.

Two-way sync. Attractive, fragile, and prone to conflicts nobody notices until QA.

What doesn’t work is an informal arrangement where the writer keeps a doc, an engineer keeps the table, and both get edited. That produces the specific bug where a line is fixed twice and reverted once.

Agree it in week one, and write it down.

What breaks in export

Small, avoidable, and constant.

  • Commas and quotes in a line, in a CSV pipeline

  • Line breaks inside a cell

  • Smart quotes and em dashes that survive a spreadsheet and not an engine’s font

  • Trailing whitespace, which becomes a visible gap

  • Non-breaking characters pasted in from a word processor

  • Formatting - bold, italics, colour - that carries no meaning past the export

  • Duplicate IDs from copy-pasted rows, which fail silently and overwrite

A useful habit: draft anywhere, but paste through plain text before it reaches the pipeline.

Where it goes wrong

One format for everything. Screenplay format used for conditional content, or a spreadsheet used for a cinematic.

IDs encoding content. Renamed, then lying.

Renumbering after recording. Every existing reference broken.

Exporting by scene for VO. An actor’s day spent context-switching.

No status column. Recorded lines edited quietly.

Diverging copies. Document and database both live.

Direction as interiority. Paragraphs an actor can’t play.

Schema churn. Columns renamed mid-project, tooling broken.

Drafting before the pipeline

Game text ends up in tables, and tables are a poor place to write. Most writers draft somewhere comfortable and paste in, which is fine - the problems start when the comfortable place has no relationship to the structure, so the map lives in one tool, the prose in another and the IDs in a third.

Skrib sits at that seam. Dialogue and string tables move in and out as .csv and .xlsx, matching how this material actually travels, and the Plan is a canvas with no page edge where the structure - nodes, conditions, which scene a string belongs to - can sit beside the lines you’re drafting. The Draft handles linear cinematic writing with screen formatting held steady, and exports to .fdx or .fountain when a cinematic goes to a vendor working in film tools. The Library keeps every version searchable.

Scope note: Skrib is not your pipeline. It doesn’t own string IDs, validate schemas, sync with an engine or serve as the source of truth. Whatever your engine reads is authoritative; this is the layer before it. You can start free.

Frequently asked questions

What format do game scripts use? There isn’t one. Format is determined by which department consumes the content - linear cinematics use screenplay format, conditional dialogue lives in a database or table, and UI text sits in a string table with character limits. The same line often exists in several shapes.

When should you use screenplay format for a game? For linear pre-rendered or in-engine cinematics with a director and no player input, with two additions: a shot or beat ID on every unit, and inline notes on engine constraints. It fails as soon as content becomes conditional, because prose can’t hold a condition reliably.

What columns does a game dialogue table need? At minimum: string ID, speaker, line, condition, VO requirement and status. Addressee, emotional direction, character limit and localisation context prevent most avoidable downstream errors and cost very little to include.

How should you name string IDs? Self-describing and sortable - a type prefix, then speaker or system, then structural position, then a zero-padded number. Never encode the line’s content, because the line will be rewritten and the ID will become misleading.

Why does VO recording change how a script is organised? Actors are booked by the hour and record all their lines at once, out of context and across the whole game. That means exporting by character rather than by scene, and supplying per-line context, since the actor has none.

Should the script or the database be the source of truth? Whatever the engine reads. If dialogue loads from a database and a separate document is being maintained alongside it, the document is already stale - and the arrangement needs to be agreed and written down in the first week, not assumed.

Share
GS
Written by
George Sermon is a screenwriter who co-founded Skrib, a writing studio for serious writers. He built the tool he wanted while writing a Gold Rush screenplay, then shaped it with feedback from its first 25 users, who were all professional screenwriters.

Start writing with Skrib - free

Draft, outline, and revise your novel or screenplay in one calm workspace. No credit card, no clutter.

Create your studio →
Keep reading