About this guide

This guide is for writers. It says how to install Cold Open, write a first scene, and use each feature, in the order you’re likely to meet them.

• New to Cold Open? Start with Install, then Getting started.
• New to Fountain? A Fountain primer takes five minutes.
• Working with a production? See .fdx exchange, Track changes, Production revisions and Compare drafts.
• Worried about losing work? Your work is safe explains the crash journal.
• Using an AI agent? See AI agents.
• Looking for a key or a command? The keyboard, command-line and command references list every one. They’re made from Cold Open’s own code, so they match the version they came with.

Two things are worth knowing from the start:

• The command palette (Ctrl+K, or Cmd+K on a Mac) lists everything Cold Open can do, with its keys. If you can’t find something, type a word of it there.
• This is an alpha. Known limitations lists what isn’t there yet. Keep copies of scripts that matter.

In this guide, Mod means Ctrl on Windows and Linux, and Cmd on a Mac. So Mod+S is Ctrl+S or Cmd+S.

Install

Download the file for your computer from the download page. Every download is under 15 MB. Cold Open needs no account and no internet connection, before or after you install it.

What it runs on:

• Windows 10 or 11, on x64 or ARM;
• macOS 12 or later, on an Apple chip or Intel;
• Linux on x86-64 or ARM64, with Wayland or X11, and glibc 2.35 or newer (Ubuntu 22.04, Debian 12, Fedora 36 and later).

The builds aren’t signed by Microsoft or notarized by Apple yet (why), so the first start shows a warning. Here’s what to do on each system.

Windows

1. Run ColdOpen-…-windows-x64-setup.exe (or arm64 on Windows on ARM).
2. If SmartScreen says “Windows protected your PC”, click More info, then Run anyway. It shows for programs that aren’t signed yet, not because something is wrong.
3. The installer needs no administrator rights. It installs for you alone, in %LOCALAPPDATA%\Programs\Cold Open, and adds a Start menu entry.

It also:

• puts the command-line tool coldopen on your PATH (a box you can untick). Open a new terminal to use it;
• offers Cold Open in Open with for .fountain and .fdx files, and opens .coldopen projects. Windows lets only you choose the default app for a type: right-click a file ▸ Open with ▸ Choose another app.

Without installing: unzip ColdOpen-…-windows-x64.zip anywhere and run Cold Open.exe. coldopen.exe is beside it.

Upgrading: run the new installer. If Cold Open is open, it asks to close it first. Nothing you typed is lost: it’s all in the crash journal, and the next start brings it back.

Uninstalling: Settings ▸ Apps ▸ Cold Open ▸ Uninstall. Your scripts and settings are left alone.

macOS

1. Open the .dmg and drag Cold Open to Applications.

2. Open Cold Open. The first time, macOS refuses, because the app isn’t notarized.

3. Open System Settings ▸ Privacy & Security, scroll down to the message about Cold Open, and click Open Anyway. Then open Cold Open again and confirm.

   On macOS 12 to 14 you can instead Control-click the app in Applications and choose Open.

4. If macOS says the app is damaged, it’s the quarantine flag on an unnotarized download. Run this in Terminal, then open it again:

   xattr -dr com.apple.quarantine "/Applications/Cold Open.app"
   

The command-line tool: in Cold Open, open the palette (Cmd+K) and choose Install the command-line tool. It puts a coldopen link in /usr/local/bin, or in ~/.local/bin when that’s the one you can write, and says which. It never asks for your password.

A known issue: double-clicking a script in Finder starts Cold Open but doesn’t open the script yet. Use Open (Cmd+O) in the app.

Uninstalling: drag Cold Open from Applications to the Trash.

Linux

Pick one of the three packages.

.deb (Debian, Ubuntu, Mint, Pop!_OS):

sudo apt install ./cold-open_*_amd64.deb

This puts coldopen-app and coldopen in /usr/bin, with a menu entry and file types. Remove it with sudo apt remove cold-open.

AppImage (any distribution):

chmod +x ColdOpen-*-x86_64.AppImage
./ColdOpen-*-x86_64.AppImage

The command-line tool is inside: ./ColdOpen-*.AppImage cli --help, or make a link named coldopen to the AppImage. An AppImage doesn’t add a menu entry by itself; a tool such as AppImageLauncher can. To remove it, delete the file.

Flatpak (any distribution with Flatpak):

flatpak install --user ColdOpen-*-x86_64.flatpak
flatpak run io.github.theyungstump.coldopen

• It runs on the freedesktop 25.08 runtime. If Flatpak can’t find it, add Flathub first: flatpak remote-add --user --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo.
• The Flatpak can open scripts in your home folder. For another drive, run flatpak override --user --filesystem=/path/to/drive io.github.theyungstump.coldopen.
• The command-line tool is flatpak run --command=coldopen io.github.theyungstump.coldopen. You can add alias coldopen='flatpak run --command=coldopen io.github.theyungstump.coldopen' to your shell’s startup file.
• Remove it with flatpak uninstall io.github.theyungstump.coldopen.

On ARM64, the files say arm64 or aarch64 in place of amd64 and x86_64.

Check a download

Each release has SHA256SUMS.txt, which lists every file’s SHA-256 checksum. A file that matches is exactly the one the release built. Put the checksum file beside your download, then:

• Linux: sha256sum -c SHA256SUMS.txt --ignore-missing
• macOS: shasum -a 256 -c SHA256SUMS.txt --ignore-missing
• Windows (PowerShell): Get-FileHash .\ColdOpen-…-setup.exe, then compare the hash it prints with that file’s line in SHA256SUMS.txt.

“OK” (or matching hashes) means the download is good. Anything else: download it again, and if it still doesn’t match, please tell us.

Where Cold Open keeps things

Uninstalling never touches these:

• Settings (settings.json, keymap.json, flow.json): %APPDATA%\Cold Open on Windows, ~/Library/Application Support/Cold Open on macOS, ~/.config/coldopen on Linux.
• Untitled scripts, crash reports, the usage summary and other app data: %LOCALAPPDATA%\Cold Open on Windows, the same folder as the settings on macOS, ~/.local/share/coldopen on Linux.
• Each script’s crash journal sits beside the script while it’s open (see Recovery).

Getting started

The window

Cold Open starts on a new script, with the caret on an empty scene heading. Everything you type is saved to a crash journal as you type it, so an untitled script is safe even before you save it.

A first scene

Type this, pressing the keys shown in brackets:

1. int. lighthouse - night [Enter]. Scene headings come out in capitals. As you type, Cold Open offers INT., places you’ve used and times of day: Tab or Enter takes a suggestion.
2. The lamp turns. Waves break below. [Enter] [Tab]. Enter after action gives more action; Tab turns it into a character.
3. nora [Enter]. Character names come out in capitals, and Enter goes to dialogue.
4. Still turning. Still here. [Enter]. Enter after dialogue goes to the next character.
5. eli [Enter] [Tab] from below [Enter]. Tab in dialogue makes a parenthetical, with its brackets added for you. Enter goes back to dialogue.
6. Come down, Nora. [Enter] [Enter]. Enter on an empty character goes to action.

You’ve written a scene. Press Mod+S to save it: an untitled script asks where, and the name’s extension picks the format (.fountain unless you choose another).

The element flow

Enter and Tab always do what the hint bar says. Here is the whole table:

A few things happen by themselves, and one undo (Mod+Z) takes each back:

• Typing INT., EXT., I/E and the like at the start of an empty action makes it a scene heading.
• Typing ( in an empty dialogue makes it a parenthetical.
• An action in capitals that ends in TO: becomes a transition when you press Enter.

Mod+1 to Mod+8 set the element directly: 1 scene heading, 2 action, 3 character, 4 parenthetical, 5 dialogue, 6 transition, 7 shot, 8 general.

Shift+Enter starts a new line inside action or dialogue, without starting a new element.

Autocomplete

While you type, a short list offers what fits:

• character names you’ve used, the ones in the current scene first;
• extensions after a ( in a character: V.O., O.S., O.C., CONT'D and any you’ve used;
• scene prefixes (INT., EXT., INT./EXT., EST., I/E.), places you’ve used, and times of day after -;
• transitions: CUT TO:, DISSOLVE TO: and the ones you’ve used.

Up and Down choose, Tab or Enter takes it, and Esc closes the list.

Moving around

Shift with any of these selects. A double click selects a word, a triple click an element.

The navigator lists every scene with its number, page and length in eighths of a page. Click a scene to go to it. Drag a scene to move it, or select it and press Alt+Up or Alt+Down. Mod+\ shows or hides the navigator, and F6 moves the keyboard between the navigator, the page and any open panel.

Find and replace: Mod+F finds, and Mod+H (Mac: Cmd+Option+F) finds and replaces. Enter, F3 or Mod+G goes to the next match. “This scene only” limits it to one scene. Replace all is one undo step.

The palette, and everything else

Mod+K opens the command palette. It lists every action, with its keys, and your recent files. Type a few letters of what you want: “pdf”, “reports”, “dark”. The keyboard reference lists everything it holds.

Views

• Page view shows the pages as they print. Draft view (Mod+Shift+D) is one long column with no page breaks, which also shows sections and synopses as grey lines.
• Zoom: Mod+= and Mod+- (Mod+0 for 100%). A page always fits the window’s width.
• Interface size: if the text in dialogs and panels is too small, “Make the interface larger” in the palette makes the whole window bigger, up to 200%. “Make the interface smaller” and “Interface at normal size” take it back.
• Focus mode (Mod+Shift+F) hides everything but the page.
• Themes: light, dark and high contrast, in the palette. The default follows your system.
• The renderer: Cold Open draws with the CPU on Windows and Linux, and with the GPU on macOS. The GPU is smoother on 4K and Retina screens; the CPU uses less memory. “Draw with the GPU” and “Draw with the CPU” in the palette switch, from the next start.

Your own keys

keymap.json in the settings folder (see Install) changes any shortcut. It holds only your changes, and Cold Open never rewrites it, so an upgrade never undoes them:

{"v": 1, "bindings": [
  {"keys": "Mod+Shift+K", "action": "app.palette"},
  {"keys": "Mod+1", "action": null}
]}

null removes a shortcut. The action names are in the keyboard reference. Keys are written with Mod, Ctrl, Alt, Shift and Super (Cmd on a Mac), then a letter, digit, F1–F24, a named key such as Enter or PageUp, or one punctuation character. A mistake in the file is listed in a notice when Cold Open starts, and never stops it starting.

flow.json changes the element flow the same way:

{"v": 1, "kinds": {"dialogue": {"enter": "action"}, "action": {"tab": "transition"}}}

The fields are enter, empty_enter, tab and shift_tab.

Saving

• Mod+S saves in the background, so typing never waits for it.
• Save as (Mod+Shift+S) saves under another name, and converts when the extension is another format.
• A script saves back to the format it came in. If you used something that format can’t hold (tracked changes in a Fountain file, say), Cold Open asks before saving, and offers a Cold Open project, which keeps everything. See Files.
• Closing with unsaved changes asks first.

A Fountain primer

Fountain is a plain-text way to write a screenplay. A Fountain file reads like a script in any text editor, and Cold Open lays it out as a script. It’s Cold Open’s own format, so you never need to know it: Cold Open writes it for you. But it’s simple, and knowing it helps when you open a script in another program, paste text in, or ask an AI agent to write.

This is a short tour. The Fountain syntax page has the whole of it, and Cold Open follows all of it.

The elements

INT. LIGHTHOUSE - NIGHT

The lamp turns. Waves break below.

NORA
Still turning. Still here.

ELI
(from below)
Come down, Nora.

CUT TO:

• A scene heading is a line that starts with INT., EXT., EST., INT./EXT. or I/E, with a blank line before it. Start any line with . to make it one anyway: .FLASHBACK. A number between # signs at the end is its scene number: INT. HOUSE - DAY #12A#.
• Action is any ordinary paragraph.
• A character is a line in capitals with a blank line before it and text right after it. That text is the dialogue. A line in brackets inside a speech is a parenthetical. Start a name with @ to use lower case: @McCLANE.
• A transition is a line in capitals ending in TO:, or any line starting with >.
• Centered text goes between > and <: > THE END <.
• Dual dialogue: put ^ after the second character’s name, and the two speeches print side by side.
• Lyrics start with ~.
• A page break is a line of three or more =.

Emphasis

*italic*, **bold**, ***bold italic*** and _underline_. A backslash before a star or underscore prints it as it is: \*.

What doesn’t print

• Notes: [[like this]], anywhere, even inside a line.
• Boneyard, for cut material: /* to */, over as many lines as you like.
• Sections, for acts and sequences: lines starting with #, ## and so on.
• Synopses: lines starting with =.

Cold Open keeps all of these, shows them in the margin, and never prints them.

The title page

A Fountain file can begin with Key: value lines:

Title: The Lighthouse Keeper
Credit: Written by
Author: Jo Lee
Draft date: 2 November 2026
Contact:
    jo@example.com

A blank line ends the title page. In Cold Open, Edit title page… (Mod+Shift+T) edits it: see The title page.

Why Fountain

• It’s yours. Any text editor on any computer reads it, today and in fifty years.
• It works with version control. Git and similar tools show exactly which lines changed between drafts.
• AI agents read it well. It’s plain text that looks like a script.

What Fountain can’t hold, such as tracked changes or revision marks, a Cold Open project keeps.

Files: Fountain, .fdx and projects

Cold Open opens and saves three kinds of script file. It saves a script back to the kind it came in, unless you choose another with Save as.

When to use which:

• Writing on your own: Fountain. It’s readable anywhere and never locked in.
• A production sent you an .fdx: keep it as .fdx, so they get back the format they sent. See .fdx exchange.
• Tracking changes, or production revisions: a project. Save as Cold Open project… in the palette. You can always save a copy as Fountain or .fdx to send out.

When a format can’t hold something

Cold Open never drops anything without asking. If you save to a format that can’t hold part of your script, it says what would be lost before writing anything, and offers three choices:

• Save as Cold Open project… keeps everything. It’s the default when tracked changes or revision marks would be lost.
• Save anyway writes the file without what it can’t hold. Tracked changes are accepted first, and revision marks taken out, and the version with them is kept in Recovered versions.
• Cancel.

Save a copy as .fdx and Save a copy as Fountain (palette) write a copy in that format and leave the script you’re working on as it is.

Opening

• Mod+O opens .fountain, .spmd, .txt, .fdx and .coldopen files.
• Recent files are on the start screen and in the palette. A file that’s gone (on an unplugged drive, say) stays in the list, marked Missing, until you remove it.
• A script in a folder Cold Open can’t write (a read-only share, or a CD) opens as an untitled copy, with a notice. Save as… keeps it somewhere else, and the original is never touched.

Inside a project

A .coldopen file is an ordinary zip. Inside are script.fountain (a readable copy of the script), document.json (the script with every element’s id), changes.json (tracked changes), revisions.json (revision sets) and meta.json. Its format is open and documented in the bundle spec, so other tools can read it, and the same script always saves to the same bytes.

.fdx exchange and repair

Most productions send scripts as .fdx files, the format Final Draft uses. Cold Open opens them, lets you edit them, and saves them back so the people who sent them get the format they expect.

What comes back as it went

• Everything you didn’t edit is written back exactly as it was, down to the byte. A file opened and saved with no edits is identical to the original.
• What Cold Open doesn’t use passes through untouched: another app’s settings, page setup, and anything else in the file that Cold Open doesn’t model.
• What you did edit is written in the same style as the rest of the file.
• The pages: Cold Open lays out an .fdx with its own page settings, so its page count matches the file’s own closely. We measure it against reference scripts, and on a 120-page feature it matches page for page.

What .fdx can’t carry from Cold Open

Some things Cold Open holds have no public description of how .fdx stores them. Cold Open won’t guess at a format, so these aren’t written to .fdx. It asks before saving, and a project keeps all of them:

• Notes, boneyard, sections and synopses are left out.
• Tracked changes are written accepted: the file holds the script as it would be with every change accepted.
• Revision sets and marks are left out. A Revisions list the file already had passes through untouched.
• A Fountain title page’s key names become plain lines.

A damaged file

A damaged .fdx still opens. Cold Open repairs what it can: broken XML, a wrong encoding, characters XML doesn’t allow, settings out of range. Then it says what it fixed:

• “Cold Open repaired this file” gives the counts and the first few problems, in plain words and without your script’s text.
• Details (D) shows the whole report.
• Save repaired copy… (S) saves the repaired script under a new name.
• OK carries on with the repaired script. Nothing is written until you save.

The first save over a damaged file keeps a hidden copy of it as it was, which you’ll find in Recovered versions.

Repair an .fdx file (palette) repairs an .fdx into a new file without opening it, and shows the same report. So does the command line:

coldopen repair damaged.fdx repaired.fdx

The input is never written. Add --json for a report a program can read. It holds codes and positions only, never script text, so it’s safe to share when you report a file problem.

You can use this even if you write in another app. coldopen repair doesn’t change your file, and a repaired copy opens anywhere .fdx does.

Converting

• Save as with an .fdx name converts a Fountain script to .fdx, and the other way round. What the target can’t hold is listed first, as above.
• coldopen convert draft.fdx draft.fountain does the same from the command line, and refuses a lossy conversion unless you add --allow-lossy.

Track changes and agents’ edits

Track changes records what each person inserts and deletes, and when, so you can accept or reject each change. Deleted text isn’t gone: it stays on the page, struck through, until someone settles it.

It’s separate from production revisions, which mark what changed between drafts a production has sent out.

Tracking your own changes

Track my changes (palette, or click the hint bar’s text) turns tracking of your edits on or off. While it’s on, the hint bar says “Tracking your changes”.

The first time, Cold Open asks what name your changes should carry (“Writer” until you choose). Change my name… in the changes panel, or “Change my name for changes…” in the palette, changes it later.

What you see:

• Insertions in their author’s color, deletions struck through in that color. Each author gets their own, in the order they first appear.
• A thin bar in the margin beside every changed line.
• A label in the margin for changes to whole elements: “New”, “Deleted”, “Was Action” for an element whose type changed, “Split”, “Joined”, and “Moved” on a scene that moved.
• A dot in the navigator beside each scene with changes.
• “N to review” in the status bar.

Accepting and rejecting

Each is one undo step: Mod+Z gives the change back.

The changes panel

Mod+Shift+R opens the panel beside the pages. It lists every pending change in script order, with who made it, when, what it does, which scene it’s in, and a short excerpt.

• Click a change, or choose it with Up and Down and press Enter, to go to it.
• A accepts it and R rejects it, then the next is chosen.
• Filter by author with the list at the top.
• Esc gives the keyboard back to the page.

Agents’ edits

When an AI agent edits your script through Cold Open’s agent server, its edits are tracked changes under the agent’s name, by default. You review them like notes from a collaborator: accept what you like, reject the rest.

• An agent can withdraw its own changes, but it can never accept a change, or reject anyone else’s.
• Track agent edits (palette) turns this off for the script you’re in. Then agents’ edits go straight in, marked with a violet bar until you dismiss the marks.

Saving changes

• A project keeps every change, with its author and time.
• Fountain and .fdx can’t hold tracked changes. Saving one with changes pending asks first, and offers a project. Save anyway accepts every pending change, then saves, and keeps the version with the changes marked in Recovered versions.
• A PDF prints the changes marked, in their authors’ colors. “Print the current text” in the export form prints them accepted.

Bringing in someone else’s draft

A collaborator sent a whole new draft rather than tracked changes? Review a draft as changes… (palette) brings it in as tracked changes against your script, under the name you give. See Compare drafts.

Production revisions

Once a script is in production, each new round of changes is a revision set with its own color: Blue pages, then Pink, then Yellow. Everyone can see what changed since the last pages they were given. Cold Open marks revised lines with * in the margin and prints each revised page with its set’s name and date in the header.

This is different from track changes: track changes is for reviewing edits before they’re accepted; revision sets record what changed between drafts that went out.

Starting a set

Start revision… (palette) asks for:

• the color: the next one in the list, which you can change with Up and Down, or by typing any name;
• the label: “Blue Rev.” to begin with, following the color until you edit it;
• the date: today’s, as YYYY-MM-DD.

Enter starts it. From then on, everything you change is marked with the set’s color, and the hint bar shows the active set (“Blue Rev. 10/22/26”). Click it for the revision commands.

End revision (palette) stops marking. Starting a set while one is active asks to end that one first.

The colors

The usual order is White, Blue, Pink, Yellow, Green, Goldenrod, then Buff, Salmon, Cherry, then the same nine again as “Double Blue” and so on. Productions vary it, so Revision colors… (palette) lets you edit the list, as names between commas.

What you see

• Revised text in its set’s color on screen, and a * in the right margin of every revised line, exactly as the PDF prints them.
• Each revised page’s header: the set’s label and date.
• A * after the heading of each scene with revisions, in the navigator.

Clearing marks

Clear revision marks… (palette) clears one set’s marks, or every set’s. The sets stay in the list. It’s one undo step.

Saving and printing

• A project keeps the sets and marks.
• Fountain and .fdx can’t hold them. Saving asks first, with a project as the default. Save anyway takes them out and keeps the marked version in Recovered versions.
• PDF export prints the marks and the revised pages’ headers. Colored pages (Mod+4 in the export form) prints each revised page on its set’s color.

Not yet

Locked pages, A and B pages (12A, 12B), and locked scene numbers aren’t in the alpha. See Known limitations.

Compare drafts

Cold Open compares two drafts scene by scene. It finds scenes that moved, as well as text added, deleted and changed, and works across formats: compare a Fountain draft with an .fdx one, or with a project.

Compare with…

Compare with… (palette) asks for another draft, then compares your script as it is now (A) with it (B).

The view shows B’s pages with the changes marked, and a list of the changed scenes in place of the navigator:

• Up and Down choose a scene, and Enter scrolls to it.
• Save as PDF… (Mod+Shift+E) writes the marked pages as a PDF, to send to someone.
• Esc closes the view.

Your script isn’t changed, and you can’t type into the view. A long script is compared in the background: you can keep working, and Esc stops waiting.

Changes of style or of an element’s settings (bold, centering, extra blank lines) show in the list of changed scenes, but not on the pages.

Review a draft as changes

Someone sent back a whole draft instead of tracked changes? Review a draft as changes… (palette) brings the draft in as tracked changes against your script, under the name you give (the file’s name to begin with). The changes panel opens, so you can accept or reject each one.

Some things can’t be brought in as tracked changes: styles, notes and boneyard, element settings such as centering and blank lines, and the title page. They’re listed in a notice for you to apply by hand. The draft itself is never changed.

From the command line

coldopen diff draft2.fdx draft3.fountain
coldopen diff draft2.fdx draft3.fdx --pdf changes.pdf
coldopen diff draft2.fdx draft3.fdx --json

It prints a summary of the changed scenes, and with --pdf writes the marked pages. It exits 0 whether or not the drafts differ.

A known quirk

A section that sits just above a scene heading belongs, for comparing, to the scene before it. So moving a section together with the scene under it reads as the section moving between scenes, not as one moved scene. Accepting the changes still gives the right script.

The title page and reports

The title page

Edit title page… (Mod+Shift+T, or the palette) opens a sheet on the right. The page area shows the title page as it prints, and follows what you type.

A Fountain script has a title page of keys:

• Title, Credit, Author, Source, Draft date, Contact, Notes and Copyright are always there, empty or not, followed by any other keys the script has.
• Each field holds its values one per line: Enter starts another line.
• Add a key… adds one by name. Emptying a field removes its key.

An .fdx script has a title page of positioned lines. Each row is one line:

• its text;
• its alignment (Mod+L, Mod+E or Mod+R for left, center and right, or the button that steps through them);
• the space above it, in lines.

Enter in a line’s text adds a line after it, and Mod+Shift+K removes the line.

Moving about: Tab and Shift+Tab move between fields. Each change is one undo step, labelled “Title page”. Mod+Z in the sheet first undoes typing, then whole steps.

Closing: Esc, Done, or a click on the page.

Title page edits are never tracked or revision-marked.

Reports

Reports… (Mod+Shift+I) opens three reports in place of the pages:

• Ctrl+Tab and Ctrl+Shift+Tab change reports.
• Up and Down choose a row, and Enter goes to it in the script: a scene, a character’s first speech, a location’s first scene.
• Copy as CSV (Mod+C) copies the report for a spreadsheet.
• Esc closes the reports.

From the command line:

coldopen report characters draft.fountain
coldopen report scenes draft.fdx --format csv > scenes.csv
coldopen report locations draft.fountain --format json

How counting works:

• A character is counted by their name in capitals, without extensions: Maya, MAYA and MAYA (O.S.) are one character.
• Lines are the printed lines of their dialogue, as you’d count them on the page, including those continued after a page break. Parentheticals don’t count.
• INT. LAB - NIGHT and EXT. LAB - DAY are one location, in two settings.

PDF export

Export a PDF (Mod+Shift+E) opens a short form:

Enter asks where to save it. The PDF is written in the background, so you can keep working; a notice says when it’s done.

What you get

• The same pages everywhere. The PDF is laid out by Cold Open itself, with its bundled Courier Prime font, so it comes out byte for byte the same on Windows, macOS and Linux. What you see on screen is what prints.
• Standard screenplay format: 12-point Courier, about 55 lines a page, with the usual margins and page numbers. Page breaks follow the usual rules: a scene heading never ends a page, a character never leaves their speech behind, and a speech split over a page prints (MORE) at the foot and the name with (CONT'D) at the top of the next.
• Tracked changes print marked, in their authors’ colors, unless you choose “Print the current text”.
• Revisions print with * in the margin, and each revised page’s header names its set and date.
• Notes, boneyard, sections and synopses never print.

A character the font has no shape for (Chinese, Japanese or Korean text, or emoji) prints as a box, and the export says which.

The PDF and everything in it are yours. The font’s license (the SIL Open Font License) doesn’t cover what you print with it.

From the command line

coldopen export draft.fountain draft.pdf
coldopen export draft.fdx review.pdf --watermark "DRAFT" --scene-numbers
coldopen export draft.fountain pages.pdf --no-title-page

coldopen pages draft.fountain prints the pages as plain text, the way they print, which is handy for checking where pages break.

Compare as a PDF: coldopen diff a.fdx b.fdx --pdf changes.pdf, or Save as PDF… in the compare view, prints the second draft with the changes marked. See Compare drafts.

Your work is safe: recovery

Cold Open is built so that a crash, a power cut or a damaged file never costs you more than the last moment of typing.

The crash journal

While a script is open, every key you press is written to a crash journal before it shows on screen, and the journal reaches the disk within a quarter of a second.

• If Cold Open crashes, or is closed from outside (Task Manager, Force Quit), nothing that was on screen is lost.
• If the power goes, you lose at most the last quarter of a second.
• The next time you open the script, Cold Open puts back everything since your last save, and your undo history with it.

The journal is a hidden file next to the script: .lighthouse.fountain.coldopen-journal for lighthouse.fountain. Saving starts it again, and closing a saved script deletes it. If you keep scripts in git, add .*.coldopen-journal to your .gitignore.

An untitled script has a journal too, in Cold Open’s own folder, so even a script you never saved is offered back at the next start.

The status bar shows the journal’s state: “Protected” when everything is on disk. If the disk ever can’t keep up, it says “Protecting…”, and if writing fails it says “Not protected” with the reason, and won’t take more edits until it can protect them again.

Getting your work back

When Cold Open opens a script and finds unsaved work in its journal, it says so:

• how many changes came back, and when the last was made;
• which scenes they touched;
• a warning if another program changed the file meanwhile.

Keep (Enter or K) carries on with the recovered script, unsaved, so you can look it over before saving. Discard (D) goes back to the file as it was saved, and keeps the recovered work aside in Recovered versions, in case you change your mind.

Work from another computer. A journal that came from another computer, through a synced folder say, is never applied by itself. Cold Open asks first, naming the computer: Recover them or Set them aside.

Saving is safe too

Every save writes a new file next to the old one, makes sure it’s on the disk, then puts it in the old one’s place in one step. A crash in the middle of a save leaves either the old file or the new one, never half of each. Saving happens in the background, so typing never waits for it.

Recovered versions

Cold Open never throws work away. When it sets something aside, it keeps it in Recovered versions (palette, or the start screen):

• unsaved changes you chose not to save (“Don’t save” or “Discard”);
• the version with tracked changes or revision marks, when a save to Fountain or .fdx took them out;
• a damaged file, as it was before Cold Open repaired it;
• a journal that couldn’t all be replayed.

The screen lists them newest first, with a preview. Restore (Enter or R) opens one as a new untitled script, with nothing overwritten. Delete removes one, after asking.

A copy is cleared away 30 days after you first saw it in the list. One you’ve never seen is kept, however old.

Crash reports

If Cold Open crashes, it also saves a short crash report on your computer. The report holds no script text, file names or user names. At the next start it offers to show it to you: Look at it shows the whole report, and you can send it to us if you like, or not. Nothing is sent unless you send it yourself. See Privacy.

Crash on purpose (to test recovery) in the palette lets you try all of this safely: it closes Cold Open as a crash would. Open it again and your work comes back, with a crash report to look at.

Settings and the usage summary

New in 0.1.0-alpha.3.

Settings (Ctrl+Comma on Windows and Linux, Cmd+Comma on a Mac, also in the palette, on the start screen and in About) gathers Cold Open’s settings in one place. On a Mac it’s also Cold Open ▸ Settings… in the menu bar. Each change applies at once and is kept for next time.

From the keyboard: Up and Down choose a row, Left and Right change it, Space or Enter switches an on-or-off row, and Esc closes. On the Usage summary row, Tab moves between its switch, View… and Reset….

The usage summary

Cold Open keeps a small summary of how it’s used, on your computer only, so that feedback can say which features you rely on. It never sends it. It goes anywhere only if you tick Include my usage summary when you share feedback, and then you see all of it first.

What it counts:

• which commands and actions you use, by name (such as text.insert or changes.accept), and how often;
• how many times you start Cold Open, and roughly how long each session lasts (under 5 minutes, up to 30, up to 2 hours, or longer);
• which formats you open and save: Fountain, .fdx or a Cold Open project;
• whether the CPU or the GPU draws the window, and Cold Open’s version;
• the day counting started.

What it never holds: your text, the names of characters, scenes or anyone, file names or folders, or any time finer than a day.

• View it: Settings ▸ Usage summary ▸ View…, or Usage summary… in About. It shows exactly what’s in the file, in plain words. Copy copies it.
• Reset it: Reset… deletes it, after asking. Counting starts again from that day.
• Turn it off: Settings ▸ Usage summary ▸ Counting off. Then nothing is counted or written.

It’s kept in usage.json in Cold Open’s own folder (see Install). See also Privacy.

Share feedback

Share feedback… (in the palette, About and the start screen) opens a box for what works, what doesn’t and what you’d like.

1. Type your feedback.
2. If you’d like, tick Include my usage summary. The whole summary appears under the tick, exactly as it will go.
3. Choose Open the form (no account needed), Open a GitHub issue, or Copy all. Copy all leaves the sheet open, with your text, so you can still open the form after pasting it somewhere.

Cold Open opens the page in your browser with your text filled in, along with Cold Open’s version and your system. Nothing is sent until you submit that page yourself. If it’s too long for the page’s address, Cold Open copies it all to your clipboard and says so: paste it into the page.

Keys: while you’re typing, Ctrl+Enter (Cmd+Enter on a Mac) opens the form. Esc or Tab leaves the text box; then U ticks the summary, F opens the form, G the GitHub issue, C copies all, T goes back to typing, and Esc closes.

Report a problem… has the same Include my usage summary tick.

Known limitations of the alpha

Cold Open is an alpha. Everything in this guide works, and it’s careful with your work. But it’s new, and some things aren’t there yet. Here they are, honestly.

Back up your scripts

Keep copies of anything that matters, as you would with any new program: in another folder, on another drive, or in version control. Cold Open’s journal and atomic saves protect against crashes and power cuts, but an alpha can have bugs nobody has found yet. Your scripts are ordinary Fountain and .fdx files, so a copy opens anywhere.

Installing

• The builds aren’t signed by Microsoft or notarized by Apple yet, so Windows and macOS warn the first time (see Install). Windows signing comes with SignPath Foundation’s approval; Apple’s notarization needs a paid account.
• On macOS, double-clicking a script in Finder starts Cold Open but doesn’t open the script. Use Open (Cmd+O).
• On Windows, Cold Open isn’t made the default app for .fountain and .fdx files. It’s offered in “Open with”, and Windows lets only you choose a default.
• No automatic updates. Cold Open never checks the internet. New releases are on the download page.
• The Flatpak isn’t on Flathub yet, and sees only your home folder unless you give it more (see Install).
• The icon is a stand-in.

Files

• .fdx files can’t carry notes, boneyard, sections or synopses from Cold Open, nor tracked changes (they’re written accepted) or revision marks (they’re left out). No public description of how .fdx stores them exists, so Cold Open asks before such a save and offers a project, which keeps everything. See .fdx exchange.
• No PDF import. Cold Open exports PDFs, but can’t read one back.
• Templates: feature film only. One-hour drama, multi-camera sitcom, stage play and others come later.
• A4 isn’t selectable yet: a new script is US Letter. An .fdx file keeps its own page settings.

Writing

• No spellchecker yet.
• Dual dialogue is set with the palette (“Toggle dual dialogue” on the second character), not with a button.
• Notes and boneyard inside a line are kept and shown in the margin, but you can’t edit them inside the line yet. Edit them in the Fountain file, or with an agent.
• No screen-reader support yet, and no input methods for Chinese, Japanese or Korean. Accented letters, dead keys and AltGr work.
• One window at a time, and no native macOS menu bar beyond Settings… in the app menu: everything else is in the palette and on the keys.
• Shortcuts are changed in keymap.json, not in Settings (Mod+Comma), which holds the theme, sizes, the renderer and the privacy choices.

Production

• Locked pages, A and B pages, and locked scene numbers (12A, 12B) aren’t there yet. Scene numbers can be set by hand.
• Omitted scenes and production breakdown tags come later.

Compare and import

• Bringing in a draft as changes can’t bring styles, notes, boneyard, element settings (centering, blank lines) or the title page. They’re listed for you to apply by hand.
• A section just above a scene heading belongs to the scene before it when comparing, so moving a section with its scene reads as the section moving.

Crash reports

A crash report is written when Cold Open itself stops on an error. It isn’t written when Cold Open is closed from outside, when the computer loses power, or when a graphics driver or the system fails underneath it. Your typing is safe in each case: the crash journal covers all of them.

Found something else?

Please tell us. That’s what the alpha is for.

FAQ

Is it really free?

Yes. Writing, formatting, export and every file format are free, with no account, no activation and no limit on how many computers you install it on. Cold Open is open-source under the GPL, so any version you have keeps working, and anyone can check what it does.

Does it need the internet?

No. Cold Open never connects to anything: no account, no update check, no usage counting. See Privacy.

Can I open my Final Draft scripts?

Yes, .fdx files, the format Final Draft saves. Cold Open opens them, and saves them back with everything you didn’t edit exactly as it was. Some things don’t travel into .fdx from Cold Open: see .fdx exchange. The older .fdr format isn’t supported; save it as .fdx first.

Will a producer see the same pages I see?

Very nearly. Cold Open lays out pages by the usual screenplay rules, and an .fdx keeps its own page settings. We check the page breaks against reference scripts, and on a 120-page feature they match page for page. Cold Open’s own PDFs come out the same on every computer.

Does it work with other screenwriting apps?

Any app that reads Fountain or .fdx can read what Cold Open writes, and the other way round.

Where’s autosave?

Every keystroke goes into a crash journal as you type, so nothing needs autosaving: a crash or a power cut brings your work back at the next start. You still save (Mod+S) to write the script file itself. See Your work is safe.

Does Cold Open use AI? Does it send my script to an AI?

Only if you connect an agent yourself. Nothing connects by default, and Cold Open sends your script nowhere. If you want an AI agent’s help, you can connect one of your own through MCP. Then every edit the agent makes is a tracked change under its name, which you accept or reject, as you would a collaborator’s note. What the agent does with what it reads is up to that agent and its own privacy policy.

Why does my computer warn me when I first open it?

The builds aren’t signed by Microsoft or notarized by Apple yet. It’s the warning every new, unsigned program gets. Install says what to click, and how to check that your download is the real one.

Can I change the font?

The page is always Courier Prime, a 12-point Courier made for screenplays and free to use. That’s what keeps pages the same length everywhere. The rest of the window uses Atkinson Hyperlegible Next, made for legibility.

Can I use it on two computers?

Yes, on as many as you like. If the same script’s journal turns up on a second computer, through a synced folder say, Cold Open asks before recovering it.

Is there a version for phones, tablets or the web?

Not yet. Windows, macOS and Linux come first. The core is written so it can come to the web and mobile later.

Can I write in other languages?

Accented letters, dead keys and AltGr all work, and Cold Open’s interface is in English. The page font has no Chinese, Japanese or Korean characters yet, and those print as boxes. Input methods for those languages come later.

How do I report a problem?

Report a problem… in the palette, or in About Cold Open, opens a ready-filled page in your browser, with nothing from your script in it. You can also use the GitHub issues, or the form if you don’t have a GitHub account. What feedback helps says what makes a report easy to act on.

What does “alpha” mean here?

All the features are in, and Cold Open is careful with your work, but few people have used it yet. Expect rough edges, and keep copies of anything that matters. Your scripts stay ordinary files you can open anywhere.

Keyboard reference

Every action is in the command palette (Ctrl+K, or Cmd+K on a Mac), with its keys beside it. This page lists them all, with the keys they have when Cold Open is new. You can change any of them in keymap.json (see Your own keys).

The keys that move the caret and edit text (the arrows, Home, End, Page Up and Down, Backspace, Delete, Enter and Tab) are built in: see Getting started.

The app’s actions

Commands

The commands of the command reference, as the palette lists them. One with parameters opens a small form for them.

AI agents (MCP)

Cold Open comes with an MCP server, coldopen mcp, so an AI agent can read and edit your script. MCP (the Model Context Protocol) is the standard way AI assistants such as Claude use tools.

Connecting an agent is free, and so is the server. Cold Open itself never sends your script anywhere. The agent you connect is a separate program: what it reads from your script, and where it sends it, is up to that program and its own privacy policy.

Setting it up

The server is coldopen mcp, which talks over standard input and output. Any MCP client that runs a local (“stdio”) server can use it.

Claude Code:

claude mcp add coldopen -- coldopen mcp

Claude Desktop: add this to its claude_desktop_config.json (in Claude Desktop: Settings ▸ Developer ▸ Edit Config), then restart Claude Desktop:

{
  "mcpServers": {
    "coldopen": { "command": "coldopen", "args": ["mcp"] }
  }
}

A desktop app may not see your terminal’s PATH, so give the full path to coldopen if it isn’t found:

• Windows: C:\\Users\\<you>\\AppData\\Local\\Programs\\Cold Open\\bin\\coldopen.exe (with the backslashes doubled, as JSON needs).
• macOS: /Applications/Cold Open.app/Contents/MacOS/coldopen.
• Linux: /usr/bin/coldopen from the .deb. For the Flatpak, use "command": "flatpak" with "args": ["run", "--command=coldopen", "io.github.theyungstump.coldopen", "mcp"].

Other clients take the same two things: the command coldopen and the argument mcp.

How it works with the app

When the script is open in Cold Open, the agent’s doc_open attaches to the app instead of opening the file again. Then:

• you see each edit appear as it’s made;
• the agent’s edits arrive as tracked changes under its name, for you to accept or reject (Track changes);
• Mod+Z undoes an agent’s step like your own, and Undo agent edits (Mod+Alt+Z) undoes all its steps on top;
• the status bar shows a connected agent, with Disconnect, and Turn agent access on or off in the palette stops any agent attaching.

The link between them stays on your computer: a socket or pipe that only your user account can open, and a fresh secret each time Cold Open starts. There’s no network connection.

Without the app, coldopen mcp opens the file itself, with the same crash journal.

What an agent can and can’t do

It can: read the script (as Fountain, as elements with ids, as pages, or scene by scene), list scenes, read the reports, find text, insert, change, delete and move elements and scenes, run a batch of edits as one undo step, list tracked changes, withdraw its own, compare drafts, and save the script in place.

It can’t, because these are yours:

• accept any change, or reject someone else’s;
• turn tracking on or off;
• start or end revision sets, or bring in a draft as changes;
• edit the title page while its edits are being tracked;
• accept a loss when saving (such as saving tracked changes into Fountain);
• restore or delete Recovered versions;
• close, replace or rename the script open in the app.

The command reference lists every tool and its parameters.

Untracked edits: --untracked

On its own, without the app, an agent’s tracked edits can’t be saved into a Fountain or .fdx file, which can’t hold tracked changes. It can save a project instead, or leave them in the journal for you to review in the app.

If you’d rather the agent’s edits went straight in, start the server with:

coldopen mcp --untracked

Then the agent’s edits are recorded untracked in scripts the server opens itself. In the app, Track agent edits in the palette does the same for the script you’re in.

Other options: --doc PATH opens (or attaches to) a script before the agent starts, and --no-attach always opens the file in the server, never in the app.

Command-line reference

coldopen comes with the app on every system (see Install). Every subcommand sends the same commands the app does, so a script is changed the same way from here as from the window. coldopen --version prints the version and commit, and coldopen help <subcommand> prints a subcommand’s help.

coldopen convert

Convert a script to Fountain, .fdx or JSON.

coldopen convert [OPTIONS] <INPUT> <OUTPUT>

coldopen repair

Repair a damaged .fdx file into a new one, and print what was repaired. The input is never written.

coldopen repair [OPTIONS] <INPUT> <OUTPUT>

coldopen export

Export a script as a PDF.

coldopen export [OPTIONS] <INPUT> <OUTPUT>

coldopen pages

Print the pages of a script as plain text, the way they print.

coldopen pages <FILE>

coldopen report

Print a report: scenes, characters or locations.

coldopen report [OPTIONS] <KIND> <FILE>

coldopen diff

Compare two drafts, in any of the three formats, scene by scene. Prints a summary; exits 0 whether or not they differ.

coldopen diff [OPTIONS] <A> <B>

coldopen scenes

List the scenes in a script.

coldopen scenes [OPTIONS] <FILE>

coldopen run

Run a batch of commands from a JSON file (an array of requests, or one request per line). Prints one response per line.

coldopen run [OPTIONS] <EDITS>

coldopen licenses

Print the licenses of Cold Open and of the fonts it bundles.

coldopen licenses

coldopen bench

Measure every speed and memory budget on this computer and write a small report to send back. Runs the desktop app installed beside this command; takes about two minutes, during which its windows come and go.

coldopen bench [OPTIONS]

coldopen serve

Read JSON requests on standard input, one per line, and answer each on standard output.

coldopen serve [OPTIONS]

coldopen mcp

Serve the Model Context Protocol on standard input and output, so an AI agent can read and edit scripts. When the Cold Open app has the script open, the agent’s edits go into the app, live and undoable.

coldopen mcp [OPTIONS]

Command reference

Everything Cold Open does to a script is one of these commands. The same names and parameters work everywhere:

• in a JSON batch for coldopen run, and over coldopen serve --stdio ({"v": 1, "id": 1, "command": "block.insert", "params": {…}});
• as tools of the MCP server coldopen mcp, where the dot becomes an underscore (block.insert is the tool block_insert);
• in the app’s palette, which lists every one.

Blocks are named by their ids (b_42), which stay the same as the script changes. Positions in a block’s text count characters. The full rules, with every error code, are in the command spec.

doc.new

MCP tool doc_new. Start a new, empty script. With path, it is journaled next to that path from the first change.

doc.open

MCP tool doc_open. Open a .fountain, .spmd, .txt, .fdx or .coldopen script. If the Cold Open app has it open, attach to the app instead, so edits appear live for the writer (attach: “auto” or “never”).

doc.save

MCP tool doc_save. Save the script to its file, or to path (not allowed while attached to the app).

doc.close

MCP tool doc_close. Close the script, or detach from the app and leave the writer’s script alone. Refuses unsaved changes unless discard is true.

doc.revert

MCP tool doc_revert. Throw away unsaved changes and read the file again (not allowed while attached).

No parameters.

doc.get

MCP tool doc_get. The title page and every block with its id, type, text and attributes, plus rev, a change counter.

No parameters.

doc.export

MCP tool doc_export. The script as text without saving it: fountain (default), json, or pages (the plain-text page view).

scene.list

MCP tool scene_list. The scenes in order: heading, number, page, length in eighths of a page, and the heading block’s id.

No parameters.

text.find

MCP tool text_find. Find text in the printed text of blocks; returns each match as a block id and character offsets.

text.complete

MCP tool text_complete. Suggestions for finishing the text before an offset in a block, as the editor’s autocomplete gives them.

history.list

MCP tool history_list. The undo and redo steps, newest first, with each step’s label and author.

No parameters.

block.insert

MCP tool block_insert. Insert a block of a given type after or before a block id, or at the end. Returns the new block’s id.

block.set_type

MCP tool block_set_type. Change a block’s element type.

block.set_text

MCP tool block_set_text. Replace a block’s whole text.

block.set_attrs

MCP tool block_set_attrs. Set a block’s attributes: scene number, dual dialogue, centered, section depth, space before.

block.delete

MCP tool block_delete. Delete a block.

block.split

MCP tool block_split. Split a block at a character offset; the second part becomes a new block of the given type (or the same type).

block.join

MCP tool block_join. Join a block onto the end of the block before it, keeping the earlier block’s type.

text.insert

MCP tool text_insert. Insert text at a character offset in a block, optionally bold, italic or underlined.

text.delete

MCP tool text_delete. Delete the characters between two offsets in a block. Notes and boneyard are never deleted.

text.style

MCP tool text_style. Turn bold, italic or underline on or off between two offsets in a block.

text.replace

MCP tool text_replace. Replace text everywhere, in one scene, or at one match (at), as one undo step.

scene.move

MCP tool scene_move. Move a scene, heading and all, before another scene’s heading, or to the end.

batch

MCP tool batch. Run several edits as one undo step: all of them apply, or none do.

changes.list

MCP tool changes_list. The pending tracked changes, in document order: id, author, time, kinds, blocks, scene, and the inserted and deleted text.

changes.reject

MCP tool changes_reject. Withdraw this agent’s own tracked changes, by id, scene or all. Another author’s changes fail with not_your_change.

changes.accept

MCP tool changes_accept. Accept tracked changes. Only the writer may; an agent gets writer_only.

changes.track

MCP tool changes_track. Choose which edits are tracked. Only the writer may; an agent gets writer_only.

revision.list

MCP tool revision_list. The production revision sets, oldest first: color, label, date, whether each is active, and the blocks and pages its marks are on.

No parameters.

revision.start

MCP tool revision_start. Start a production revision set. Only the writer may; an agent gets writer_only. While a set is active, this agent’s edits are marked with it like anyone’s.

revision.end

MCP tool revision_end. End the active revision set. Only the writer may; an agent gets writer_only.

No parameters.

revision.colors

MCP tool revision_colors. Set the list of revision colors. Only the writer may; an agent gets writer_only.

revision.clear

MCP tool revision_clear. Remove revision marks, of one set or all. Only the writer may; an agent gets writer_only.

report.scenes

MCP tool report_scenes. Every scene: heading, setting (int, ext, int_ext, est), location, time, page, length in eighths, words, and the characters who speak.

No parameters.

report.characters

MCP tool report_characters. Every speaker, most words first: speeches, printed dialogue lines, words, scenes, extensions and first page.

No parameters.

report.locations

MCP tool report_locations. Every location by name, split by setting and time of day, with its scenes.

No parameters.

title.get

MCP tool title_get. The title page: its form (keys, lines or none), its Fountain keys with their values, and its positioned lines.

No parameters.

title.set

MCP tool title_set. Set one title-page key’s values (none removes the key). Refused with writer_only while this script tracks agents’ edits.

title.set_lines

MCP tool title_set_lines. Replace the title page’s positioned lines. Refused with writer_only while this script tracks agents’ edits.

diff

MCP tool diff. Compare two drafts (.fountain, .fdx or .coldopen) scene by scene: moved, changed, added and deleted scenes, then blocks and words, with a readable summary in text. Without a, the open script is the first draft. With pdf, also writes the second draft with the changes marked.

changes.import

MCP tool changes_import. Bring a draft into the open script as one writer’s tracked changes. Writer-only: an agent gets writer_only.

undo

MCP tool undo. Undo this agent’s newest step. Fails with not_your_step when the newest step is someone else’s.

No parameters.

redo

MCP tool redo. Redo this agent’s step that was undone last.

No parameters.

export.pdf

MCP tool export_pdf. Write the script as a PDF to path, with optional scene numbers and watermark. The script is not changed.

export.fdx

MCP tool export_fdx. Write a copy of the script as an .fdx file to a new path. The open script keeps its own file and format.

export.fountain

MCP tool export_fountain. Write a copy of the script as a Fountain file to a new path. The open script keeps its own file and format.

recovered.list

MCP tool recovered_list. List the copies Cold Open set aside for a script (unsaved changes kept when they were discarded, journals that could not be replayed, damaged originals).

recovered.restore

MCP tool recovered_restore. Restore a set-aside copy as a new script. Only the writer may; an agent gets writer_only.

recovered.delete

MCP tool recovered_delete. Delete a set-aside copy. Only the writer may; an agent gets writer_only.

file.repair

MCP tool file_repair. Read the .fdx file at path, repairing what it can, and write the repaired copy to a new path out; returns the repair report. path is never written.

Join the alpha

Cold Open is a new screenwriting app, and we’d like your help to make it good. The alpha has every feature in, and it’s careful with your work. What it needs now is people using it, and telling us how it went.

Anyone can join. You don’t need to be a screenwriter, have a GitHub account, or sign up for anything.

How to take part

1. Download the latest alpha and install it. It takes a few minutes.
2. Follow one track of the tester guide:
   • For anyone: about 20 minutes. Write a short scene, crash it on purpose, track a friend’s changes, export a PDF.
   • For screenwriters: longer. Bring in a draft of your own, revise it, compare drafts, read the reports.
3. Tell us how it went (below). What feedback helps says what makes a report easy to act on.

You can stop at any point. Half a track, with a note about where you got stuck, helps as much as a whole one.

Tell us

Use whichever suits you:

• Share feedback… in Cold Open’s palette, About or start screen (from 0.1.0-alpha.3): type what you think, and tick Include my usage summary if you’d like us to see which features you use (what it holds).
• Report a problem… in Cold Open’s palette (Ctrl+K, or Cmd+K on a Mac), or in About Cold Open. It opens a ready-filled page with Cold Open’s version and your system, and nothing from your script.
• GitHub issues for a bug, a file that won’t open, or an idea.
• GitHub Discussions to say how testing went, ask a question, or talk ideas through.
• The feedback form, if you don’t have a GitHub account. Your answers come to us privately.

Issues and discussions are public. Please don’t attach or paste a script you don’t own, even a draft you were sent: write a short scene of your own that shows the problem instead.

Especially wanted

• Mac and Linux testers. We test on Windows every day. Choose Measure performance in the palette (it takes about two minutes), then send us the two small files it writes to your Downloads folder. They hold your computer’s model names and the timings, and nothing personal.
• Screenwriters with .fdx files from productions. Does a script come back the way it went, and does the page count match what you expect?
• People who’ve never written a script. Does the element flow make sense without the guide?

What happens to your feedback

We read all of it. Bugs become issues that are fixed in the next alpha, and the changelog says what changed. New alphas are announced in Discussions. To hear about them, watch the repository on GitHub (Watch ▸ Custom ▸ Releases), or check back here.

Thank you.

Tester guide

Two tracks: one for anyone, and a deeper one for screenwriters. Do either, or both, or part of one. Note anything that surprised you, confused you or got in your way. That’s the most useful thing you can send.

Keys: Mod means Ctrl on Windows and Linux, Cmd on a Mac. The palette (Mod+K) lists everything, so if a step names something you can’t find, type a word of it there.

For anyone (about 20 minutes)

1. Install (5 minutes)

Download the alpha and follow Install for your system. Note anything about the warnings or the install that was unclear.

2. Write a short scene (5 minutes)

Cold Open starts on an empty scene heading. Type a scene of your own, or this one, using Enter and Tab to move between elements (the bar at the top says what each will do):

• a scene heading: int. kitchen - morning, then Enter;
• some action: The kettle screams., then Enter, then Tab;
• a character: sam, then Enter;
• dialogue: Who left this on?, then Enter;
• another character: alex, then Enter, then Tab for a parenthetical: from upstairs, then Enter;
• dialogue: Not me.

Did Enter and Tab do what you expected? Did the suggestions (names, INT., times of day) help or get in the way?

3. Save it (1 minute)

Press Mod+S and save it as kitchen.fountain somewhere you’ll find it.

4. Crash it on purpose, and get your work back (3 minutes)

1. Type one more line of action: The kettle stops.. Don’t save.
2. Open the palette, choose Crash on purpose (to test recovery), and press Enter. Cold Open closes at once, as if it had crashed.
3. Start Cold Open again, and open kitchen.fountain: it’s in the recent files, and in the bar offering your unsaved work.
4. A dialog says what came back. Is your last line there? Choose Keep.
5. A notice at the top says Cold Open closed unexpectedly and saved a crash report. Click Look at it. Read it: it should hold nothing from your script. If you’re happy to, click Send on GitHub or Send with the form and send it to us, so we can check the whole path works.

5. Track a friend’s changes (5 minutes)

You’ll play both people.

1. In the palette, choose Track my changes. Give your name when it asks.
2. Change a word or two in the scene. The new text shows in color, and anything deleted is struck through.
3. In the palette, choose Change my name for changes… and type a friend’s name. Change another line, as them.
4. Press Mod+Shift+R for the changes panel. It lists each change with its author.
5. Accept one change (A) and reject another (R). Mod+Z undoes either.

Was it clear whose change was whose? Could you find the changes again?

6. Export a PDF (2 minutes)

Press Mod+Shift+E. Tick Scene numbers, type DRAFT as the watermark, press Enter, and save it. Open the PDF. Does it look like a script page should?

7. Open an .fdx (2 minutes)

1. In the palette, choose Save a copy as .fdx and save kitchen.fdx.
2. Press Mod+O and open kitchen.fdx. It should look the same.

If you have an .fdx of your own, open a copy of that too.

8. Tell us

Tell us how it went: the Alpha testing discussion, the form, or Report a problem in the app.

For screenwriters (an hour or two)

Use copies of scripts you own, never the only copy, and never someone else’s script. Don’t attach or paste them anywhere public.

1. Bring in a draft

Open a copy of a recent draft, as .fdx or .fountain.

• Did it open without complaint? If it says it repaired the file, what did the report say?
• The page count: is it what you expect from your usual app, or within a page? Are scene starts on the right pages?
• The title page: is everything there?
• Click through the navigator. Are the scenes, numbers and lengths right?

2. Edit and save it back

Rewrite a scene the way you normally would. Then save it back to its own format.

• If it was an .fdx, open the saved file in the app you usually use. Is anything missing or moved?
• Open it again in Cold Open. Is it as you left it?

3. Production revisions

1. In the palette, choose Start revision…, keep Blue, and press Enter.
2. Make several changes across a few scenes.
3. Export a PDF with Colored pages (Mod+4 in the export form).

Are the * marks in the margin where you’d expect? Do the revised pages’ headers say “Blue Rev.” and the date? Would a production be happy with these pages?

4. Compare drafts

If you have two drafts of the same script, open one and choose Compare with… in the palette, then pick the other.

• Are the changed scenes the ones you know changed? Are moved scenes shown as moved?
• Save as PDF… and look at the marked pages.

Then try Review a draft as changes… with the same draft. Do the changes it brings in match what you’d expect?

5. Reports

Press Mod+Shift+I. Look at Scenes, Characters and Locations.

• Do the counts look right for your script?
• Copy as CSV (Mod+C) and paste it into a spreadsheet.

6. An AI agent (optional)

If you use Claude or another MCP client, connect it (AI agents) and ask it to tighten a scene’s action. Its edits should arrive as tracked changes under its name, for you to accept or reject.

7. Measure performance

Choose Measure performance in the palette. It takes about two minutes, and its windows come and go. Send us the two files it writes to your Downloads folder, especially from a Mac or Linux.

8. Tell us

Tell us how it went, including what you’d need before you’d write your next draft in Cold Open.

What feedback helps

Any feedback helps. A few things make it much easier to act on.

The most useful things

• What you were trying to do. “I wanted to move a scene to the end of act one” tells us more than “drag doesn’t work”.
• What you expected, and what happened instead.
• The steps, if you can make it happen again. “It happened once” is still worth telling us.
• Where you got stuck, guessed, or had to look something up. These are the rough edges we can’t see ourselves.
• Your version and system. About Cold Open ▸ Copy version info copies them. Report a problem… fills them in for you.

Files and scripts

• Never send a script you don’t own, even a draft you were sent. Scripts are copyrighted, and issues are public.
• Write a short scene of your own that shows the problem. A few lines that go wrong are better than a whole script.
• For an .fdx that won’t open or saves wrong, send the output of coldopen repair your-script.fdx copy.fdx --json. It lists what was wrong by code and position, and holds no script text.
• Screenshots help with how something looks. Crop out anything private or copyrighted.

Crashes

If Cold Open crashed, the next start offers its crash report. Look at it, then Send on GitHub or Send with the form, and paste the report into the page that opens. It holds no script text. Tell us what you were doing when it happened, if you remember.

Ideas

Tell us the problem before the solution: “I can’t see which scenes are night scenes” lets us find the best answer, and maybe one you’d like better than your first idea.

What’s less helpful

• “It’s slow”, with nothing more. Which action, on what computer, with how long a script? Measure performance in the palette gives us numbers.
• Long lists of things another app does. Tell us which ones you’d miss most, and why.

Thank you for taking the time.

Send feedback without an account

You don’t need a GitHub account to tell us about a problem, a crash or an idea.

Open the feedback form. It takes a few minutes.

From Cold Open it’s quicker: Share feedback… ▸ Open the form, or Report a problem… ▸ Use the form (both in the palette, About, and the start screen). The form opens with your text and the details filled in, and, if you tick it, your usage summary.

How the form works

• Your answers come to us privately. Unlike GitHub issues, nobody else sees them.
• It asks for nothing personal. There’s a box for a way to reach you, if you’d like a reply, and you can leave it empty.
• From Cold Open: Report a problem… ▸ Use the form, and the crash report’s Send with the form, open it with Cold Open’s version, your system and the renderer filled in, and nothing from your script.
• The form is a Google Form, so Google’s privacy policy applies to what you type into it. You don’t need a Google account.

Please don’t paste a script you don’t own. A short scene of your own that shows the problem is best. See what feedback helps.

Code signing policy

Free code signing provided by SignPath.io, certificate by SignPath Foundation.

Cold Open is applying to SignPath Foundation’s program for open-source projects. Until the project is accepted, the Windows builds are unsigned, and Windows warns about them the first time they run (see Install). The macOS builds are signed ad hoc and not notarized; notarization needs a paid Apple account.

Team roles

Every team member uses multi-factor authentication for GitHub and for SignPath.

Much of Cold Open’s code is written with AI coding agents, working under the author’s direction and GitHub account. The author reviews every change before it’s merged.

How a release is signed

• Each release is built from source by GitHub Actions, from a tagged commit of the repository, by the release workflow. Nothing built elsewhere goes in.
• Only Cold Open’s own programs are signed: the desktop app, the command-line tool and the Windows installer.
• Every file carries Cold Open’s name and the release’s version in its file details.
• An approver approves each signing request by hand.
• Each release lists its files’ SHA-256 checksums in SHA256SUMS.txt, so anyone can check a download (see Install).

What the programs do to your system

• The Windows installer installs for you alone, needs no administrator rights, and asks before putting the command-line tool on your PATH. Settings ▸ Apps removes everything it installed.
• Cold Open makes no network connections. Its usage summary stays on your computer, unless you include it in feedback. This website counts visits anonymously with Cloudflare Web Analytics, without cookies. See Privacy.

Privacy

This program will not transfer any information to other networked systems unless specifically requested by the user or the person installing or operating it.

In short: the website counts visits anonymously with Cloudflare Web Analytics, without cookies; the app sends nothing.

In practice

• Cold Open makes no network connections. It doesn’t check for updates or contact any server. The app, the command-line tool and the agent server hold no network code at all, and the project’s automated checks make sure none gets in.
• A usage summary, on your computer only (from 0.1.0-alpha.3). Cold Open counts which features you use, on this computer only, and it’s never sent unless you include it in feedback. It holds counts, never your text, names or file paths. Settings (Ctrl+Comma, or Cmd+Comma on a Mac) shows it in full, resets it, or turns counting off.
• No account, and nothing about you. Cold Open never asks who you are. The one name it keeps is the one you give your tracked changes, in your own settings file.
• Links open in your browser, and only when you click them.

What stays on your computer

Cold Open writes these files, and nothing else, and none of them leaves your computer unless you send it:

• your scripts, where you save them;
• each open script’s crash journal, beside it (see Recovery);
• your settings, recent files and untitled scripts, in Cold Open’s own folders (see Install);
• crash reports, in Cold Open’s own folder (below);
• the usage summary, usage.json, in Cold Open’s own folder (below);
• the two report files Measure performance writes to your Downloads folder, holding your computer’s model names and timings.

AI agents

The app and coldopen mcp talk through a socket or a pipe that only your user account can open. There’s no network endpoint. An AI agent you connect is a separate program: what it reads from your script, and where it sends it, is up to that program and its own privacy policy. See AI agents.

Report a problem

Report a problem… (in the palette and in About Cold Open) opens a page in your browser, ready to fill in: a GitHub issue, or our feedback form for people without a GitHub account. Cold Open fills in:

• Cold Open’s version and commit, and the build’s target (such as x86_64-pc-windows-msvc);
• your operating system’s name and version;
• the renderer drawing the window (CPU or GPU, and the GPU’s model).

It adds no script text, no file names or paths, and no user or computer names. Nothing is sent until you submit the page yourself, and you can change or remove anything on it first.

Crash reports

If Cold Open crashes, it saves a report on your computer, in crash-reports in Cold Open’s own folder. It keeps the newest five. A report holds:

• Cold Open’s version, the build’s target, your operating system and version, and the renderer;
• the time of the crash, in UTC;
• the name of the thread that crashed, and the name of the last action you ran, such as text.insert (never what you typed);
• where in Cold Open’s code it happened;
• the error’s message, with anything in quotes taken out, and any file path, your home folder and your user name replaced;
• a backtrace: code addresses within Cold Open’s own files, with no folder names.

It holds no script text, file names or user names.

At the next start, Cold Open says a report was saved, and offers Look at it and Never ask again:

• Look at it shows you the whole report, exactly as it is on disk. From there you can Send on GitHub or Send with the form, which copy the report to your clipboard and open a page to paste it into, or Copy it, or Delete it. Nothing is sent until you submit that page.
• Never ask again turns crash reports off: Cold Open stops writing them at all. “Turn crash reports on or off” in the palette turns them back on.

The usage summary

From 0.1.0-alpha.3, Cold Open keeps a small summary of how it’s used, in usage.json in its own folder, so that feedback can say which features someone relies on. It’s on from the first start, and it never leaves your computer by itself. It holds only counts:

• which commands and actions you used, by their names in the command list and the keyboard reference, and how often;
• how many times you started Cold Open, and how long each session lasted, rounded to under 5 minutes, 5 to 30 minutes, 30 minutes to 2 hours, or longer;
• which formats you opened and saved (Fountain, .fdx or a project);
• whether the CPU or the GPU drew the window, and Cold Open’s version;
• the day counting started.

It never holds script text, names of characters, scenes or anyone, file names or folders, or any time finer than a day.

• View it: Settings ▸ Usage summary ▸ View…, About ▸ Usage summary…, or “View usage summary” in the palette. It shows exactly what’s in the file, in plain words.
• Reset it: Reset… deletes the file. Counting starts again from that day.
• Turn it off: Settings ▸ Usage summary ▸ Counting off. Then nothing is counted or written.
• Share it, if you want to: Share feedback… and Report a problem… have a tick, Include my usage summary, which is off each time. Ticked, the sheet shows the whole summary first, and it goes only into the page that opens in your browser, which you submit yourself.

Where what you send goes

• GitHub issues and Discussions are public, under GitHub’s privacy statement.
• The feedback form’s answers come privately to the project, through Google Forms, under Google’s privacy policy. The form asks for nothing personal; a way to reach you is optional.

This website

The website counts visits anonymously with Cloudflare Web Analytics, without cookies. It counts page views in aggregate, such as how many people opened the download page, and how many downloads each build had, by the page that started each download. It sets no cookie, stores nothing in your browser, and doesn’t record the addresses’ query strings (Cloudflare’s Web Analytics FAQ; Cloudflare’s privacy policy). Nothing else measures visitors: no other analytics, no fonts or scripts from elsewhere, and the site’s search runs in your browser.

The download page’s recommendation reads what your browser says about your computer, in your browser only, and sends nothing. Downloads come from GitHub’s release files. The site is served by GitHub Pages, under GitHub’s privacy statement.

Questions

Ask in Discussions, or through the form.

Contribute

Thank you for wanting to help. During the alpha, the most valuable help isn’t code: it’s using Cold Open and telling us how it went.

Ways to help now

• Test it. Follow the tester guide, on any system, and tell us how it went.
• Report bugs. GitHub issues, Report a problem… in the app, or the form. What feedback helps says what makes a report easy to fix.
• Send crash reports. If Cold Open crashes, the next start offers to show you the report, and you can send it.
• Measure it. Measure performance in the palette, on a Mac or Linux especially, and send us the two small files it writes.
• Share .fdx problems with a short scene of your own, or the output of coldopen repair --json. Never a script you don’t own.
• Improve the docs. Something unclear or wrong on this site? Open an issue, or start a discussion. Every page has an edit link (the pencil at the top), which shows its source.
• Talk ideas through in Discussions.
• Tell people who might like it: screenwriters, Linux users, Fountain fans.

Code contributions

Pull requests aren’t accepted yet. Before they are, Cold Open needs a contributor license agreement, which a lawyer will check first. It will let the project publish signed builds in app stores, whose terms don’t fit outside contributions under the GPL alone. Until then, please open an issue or a discussion instead: a well-described bug or idea is as useful as a patch.

When pull requests open, this page will say how. Meanwhile, the code and its design are all public:

• the repository, with build and test instructions in its README;
• the product spec and the behavior specs;
• a record of how each phase was built, in docs/progress.

Licenses

• The app, the command-line tool and the agent server are under the GPL-3.0-or-later.
• The Fountain and .fdx libraries, the layout engine, the diff library and the font crate are also available under MIT or Apache-2.0, so other apps can use them.
• The bundled fonts, Courier Prime and Atkinson Hyperlegible Next, are under the SIL Open Font License 1.1.

A clean room

Cold Open matches what screenwriters need from other apps without using any of their code, files or text. Its knowledge of .fdx comes from publicly shared sample files, written up in the project’s own specs. So please don’t send material from another app’s software, manuals or help pages, even to help.

Be kind

Be considerate in issues and discussions. Everyone here is trying to make a good tool.