Frequently asked questions

What you write is yours. Ordfoss makes no claim on your work, takes no royalty, and does not require attribution. Publish it, sell it, licence it to a studio — none of that involves the tool that produced the file, any more than a word processor has a claim on a novel.

The software itself is free during the early-access preview, with no account, no activation and nothing to register. There is no free tier to exceed, because there are no tiers yet.

Per-person licensing does not exist today: there is nothing to assign to a person, no seat count and no team plan, because there is no account system to hold one.

Pricing for the full release has not been decided. Plans, tiers and what lands in each are still open, so the terms above describe the preview and are not a commitment about what a paid release will say. That is the honest answer rather than a reassuring one — and it is the same thing is-it-free says about cost.

If your situation needs something in writing — a studio's procurement process, a publisher's vendor form — ask rather than relying on this page, because a preview's terms are not a contract.

See also: How much does it cost? · Moving a project, cloud folders, and what happens if you uninstall · Can I work on a project with other people?

This answer has not yet been checked against the application.

Help ▸ Check for Updates… asks whether a newer version exists and tells you what it found. It only reports — nothing is downloaded or installed without you saying so, and the request carries no personal data.

It also checks on its own, unless you turn that off

Ordfoss checks once when it starts, a few seconds after the window appears, and says nothing unless there is something newer. That is on by default.

To stop it, untick Preferences ▸ General ▸ Check for updates when Ordfoss starts. With that unticked nothing checks in the background, and Help ▸ Check for Updates still works whenever you want it.

If the check cannot reach the network it stays quiet rather than interrupting you — being offline is not something worth a dialog about.

Which releases it offers you

Preferences ▸ General ▸ Update channel decides that:

• Stable — the released version. This is the default and what nearly everyone wants.
• Beta — early builds, and it needs an access key. See the beta channel.

When an update is found, a button appears in the status bar and a dialog offers to install it. The installer's checksum is verified before anything runs, so a download that arrived damaged or altered is refused rather than installed.

See also: Does it work offline? · What changed in this release? · The beta channel — early builds

Yes. Ordfoss is a local program: it opens, edits and saves your projects with no connection at all.

There is no telemetry and no analytics. Nothing about your writing, your usage or your machine is sent anywhere.

Two things reach the network, and only when you ask them to: the AI features, which talk to the provider you configure, and the update check, which asks whether a newer version exists. Both can be left alone entirely.

See also: Where does my writing live? · Does the AI see my writing? · Check for a new version

No. There is no analytics, no usage tracking, no crash reporting and no opt-out setting, because there is nothing to opt out of. Ordfoss has no server.

The only things that ever leave your machine, all of them started by you:

• Your AI provider, if you configure one. You supply the endpoint and the key, so the text goes where you pointed it and nowhere else. Without a provider configured, the AI features are absent rather than disabled.
• The update check, if it is enabled — it asks whether a newer version exists and sends nothing about you or your project. It is a setting, and it can be off.
• Notification webhooks, if you set one up. You supply your own channel's URL.

That is the complete list, and it is enforced rather than promised: all networking lives in one library, and a check in the build refuses any code elsewhere in the tree that reaches for a network. There is also a build with networking compiled out entirely, which is what "works offline" means here — not "degrades gracefully" but "the code is not present".

Your project is never uploaded. It is a folder on your disk. Nothing syncs it, nothing indexes it remotely, and no part of the program requires a connection to open, edit or export it.

See also: Does it work offline? · Does the AI see my writing? · Moving a project, cloud folders, and what happens if you uninstall · Check for a new version

Ordfoss has two places to go when you are stuck, and both are in the Help menu.

Help ▸ Documentation… opens ordfoss.com/docs in your browser. That is the written guide: a page per window explaining what it is for and how to use it, a features section organised by what you are trying to do, and the API reference if you are scripting Ordfoss or connecting it to an AI assistant. It is the right first stop for "how does this work".

Help ▸ Join the Discord… opens the community server. That is the right stop for "why doesn't this work", for asking for a feature, and for talking to other writers using Ordfoss. Questions asked in the help channel are answered by a bot drawing on this same FAQ, so you often get an answer immediately — and a person when you do not.

Neither contacts anything until you click it. Ordfoss does not phone home; both menu items simply hand a web address to your browser when you choose to go.

Three more things live in the same menu and are easy to miss:

• Help ▸ Keyboard Shortcuts lists every shortcut, which is faster than hunting for one.
• Help ▸ Take the Tour walks you through the main windows in the app itself.
• Help ▸ Welcome… reopens the first-run dialog, and one of its choices builds a complete worked sample project you can open and take apart. If you are trying to understand how a feature is meant to be used, seeing it used is usually quicker than reading about it.

See also: How do I report a bug? · Windows warned me about the installer · See the third-party licences Ordfoss ships under

The early-access preview is free while Ordfoss is in development. Pricing for the full release hasn't been decided yet — plans, tiers, and what lands in each are still open.

There is no account to create and nothing to activate. You download it and it runs.

See also: What is Ordfoss? · What do the AI features cost?

Yes. Alongside the writing tools there are stat blocks, random tables, dice rolling, encounter checks, maps with layers, and callouts that only the GM sees.

The codex does not care whether an entity is a character in a novel or an NPC in a campaign, and the timeline validates a campaign's chronology the same way it validates a book's.

If you only want the game tools, the writing side stays out of your way.

See also: What is Ordfoss? · Stat blocks for creatures and NPCs · Random tables

File ▸ Quick Open… searches your project and takes you straight to what you pick.

Type part of what you are after and the list narrows as you go. It matches titles and text: document titles and their prose, codex entry names, their aliases and their field values, and branching dialogue — every line, the labels on its choices, the notes you left on a node and the names of the variables it changes. The words you typed are shown in bold in each result.

Titles that start with what you typed sort first, so the thing you meant is usually the first result. Every word has to match: dragon oath finds only things containing both.

Narrow it down. The box beside the search field limits results to Documents, Entities or Dialogue; All is everything. A tag:name term filters by tag instead of matching text, and combines with words — dragon tag:draft means both.

Quick Open takes you somewhere. To change text in place across the whole project rather than navigate to it, use Find in Project.

See also: Search and replace across the whole project · Find everything you tagged · Find a line of dialogue

Right-click almost anything and choose Toggle Pin. It appears in the Pinned panel.

It is for the four or five things you open twenty times a day — the character you are writing about, the map you keep checking.

Pinning changes nothing about the object. Unpin it the same way.

See also: Jump to anything by name · Find a panel you cannot see

Help › Third-party licences opens the notices file that ships with Ordfoss. It lists every third-party library the application uses, each with its own licence text.

Why it exists rather than just an About box. Some of those libraries are under the LGPL-3.0, which obliges us to deliver the licence text to you — not merely to have complied somewhere. A version number in an About dialog does not discharge that. The same file also carries the written offer for the library source, which is the other half of the obligation.

If it says the notices are not present in this build, you are running a developer build rather than an installed one. The file is staged into the installer's payload, so it sits beside Ordfoss.exe in an installed copy. The same notices are published at ordfoss.com, which is where to look either way.

Ordfoss itself is not open source, but it is built on libraries that are, and their terms are what this file records.

See also: Windows warned me about the installer

1. File ▸ Manage Audiences… and register Players and GM before you write anything. Doing this first means you never have to go back and mark a hundred existing entries.
2. Build the world in the Codex — factions, places, NPCs — and set Visibility… on anything the players should not see.
3. Put creature and NPC numbers in the Stat Blocks panel.
4. Add a map in the Maps panel and pin the places to their codex entries, so a pin and an entry are the same thing.
5. Write session notes as documents. Use GM-only Callout for what happens behind the screen — it sits in the scene rather than in a separate file you will not open at the table.
6. Keep the things you reach for constantly pinned: Toggle Pin puts them in the Pinned panel.
7. To hand players a reference, File ▸ Export ▸ Website… or a manuscript export, with the audience set to Players.

The audience filter is what makes one project serve both sides of the screen. Everything else is ordinary worldbuilding.

See also: Is it useful for TTRPG campaigns? · GM-only notes inside the prose · Audiences: who is allowed to see what · Stat blocks for creatures and NPCs

1. File ▸ New Project… and choose where it lives. A project is a folder, so put it somewhere you back up.
2. In the Documents panel, choose New ▸ Document… and name your first chapter.
3. Write. It saves into that folder as Markdown, and the status bar counts as you go.
4. When a character turns up, open the Codex panel, right-click and choose New Entity…. Give it a category — Characters — and a name.
5. Save with Ctrl+S.

That is the whole loop: documents hold the prose, the codex holds the world, and both live in files you own.

Nothing else has to be set up. The timeline, maps, screenplay tools and the rest are there when you want them and do not need configuring first.

See also: What is Ordfoss? · Add a character or place · Where does my writing live?

Help ▸ Take the Tour walks you through the interface, pointing out what each part is for.

Help ▸ Welcome… reopens the screen you saw the first time you ran Ordfoss — useful when you want the starting points again rather than a tour of the window.

Neither changes anything in your project, and you can leave either at any point.

If you would rather read than be shown, the user guide at <https://ordfoss.com/docs/user/> has a page for every panel.

See also: Start your first project · What is Ordfoss? · Find a panel you cannot see

Beta builds go to a small group of testers before everyone else. They are not available by default: you need an access key, which is given out one person at a time.

Getting a key

Ask in the Ordfoss Discord (Help ▸ Join the Discord). Keys are handed out by the team rather than self-served, because a pre-release build of an application holding an unpublished manuscript is not something to give away on a click.

A key looks like ordf_beta_ followed by 32 characters. It grants downloads and nothing else — it reads none of your work, it is not a login, and it cannot spend anything.

Where the beta access key goes

1. Preferences ▸ General.
2. Paste the key into the Beta access key box.
3. Click Verify. It asks the beta channel whether the key works and tells you plainly what came back, including which beta is newest.
4. Set Update channel to Beta.

Beta cannot be chosen until a valid key is in the box. If the option is greyed out, the key is missing or mistyped — the tooltip on the channel box says which.

Clearing the key puts you back on Stable, so you can never be left set to a channel you cannot reach.

Going back to Stable

Set Update channel back to Stable. You keep the build you have.

Nothing will appear to happen for a while, and that is correct. If you are on 0.4.0-beta.1, the stable channel has nothing newer to offer you until stable releases pass that build. Ordfoss does not downgrade you; it waits. Once a stable release overtakes your beta, you are offered it normally.

"Your beta access has ended"

Beta access can be withdrawn — usually because a testing round finished. If that happens:

• You keep the build you have. Nothing is removed and nothing stops working.
• Ordfoss switches you back to Stable on its own, and Help ▸ Check for Updates follows stable releases from then on.
• A stable release will reach you as soon as one is newer than the beta you are running.

If you think it ended by mistake, ask in the Discord.

Should you be on it?

Only if you want to be. Beta builds are newer, which is the point and also the risk: they have had less use than a release. Keep backups of anything you cannot afford to lose — which is good advice on any channel.

See also: Check for a new version · What changed in this release? · Get help — the documentation and the Discord community

The release notes at <https://ordfoss.com/notes.html> list every release and what it changed, newest first.

They are written to be read rather than skimmed for version numbers: each entry says what the feature does and, where it matters, what it does not.

See also: Check for a new version · Why did Easy Writer become Ordfoss?

It's a writing app and a worldbuilding app that refuse to be separated: a full word processor next to a codex of your characters and places, a timeline that validates your chronology, maps, spreadsheets, screenplay tools, and research tools — in one local Windows program.

The point is that your prose and the world behind it stay in sync: names link themselves, contradictions get flagged, and everything lives in files you own.

See also: How much does it cost? · What platforms does it run on? · Is it useful for TTRPG campaigns?

Windows, today. That is the only build that ships.

The engine underneath is cross-platform and mobile and web clients are planned on the same core, but nothing else is available yet, and it would be dishonest to imply otherwise. If you are on macOS or Linux there is currently nothing to download.

See also: What is Ordfoss? · Windows warned me about the installer

Easy Writer is now Ordfoss — Icelandic orð (word) and foss (waterfall). Same app, same team, same licence.

Your existing projects, settings, window layout and preferences all carry over the first time you open it. Nothing needs moving and nothing needs re-entering.

One thing needs your attention if you use Claude: the built-in MCP server is now called ordfoss instead of easywriter.

See also: What happens to .ewriter files? · Claude stopped seeing Ordfoss after the rename

There is no real-time collaboration, and there is no account system. Ordfoss has no server: a project is a folder of files on your machine, and nobody else can be in it at the same time. If you are expecting the Google Docs model — two cursors in one document — that does not exist and is not how this works.

What does work is passing the project between people, which several features are built for.

Version control, if you both use it

The project is plain text — Markdown and JSON — so Git or Perforce handles it properly: real diffs, real merges, real history. Two people working on different chapters merge cleanly. Two people editing the same paragraph conflict, exactly as they would in code.

Sending someone only what they need

Audiences let you mark content for particular readerships and export a copy with the rest removed — not hidden, removed. A freelancer working on one region gets a manuscript and codex with the other regions absent, and there is nothing in the file to un-hide.

Comments come back the other way: an editor's notes live on the text and are resolved in place.

Shared reference material

A mounted library is another project mounted read-only (or read/write) inside yours, so a shared world bible can be maintained once and used by several projects.

What there is no mechanism for

Per-person accounts, read-only access enforced by permissions, live presence, or anything that depends on a service. Read-only for a person is a Perforce or Git permission, or simply sending an export rather than the project. Ordfoss cannot enforce it, because there is nobody to authenticate.

And there is no web version. It is a desktop application; there is no browser client.

See also: Work with an editor or beta reader · Someone changed the files outside Ordfoss · Audiences: who is allowed to see what · Share one world across several projects · Leave a comment on the text

File ▸ New Project…

You choose a name and where the project folder goes. Put it somewhere your backups cover — a project is an ordinary folder, and Ordfoss's own backups sit beside it rather than off the machine.

If you have saved a project as a template, you can start from that instead of from empty, and get its categories, calendar and style rules without its manuscript.

Nothing is created until you confirm, and you can move the folder afterwards; Ordfoss opens it from wherever it is.

What the dialog asks

Project name is the folder it makes. Browse… chooses where that folder goes -- the project is the folder, so this is the only decision about where your writing lives.

Blank project starts with nothing. The other choices start you with structure already in place, which is easier to delete than to invent.

Advanced: store as a plain folder writes the project as loose files rather than as a single bundle. Tick it if the project is going into Git or Perforce, because a folder of Markdown and JSON diffs and merges properly and a bundle does not. You can change your mind later -- see project-file-formats.

See also: Start your first project · Reuse a project setup elsewhere · Where does my writing live?

This answer has not yet been checked against the application.

A project is a folder of ordinary files — Markdown for prose, JSON for structure, your images in assets/. That single fact answers most of this.

Moving to another computer

Copy the folder. There is nothing registered, no licence tied to a machine, no database to export. Put it on a USB stick, a network share, or into a repository, and open it on the other side.

Dropbox, OneDrive, Google Drive, iCloud

They work, because a sync folder is just a folder. Two cautions, and they are the same ones that apply to any application:

• Do not have the project open on two machines at once. A sync service resolves a conflict by keeping both copies under different names, and neither of them is what you meant.
• Let it finish syncing before you open it elsewhere. A half-synced folder looks like a project with missing pieces.

If two people are genuinely working on the same project, version control handles it properly and a sync folder does not.

If you uninstall

Your projects are untouched. They live wherever you saved them, not inside the program's folder, and uninstalling removes the application only. Reinstall later, or never, and the files are still readable — Markdown opens in any text editor, JSON in any of them.

Who owns it

You do, entirely. Nothing is uploaded, there is no account holding your work, and no part of it requires the program to remain installed or the company to remain in business. That is a consequence of the format rather than a promise: plain text in a folder cannot be held hostage.

See also: What happens to .ewriter files? · Where does my writing live? · Where are my backups? · Someone changed the files outside Ordfoss

A template — for your own next project

1. Set a project up the way you like it: categories, calendar, house style, audiences.
2. File ▸ Save as Template…
3. When you make a new project, start from that template. You get the structure without the manuscript.

A content pack — to give a piece of a project to someone else

1. File ▸ Save as Content Pack… and choose what goes in it.
2. Send them the file. It is an ordinary file — no account, no upload, nothing hosted.
3. They use File ▸ Apply Content Pack… to bring it into their project.

That is how a game system, a shared setting or a set of random tables travels between projects and between people.

Which to use. A template is a starting point — used once, when a project is created. A content pack is an addition — applied to a project that already exists, as many times as you like.

If what you want is one world shared live across several of your own books, neither of these is it: mount the world as a library instead, so a fix in one place is a fix everywhere.

See also: Reuse the same shape of entry · Share one world across several projects · Start your first project · Where does my writing live?

A series that shares one world should not keep the world in each book and hope the copies stay in step. Mount it once instead.

1. Put the shared material in its own project — the world, with no manuscript.
2. In the book's project, open File ▸ Mounted Libraries….
3. Add the shared project as a mount.
4. Toggle Read/Write on the selected mount chooses which it is. A read-only mount can be referenced but not changed from here; a read/write one can be edited in place. Pick read-only if several books share the world and you want changes made deliberately in one place.
5. Its codex now appears alongside your own. Search and Quick Open span it, and entity names in your prose auto-link to library entities exactly as they do to local ones.

Where two entities answer to the same name, your own project wins over the library — so a local override behaves the way you would expect rather than the other way round.

Nothing is copied. The library is read where it lives, so fixing something in the shared project fixes it for every book that mounts it.

See also: Reuse a project setup elsewhere · What is the codex? · Jump to anything by name

They keep working. Projects saved as .ewriter still open exactly as before, and still open by double-clicking.

New projects are saved as .ordfoss. Saving an older project leaves it where it is, under the name it already has — nothing is migrated behind your back and nothing needs renaming.

See also: Where does my writing live? · Why did Easy Writer become Ordfoss?

Ordfoss backs a project up before it writes over it. Backups live under %LOCALAPPDATA%\LoomWright Games\Ordfoss\backups, in a folder named after the project.

You can also take one at any time with File ▸ Back Up Project Now.

For a single document rather than the whole project, use Version History on the document — that keeps snapshots you can read and restore individually.

See also: Where does my writing live? · Get an earlier draft back · How do I report a bug?

In a folder on your own disk. A project is a folder of text files — Markdown for prose, JSON for structure, your images and audio in an assets folder beside them.

That means you can read your work with any text editor, keep it in Perforce or Git and get sensible diffs, and take it somewhere else if you stop using Ordfoss. There is no database you cannot open and no format that needs us to exist.

You can also save a project as a single .ordfoss file when you want to move it about as one thing — that is a container for the same files, not a different format.

Opening one, and choosing which shape it is saved in

File ▸ Open Recent lists the projects you have had open, and Clear Recent empties that list — worth knowing if you share the machine, because the list names paths.

A project can live either way and you can change your mind. File ▸ Open Project Folder… opens one stored as a plain folder, which is the shape to keep in version control because it diffs. File ▸ Save as Folder… writes a single-file project back out as one. The single .ordfoss file is a container for the same files, so nothing is converted — only packed or unpacked.

See also: What happens to .ewriter files? · Where are my backups? · Does it work offline?

An audience is a readership — Players, GM, Beta readers, whatever you define. File ▸ Manage Audiences… registers them.

Any object can then be marked visible to particular audiences, through Visibility… on its right-click menu. Exports and the reading views honour that mark, so a players' copy comes out of the same project as the GM's.

An object with no audience set is visible to everyone. An unmarked project behaves exactly as it would if audiences did not exist, which is why turning them on costs nothing until you use them.

Setting it up in one go

New content starts visible to: picks the default for everything you write from then on. Anything left unrestricted is visible to everyone, so it appears in every audience's export -- which is the right default and the thing to remember before assuming something is hidden.

Apply to All Existing Content… does the retrofit. It reports how many items are not restricted to anything yet and how many already have an audience before it changes anything, so you can tell the difference between "this will tidy up 200 stragglers" and "this will overwrite work I already did". If everything already matches, it says so rather than pretending to act.

Deleting an audience that is in use asks rather than assumes: Keep It backs out, Remove Anyway goes ahead and leaves the content that referenced it unrestricted -- which means visible to everyone, so it is the answer to give deliberately.

GM-only Callout is the per-passage version: a block inside a document that only the audiences you name will see, for a secret that lives in the middle of shared prose rather than in its own document.

See also: GM-only notes inside the prose · Export without the spoilers · Keep something away from the AI

1. Open the Branching panel from the Windows menu and create a scene.
2. Add nodes — right-click the canvas, Add Node…, and pick the kind. The first node you add becomes the scene's start, so a new scene is never immediately broken.
3. Link them: select the source node, then the target, and choose Link Selected Nodes. The link runs from the first you picked to the second, which is how direction is expressed.
4. For a Choice, each outgoing link is an option and is asked for its label as you make it.
5. If a branch should depend on what happened, declare the state first. Go to the Variables tab beside the findings, add a variable, and say what it holds and what it starts as.
6. Add a Condition node, right-click it and choose What Does It Test?…, then pick the variable, the comparison and the value.
7. Mark its two outgoing links through Links Leaving This Node… — one when true, one when false. They are marked explicitly, so reordering them can never invert the story.
8. Press Arrange Automatically to lay the graph out top-down.
9. Read the findings list and fix what it reports. Double-click a finding to jump to its node.

An empty findings list means the scene is walkable: every node reachable, every choice a real choice, every condition testing something that exists.

See also: Write a branching, choice-based scene · Make a branch depend on what happened · Take a scene from script to recorded audio

A Chance node is a fork the story rolls for. The reader never sees it — like a Condition, except that what decides is luck rather than the story's state.

Make one. In the Branching panel press the add button and choose Chance, then link it to each of the ways it can go. Its own text is your label for the fork, exactly as on a Condition.

Weight the ways. Select the Chance node, press the links button, pick a link and choose Set how likely chance takes it…. A weight is a share, not a percentage: the shares of the links leaving one node are added up and each takes its own part of the total. Three ways weighted 3, 1 and 1 are taken three times in five, once in five and once in five — and adding a fourth way does not mean re-balancing the other three. Every weight is 1 until you change it, which makes an unweighted fork even. The share is drawn on the link (×3) so you can balance a fork by looking at it.

Zero switches a way off without deleting it, and the Problems tab says so — because zero is also exactly what a mistyped weight looks like, and a branch that can never be taken is invisible on the canvas. A Chance node with fewer than two ways out is flagged too: a fork with one way is not a fork.

Every way counts as reachable, however small its share. Reachability is about whether a reader can get there, and a one-in-a-hundred branch is prose somebody will eventually read.

Replay the run. The Play tab shows the Seed everything chancy in the run is rolled from — which way each Chance node goes, and which alternate take each varied line uses. The same seed replays the same story exactly, so a run that went wrong is one you can hand to somebody else. Roll Again picks a new seed and starts over. Changing the seed restarts the run: the seed decides what already happened, so leaving the transcript would show a run that seed never produced.

In Debug, the ways chance did not take are still listed, with their reason, and you can force one — the same courtesy a Condition's shut branch gets.

In the export. ink gets a RANDOM(1, total) roll and a switch over the running shares; Yarn gets dice(total) and the matching <<if>> chain. Both do the same arithmetic Ordfoss does, so a weighted fork plays the same in the editor and in your engine. Neither uses ink's {~a|b} shuffle, which is even and would quietly discard your weights.

See also: Write a branching, choice-based scene · What kinds of node a scene can hold · Play a scene and watch the story change · Give one line several takes · Export your branching scenes as ink or Yarn Spinner

A line asking whether a character is alive is a different claim depending on when it is said. No tool that keeps the story in one program and the world bible in another can check that. Ordfoss keeps both in the same file, so it can.

Say when the conversation happens. The pin button beside the scene's name asks for a year, a month and a day on your project's own calendar — thirteen months of nineteen days is fine, and a Gregorian date picker would have refused every month you invented. Tick the box off again for a scene that is not placed in time.

Then the conditions get checked against canon. If a line's condition — or an effect that writes the codex — names a character whose death instant is before the scene, Ordfoss reports it in Problems: "names Rhys, who is already dead when this scene happens." The mirror case is reported too: a character whose birth instant is after the scene does not exist yet.

Both ends have to be known. With no date on the scene, or no lifespan on the character, there is nothing to compare and Ordfoss says nothing — a finding built on a guess would be about a coincidence. Set a character's birth and death in the codex to make the check possible.

They are warnings, not errors. A line may legitimately speak of the dead, and only you can say whether this one meant to. Each character is reported once per line however often the line names them.

Move the scene earlier and the finding goes away by itself, which is the point: it is a statement about the timeline, not about the mere presence of a name.

See also: Write a branching, choice-based scene · Let a conversation change the codex, on purpose · Add a character or place · Check your timeline for contradictions

Page breaks. Put the cursor where the page must end and choose Page Break. Remove Page Break takes it out again. Use it where a break is part of the writing — the end of a chapter, a section that must start fresh — rather than to nudge the layout, because the layout changes with the format you export to.

Line spacing. Choose Single, 1.15, 1.5 Lines or Double for the text you have selected.

If you are formatting for a submission, do not do it by hand: export in standard manuscript format instead, which applies the whole convention at once.

View ▸ Page Layout View shows the result on pages while you work.

See also: See the page as it will print · Export in standard manuscript format · Export to PDF

A line in production is not only words. It has direction: which camera, which animation, which audio cue, and when.

Direct a line. In the Branching panel, select the node and either press the sequence button on the panel's toolbar (three lines running into an arrow) or right-click the node and choose Direction…. Add… asks for a command, its arguments, how long after the line it starts, and how long it lasts. Directives run in the order listed — Move Up and Move Down change it — and two that both start at 0 s still happen in the order you wrote them. It is one undoable step.

Ordfoss does not perform direction. It authors it, checks it, and writes it into the export for your engine to perform. That is the point: the person who writes the line is the person who knows how it should play, and they can say so without filing a ticket.

Declare your commands. The Commands tab, beside Variables and Quests at the bottom of the Branching panel, is your project's vocabulary — the commands direction is allowed to use. Add one with a name, the arguments it takes, whether it takes any number of further arguments, and a sentence saying what it does. That sentence is what an author sees while filling the command in.

Declaring commands is what makes a typo catchable: Camara(Closeup) looks exactly like a command your engine has until something knows which commands exist. Once a project declares any, the Problems tab reports:

• a command the project does not declare — the typo, or a command somebody removed;
• the wrong number of arguments — the command is right and the call is not.

A project that has declared no commands checks nothing, deliberately: writing direction before the engine team has settled the vocabulary is normal, and an error on every line would be useless. The Used by column counts the lines using each command, and removing one that is still in use asks first.

What reaches your engine. File ▸ Export ▸ Dialogue Script… carries the direction:

• ink — one tag under the knot: # sequence: Camera(Closeup, Aria); Audio(vo/line1)@1.5~2. A tag, not prose, so a shipped game never reads its own stage direction aloud.
• Yarn Spinner — Yarn's own commands, one per directive, immediately before the line: <<Camera Closeup Aria>>, <<Audio vo/line1 @1.5 ~2>>. Yarn's runtime already dispatches these, so there is no importer to write. An argument containing spaces is quoted for you.

In both, @ is the delay in seconds and ~ the duration; either is written only when you set it.

See also: Write a branching, choice-based scene · Export your branching scenes as ink or Yarn Spinner · Say who speaks a line, and how they say it · Tag a line of dialogue, and filter the graph by tag

File ▸ Quick Open… reaches dialogue. Type a word that appears only inside a scene and the result is the node, not the scene holding it:

The bridgekeeper wants a wheatsheaf. · Line in Toll Bridge — …wants a wheatsheaf for the crossing.

The words you searched for are shown in bold, so you can see at a glance why a result is there, and the result says what kind of node it is — Line, Choice, Condition, Jump or Hub — and which scene it sits in. Press Enter and the Branching panel comes forward with that scene selected, the graph centred on that node, and the node selected. A result that could only name the scene would leave you hunting through a graph of hundreds.

What gets searched

• Scene titles. A scene ranks above its own nodes for its own name, so typing a scene's title gets you the scene.
• The text of every node, whatever kind it is.
• Choice labels — the words the reader picks between. They are found on the node they leave.
• Notes you left on a node (see below).
• The names of the variables a node touches. Searching gold finds the node that tests it and the node that spends it. A variable is not inside a scene and has nowhere of its own to be found at; the node that uses it does.
• Condition expressions — the text of a condition written as an expression.

Narrow to it. The box beside the search field offers Dialogue alongside All, Documents and Entities. All includes dialogue too.

Searching your own notes. A note left on a node is indexed with it, so the note's words bring the node back. See Note to Yourself on a dialogue node for how to leave one.

See also: Jump to anything by name · Note to Yourself on a dialogue node · Write a branching, choice-based scene · Search and replace across the whole project

Type tag:name in the search box.

It shows only objects carrying that tag, and it composes with ordinary words — dragon tag:draft means both, and every term has to hold.

tag:name on its own is a whole query, so it answers "show me everything I marked". Tags are free-form: right-click an object and choose Tags… to add one.

Quote a tag that contains a space — tag:"act 1" — otherwise only the first word is read as the tag and the rest is searched as ordinary text. Quotes work around plain words too, so "the guild door" matches that phrase rather than the three words separately.

Lines of dialogue can be tagged too, and the Branching panel can fade everything that does not carry the chosen tag. See Tag a line of dialogue, and filter the graph by tag.

See also: Search and replace across the whole project · Jump to anything by name · Audiences: who is allowed to see what · Tag a line of dialogue, and filter the graph by tag

Formatting lives on the toolbar above the editor. It applies to the selection, or to the paragraph the cursor is in when nothing is selected.

Alignment — this is the one people mean by "centre the text"

Align left	Ctrl+L
Align centre	Ctrl+E
Align right	Ctrl+R
Justify	Ctrl+J

Justify spreads each line to both margins, the way a printed book is set. Centre puts the paragraph in the middle — that is what you want for a chapter heading or an inscription, not for body prose.

Alignment is a property of the paragraph, so you do not need to select the whole thing: put the cursor anywhere in it and press the shortcut.

Character formatting

Bold Ctrl+B, Italic Ctrl+I, Underline Ctrl+U, plus Strikethrough, Superscript and Subscript on the toolbar. Font family and Font size (points) are the two dropdowns at the left.

Paragraph style

The Paragraph style dropdown switches a paragraph between body text, a Bulleted list, a Numbered list and a Block quote. Increase indent and Decrease indent move it in and out a level, which is also how you nest a list.

Line spacing — on the Spacing ▾ menu — offers Single, 1.15, 1.5 Lines and Double for the current paragraph.

Bullets and Outdent are the toolbar's shortcuts for the same list controls: Bullets turns the paragraph into a bulleted list, Outdent moves it back out a level.

Text Colour sets the colour of the letters and Highlight puts a colour behind them; both survive export the way bold does. Colour is the one piece of formatting a reader may not get — an e-reader in night mode, a printed proof in black and white — so it is worth using for your own marking-up rather than for meaning the reader has to see.

The Insert ▾ menu is where non-text things go in — a Link, a page break, a table, an embed.

What this is not

This is formatting for reading on screen and for export. It is not page layout — margins, page size and where a page breaks are in the page-layout view.

If you are looking at raw **asterisks** instead of bold text, you are in Markdown source mode; switch back and the formatting renders.

Formatting survives export: bold, italics, alignment, lists and quotes all carry into Word, PDF, EPUB and HTML.

Autocorrect and smart punctuation

Autocorrect and smart punctuation (curly quotes, dashes) in Preferences turns straight quotes into typographic ones and double hyphens into dashes as you type. On by default, because that is what published prose uses -- and worth knowing about so you can turn it off, since it is exactly wrong when what you are typing is code, a file path or a search pattern.

See also: Control page breaks and line spacing · See the Markdown behind the prose · See the page as it will print · Export your manuscript

Right-click a document and choose Version History….

It keeps snapshots of that document over time. You can read one, compare it with what you have now, and restore it if you want it back.

This is per document. For the whole project at a point in time, use a backup instead.

Removing a snapshot

Delete Selected removes the version you have picked from the list. Versions are snapshots of the document at a moment, so deleting one loses that moment and nothing else -- the document and every other snapshot are untouched.

See also: Where are my backups? · Keep two versions of the same scene

A choice that expires — where hesitating is itself an answer — is a recognisable device, and it is one setting on the choice.

Set it. In the Branching panel, link the choice to its options first, then right-click it and choose Time Limit…. Give it a length in seconds and say If they do not answer: which of its options the reader falls into. Both in one gesture because they are one decision.

A time limit needs a default. The Problems tab reports a choice with a countdown and nowhere to go, as an error: a timer with no default stops the story at the moment you were most deliberately controlling it, and it looks exactly like a choice that works until somebody waits. The default has to be one of the options the choice actually offers — a way the reader could never have picked is a path nobody wrote, and it would arrive without the state its destination assumes.

Set the length back to no time limit and the default is cleared with it.

Feel it in the Play tab. Walking the scene shows x.x s left beside the starting state, and when it reaches zero the run takes the default and carries on — as an ordinary step, so Back undoes it like any other. Whether six seconds is generous or cruel is a judgement you can only make by sitting through it, which is the point of counting it down here.

The clock does not run while Debug is ticked: an author reading why each branch is open or shut must not have the story move on under them.

Ordfoss does not run the clock in your game. It authors the limit, checks it, counts it down here, and exports it as data for your runtime to honour — the same division of labour a line's production direction follows. Neither ink nor Yarn Spinner models a timed choice in the language, so inventing syntax would produce a file their own compilers reject:

• ink — two tags on the knot: # timeout: 6 and # timeout_default: the_stitch_name.
• Yarn Spinner — two header fields: timeout: 6 and timeout_default: the_node_title.

Both are the out-of-band channel each language provides for telling the game something the script itself does not act on.

See also: Write a branching, choice-based scene · Play a scene and watch the story change · What kinds of node a scene can hold · Export your branching scenes as ink or Yarn Spinner

A beat often needs more than one phrasing — a greeting that shortens on the third visit, a different register for a player who has the gold, or two versions for a director to choose between in the booth.

Write them. In the Branching panel, select the line and either press the takes button on the panel's toolbar or right-click the node and choose Alternate Takes…. Add… asks for the words and, optionally, a condition — only when — written in the same language a Condition node uses. Move Up and Move Down set the order, which every mode but the first depends on.

While a line has takes, they are what the reader hears and the node's own text becomes your label for it on the canvas — the same job that text already does on a Condition or a Jump. The node shows ×3 beside its kind so you can see at a glance which lines are varied.

Choose how the story picks

• The first that fits — the first take whose condition holds, every time. The conditional line. A take with no condition always holds, so anything after it is never used.
• In order, then stay on the last — first visit, second visit, and then the last one for ever. The greeting that gets shorter.
• In order, round and round — wrapping back to the first. Good for an idle line that should not sound like a recording.
• One at random — which can repeat. Use round and round if a repeat would be wrong.
• Each once, then nothing — after the last take, the line says nothing at all.

Conditions are honoured in every mode, not only the first: a take written for a state the reader is not in is skipped, and the mode picks between the ones that are left. If no take fits, the line says nothing — it never falls back to your label.

Play it. The Play tab walks the scene and shows the take that visit calls for, counting your visits as it goes. Stepping back and forward again shows what you heard, including on a random line.

Each take has its own line id, which does not change when you rewrite the words — so a recorded take and an approved translation stay attached to the take they were made for. Every take is extracted for translation; a varied line's label is not, because no reader ever hears it.

In the export. File ▸ Export ▸ Dialogue Script… carries them:

• ink writes its own variable text — {a|b|c} in order, {&a|b} cycling, {~a|b} at random, {!a|b} once each — and the first that fits as a { - condition: … } switch.
• Yarn Spinner has no variable text, so the mode is written as <<if>> over visited_count, and one at random as a dice() roll.

ink has no per-alternative condition, so a condition on a take in any mode but the first that fits cannot be exported: the take still goes out, and the export report names every one it could not guard.

See also: Write a branching, choice-based scene · Make a branch depend on what happened · Export your branching scenes as ink or Yarn Spinner · Tag a line of dialogue, and filter the graph by tag · Send your book to a translator

In the editor, insert a GM-only Callout…. It sits inside the prose as a distinct block rather than as a comment off to the side.

When you export for an audience that should not see it, it is left out. When you export for yourself, it is there.

It is for the paragraph that explains what is actually going on — the thing you want next to the scene rather than in a separate document you will forget to open.

See also: Audiences: who is allowed to see what · Export without the spoilers

Read Aloud in the editor speaks the document back to you, and Stop Reading stops it.

It uses the speech voices Windows already has, so the range available depends on what is installed on your machine rather than on Ordfoss.

Hearing a paragraph read flatly is one of the better ways to catch a sentence that does not work.

See also: Is Ordfoss usable with a screen reader? · Voice-over scripts and takes

Declaring a variable asks How long does it last?, and there are two answers.

Whole story keeps its value from the moment something sets it until something else changes it. This is what you want for anything the reader should carry with them: "they took the sword", "they know about the letter", how much gold they have.

Resets each scene goes back to its starting value every time a scene begins. This is for bookkeeping inside one scene — "already asked about the weather", "has tried the door" — and it exists so a hundred small local flags never accumulate into permanent state you have to reason about later.

If a variable seems to have forgotten something between scenes, this is almost always why: it was declared Resets each scene and is doing exactly that.

Reading it off the Variables tab

The Variables tab, beside Problems in the Branching panel, is a table with one row per variable:

• Name — what conditions and effects refer to.
• Holds — yes / no, number or text. Fixed at declaration; see the type note in declaring a variable.
• Starts at — the value before anything has changed it, and what Resets each scene returns to.
• Lifetime — Whole story or Resets each scene.
• Supplied by — This story for an ordinary variable, or The game — <key> for one the surrounding game owns; see variables the game supplies.
• Tested by — how many conditions read it, which is how you spot a variable that is written everywhere and never actually tested.

Lifetime is one of the things Edit Variable… will change afterwards, so a flag that should have been scene-local is a right-click away from being fixed.

See also: Make a branch depend on what happened · Make a branch actually change something · Test things the game owns — inventory, level, faction standing · Write a branching, choice-based scene

A Jump node can send the reader into a different scene, so a story does not have to fit in one graph.

Set it up in two steps.

1. In the scene being entered, right-click the node you want to be a way in and tick Entered From Another Scene. The scene's starting node is always a way in and needs no ticking.
2. In the scene doing the jumping, select the Jump and choose Jump To…. The list now offers this scene's own nodes and every other scene's ways in, shown as Scene ▸ the line you land on.

The reader carries the whole story's state across: a variable set before the jump is still set after it, and a jump back brings that state home again.

Why you have to declare a way in

A jump may land only on a declared entry point or a scene's start. Landing in the middle of another conversation puts the reader somewhere the surrounding nodes assume state they never picked up — and every symptom of that shows up somewhere else entirely, hours later. If you point a jump anywhere else, the Problems list says "jumps into the middle of another scene".

It also keeps the Unreachable warning worth reading. Ordfoss works out what a reader can arrive at by walking forwards from the way in. A node reached only from another scene has nothing leading to it inside its own, so without a declaration it would be reported as prose nobody can reach — and a warning that is usually wrong is one you stop reading. Declaring it says "this is reached from outside" once. A node that is neither reachable nor declared is still reported, which is the point.

Reading it on the canvas

• A Jump that leaves the scene is outlined in blue and heavier than a local one. Its tooltip names the scene it goes to — the consequence is not on this canvas to look at.
• A declared entry point is tinted like the starting node, because both are places a reader can arrive without having come through this scene.
• Hovering a scene in the scene picker says which scenes jump into it, so you can read the shape of the whole story without opening every scene to find out what feeds this one.

When a scene is deleted, jumps that led to it say "jumps to a scene this project no longer has" — told apart from a mistyped target, because the fix is different.

See also: Write a branching, choice-based scene · Line IDs, and why a recording survives a rewrite · Make a branch depend on what happened · Find a line of dialogue

In the Documents panel, choose New ▸ Today's Note.

It opens today's note, creating it the first time. That is the whole feature: somewhere to put a thought without deciding where it belongs.

Use it as the scratch layer. Things that turn out to matter get moved into a real document or a codex entry later; things that do not can stay there.

For a note that is not about today, New ▸ Note… makes an ordinary one.

See also: Start your first project · Keep a to-do list · Keep things you use constantly to hand

A line that does not fit the UI box, or blows the voice-over budget, is normally found in QA — months after the scene was signed off, by somebody who cannot rewrite it. Ordfoss counts while you are still writing.

Set a budget. The Budgets tab, at the bottom of the Branching panel beside Variables and Commands, holds them. Right-click ▸ Add Budget…, choose whose lines it applies to — one character, or Every line in the project — and give it a longest length in characters, a longest time in seconds, or both. Leave a number at zero and it is not checked. A budget that checks neither is refused, because a row promising a check that never fires is worse than an empty table.

The nearest limit wins, and each number is resolved on its own:

1. the line's own limit, set in Edit Text;
2. the speaker's budget;
3. the project-wide one.

So a line may override its length and still keep its speaker's time limit — overriding one number never quietly switches the other check off.

Time is estimated, not measured. The line is being budgeted long before anybody records it, which is the point. The estimate counts words at the project's reading speed — right-click ▸ Set Reading Speed…, 150 words per minute by default, which is the usual conversational figure. Words rather than characters because that is what reading rate is a property of: a and antidisestablishmentarianism take very different times per character and about the same per word.

Count as you type. Edit Text shows what the line costs under the box — 84 of 120 characters · about 2.1 s of 4.0 s — updating on every keystroke, and saying over budget in words as well as numbers. The same dialog is where a line sets its own limit.

Over-budget lines are reported in the Problems tab, as warnings rather than errors: the story works, and a draft that overruns a limit you are about to edit is not a defect. Every alternate take of a line is counted separately; a varied line's own text is not, because no reader ever hears it.

Translations are checked too, and this is the one that matters. A translation that grows 40% fits the translator's file and not the box it has to appear in — a budget that looked only at the source language would pass every project right up to the day it shipped in German. Once a translation is imported, an over-budget one is reported against the line, naming the language, even when the original fits.

See also: Write a branching, choice-based scene · Say who speaks a line, and how they say it · Send your book to a translator · Give one line several takes

A document can hold more than one variant — alternative takes on the same scene, kept side by side rather than in two files you have to remember to keep in step.

Use the variant actions on the document to make a new one, rename the active one, or delete one you have finished with, and compare two to see what actually differs.

This is for deliberate alternatives. For "what did this look like last week", use Version History.

See also: Get an earlier draft back · Lock a document so it cannot change

1. Edit ▸ House Style…
2. Add a row. The table has a column for each thing a rule needs: Term, Ruling, Write instead, Why, and Match case.
3. Ruling is a picker with three choices, and it is the one that decides what the rule means:
   • Spell it this way — the spelling this project uses. "Always grey."
   • Never use — a word you have decided is wrong for the book.
   • Prefer something else — avoid where you can, but it is not an error.
4. Write instead is the replacement to suggest, and Why is the reason the Style panel shows you six months later. Match case says whether the term is case-sensitive: Grey and grey are usually the same rule; a proper noun usually is not.
5. Close the dialog and open the Style panel. Your rules are reported there alongside the general prose checks, so a Never use word appears in the same list as everything else.
6. Fix what it finds, or ignore it. Nothing is rewritten for you.

House style is project data, not a preference. It travels with the project and applies to everyone working on it — which is the point when more than one person is writing, and still useful when it is just you and a word you keep spelling both ways.

See also: See what the style checker found · Search and replace across the whole project · Run a revision pass over a finished draft

A branching condition has always been able to read the codex: @Rhys.status == "deceased", count(@Guild.members) > 3. An effect can now write one — and because that rewrites the world bible rather than story state, it is deliberately harder to do by accident than anything else in the branching editor.

Author it. On a node's Effects, add an effect and set Writes: to A codex property (changes canon). Pick the object and finish the path — the same syntax a condition uses, so @Rhys.status in a condition and in an effect mean the same value. An effect that writes canon writes no variable; the two are different kinds of thing and one effect is only ever one of them.

Allow it first. Off by default in every project. Until a project says yes, a canon-writing effect is reported as an error in Problems: a team that has not agreed to let dialogue rewrite the codex should find out that a scene tried before it ships, not afterwards.

It is reported even when it is allowed, which is unusual and the whole point. Every canon write is listed in Problems, named with the property it changes, so a lead can see every place a conversation touches the world bible. Nobody should discover it by reading the codex and being unable to explain what happened. The node is also marked on the graph, so it does not draw like one that merely changes a counter.

Ordfoss authors and exports it; Ordfoss does not perform it. Playing the scene in the Play tab will not edit your project — a playthrough is a lens for reading the story, and one that rewrote the codex as it walked would make opening a scene and changing the world the same act. The write travels in the engine export for the runtime to carry out, the same division of labour a line's production direction follows.

A write whose target is gone is reported like any other dangling reference: a change the author believes they made, going nowhere, is worse than one that fails loudly.

See also: Write a branching, choice-based scene · Why an effect does nothing · Add a character or place · Properties, and who they belong to

Every node in a branching scene has an ID that never changes. Rewrite the words, rename the scene, drag the node anywhere in the graph, close and reopen the project — the ID is the same.

Get it. Right-click the node in the Branching panel and choose Copy Line ID. It goes on the clipboard, ready to paste into an email, a spreadsheet or a bug report.

Where it turns up

• The Line ID column of the CSV from Export Line List in the Voice panel, so a studio can key their own tracking on it.
• The string address in a translation export, as …/nodes/<id>/text.

Why it matters: your work stays attached to it

A recorded take, the actor cast on a line and an approved translation are all attached to the ID, not to the words. So:

• Rewriting a line does not lose the recording. The take stays, and the line's status becomes Needs pickup — the recording still plays, still sounds fine, and no longer matches what is written. That is a thing to schedule, not a thing to discover.
• Renaming the scene, moving the node, or reordering the scene change nothing. None of them touch the ID.
• Deleting a line and typing it again makes a new line, even if you type exactly the same words. It has a new ID, no takes and no casting — you started over, and it does not quietly inherit somebody else's work.

Pulling lines from a scene again (Pull Lines from a Scene… in the Voice panel) matches on the ID too, so re-pulling after an edit updates the lines you have rather than duplicating them.

See also: Voice-over scripts and takes · Send your book to a translator · Write a branching, choice-based scene · Note to Yourself on a dialogue node

Right-click the document and choose Lock.

A locked document stays readable and can still be reordered, but it cannot be edited or deleted — and the assistant cannot change it either, however it is asked. Only you can unlock it.

It is for the chapter you have finished with and would rather not touch by accident.

See also: Keep something away from the AI · Get an earlier draft back

A Condition reads the story's state. Effects are what write it — and without them a condition would test the value its variable was declared with for ever, so nothing in the scene could ever change.

Right-click any node in the Branching panel and choose Effects…, then Add…. Pick the variable, pick what it does, fill in the operand, and click OK twice. (If Add… is greyed out, the project has no story variables yet — declare one on the Variables tab beside the findings first, and it becomes choosable here.)

The window that opens is a short form — Variable:, What it does:, and a bottom row that changes with your answer. See the rows in the Effect window for what each one is and why they come and go.

What an effect can do

• Set it to a value — replaces the value with a literal you type. "gaveGold = Yes".
• Set it to another variable — copies whatever a second variable holds at the moment the reader passes the node, not what it holds while you are writing. This is how you remember something: "purseAtDoor = gold" records what they were carrying when they arrived, and it keeps that number afterwards even as gold goes on changing.
• Add to it — for a number, and the amount can be negative. There is no separate subtract: spending ten gold is add –10, which is also how the condition that tests it later reads.
• Flip it — for a yes/no variable: yes becomes no, no becomes yes, whichever way it was set. A lamp a node switches does not know which way it was pointing, so Set it to cannot express it without a Condition and two more nodes.
• Reset it to its starting value — back to what the variable's own declaration says, not to zero. A counter declared to start at 3 resets to 3.

The list only offers what the variable's type can do

You will not find Add to it on a yes/no variable, or Flip it on a number, because neither does anything when the story runs. Set it to another variable only offers sources of the same type for the same reason — copying a name into a counter has no answer to give.

Seeing which nodes change something

Every node that carries effects shows them on its body in the graph, in purple after a small dot — "gold – 3", "lampLit flipped", "purseAtDoor = gold". Hover the node for the full list. This is the fastest way to find the node that quietly set the flag three branches back.

When they happen, and why the order matters

Effects apply when the reader arrives at the node, before its outgoing links are chosen. So a Condition that also carries an effect tests the state it arrived with, and everything after it sees the change.

They run in the order you list them, and Move Up and Move Down are how you change that. Two effects on one variable compose — add 5 then reset is not the same as reset then add 5.

Effects go on the node, not on the choice

A Choice offers options; the node each option leads to is where the consequence goes. That node is already where you wrote "You hand over the coins", so it is where gaveGold = Yes belongs too.

When one does not work

An effect that changes nothing is reported on the Problems tab rather than failing silently. See Why an effect does nothing.

See also: Make a branch depend on what happened · Write a branching, choice-based scene · Test a branching scene and find the paths that are broken · What the rows in the Effect window mean

Story variables are the state a branch can depend on — whether the gate is open, how much gold, what name the reader chose. A Condition node has nothing to test until one exists, so declare it first.

Declare the variable

1. Open the Branching panel from the Windows menu and select the Variables tab, beside Problems.
2. Right-click anywhere in the list and choose New Variable…. (The panel's toolbar has a button for it too — the token icon, tooltipped "Declare a story variable a condition can test".)
3. Fill in the four things it asks:
   • What is it called? — the name conditions refer to.
   • What does it hold? — Yes / no, a number, or text.
   • How long does it last? — Whole story, or Resets each scene.
   • Starting Value — what it holds before anything changes it.
4. There is a Note to yourself (optional) field. Use it: six months later, "gate_open" will not explain which gate.

The Variables tab is a table: Name, Holds, Starts at, Lifetime, Supplied by and a Tested by count, so you can see which ones are load-bearing. See how long a variable keeps its value for what each column says.

Change one you already made

Right-click the row on the Variables tab and choose Edit Variable…, or just double-click it. It asks again for the name, the Starting Value, the lifetime and the note, seeded with what the variable has now.

Renaming is safe — conditions and effects point at a variable by identity rather than by name, so nothing that uses it breaks.

What it does not ask for is the type, deliberately. Re-typing would silently invalidate every comparison already written against it: gold is at least 50 has no answer once gold holds text, and there is no honest way to convert those. If you do need a different type, delete the variable and declare a new one — that path warns you first and says how many conditions are affected.

To remove one, right-click and choose Delete Variable, or select the row and press Delete.

Test it in the scene

1. Add a Condition node to the graph.
2. Right-click it and choose What Does It Test?…
3. Leave Test one variable selected and pick the Variable, then Compared how — is, is not, is less than, is at least — and the value to compare against. (Choose Test an expression instead to test more than one thing at once, or to compare two variables with each other: see write a condition as an expression.)
4. Give it two outgoing links. Open Links Leaving This Node… and set one to When the condition is true and the other to When the condition is false. They are labelled rather than ordered, so rearranging them can never quietly invert your story.

What goes wrong, and how you find out

The Problems tab reports a Condition that tests no variable — "so it can never decide anything" — and one testing a variable the project no longer has. Deleting a variable that conditions still test warns you first, and Edit ▸ Undo brings it back.

An empty variable picker in What Does It Test? means the project has none yet: declare one on the Variables tab and it becomes choosable here.

See also: Make a branch actually change something · Write a branching, choice-based scene · Write a condition or a rule as an expression · How long a story variable keeps its value

Chapters, scenes, parts and notes are all the same thing underneath — a document. What differs is where it sits and what kind you give it.

1. Make it. Right-click in the Manuscript panel and choose New Document…. It asks for a title, then for a kind:

• prose — manuscript writing. Chapters and scenes are both this.
• screenplay — industry screenplay formatting, with the input behaviour to match. See screenplay-mode.
• note — freeform research or thinking, kept out of the manuscript. New Note… on the same menu is the shortcut for one.

The kind selects the style set, the typing behaviour and how the document exports, so it is worth getting roughly right — but it is not a trap. Change Kind… on the right-click menu moves a document between kinds later.

2. Put it where it belongs. There is no separate "chapter" or "scene" object: a scene is a document nested under the document you are calling a chapter. Promote and Demote change how deeply a document is nested; Move Up and Move Down reorder it among its siblings. That is the whole structure — see reorder-manuscript.

3. Write in it. Selecting a document opens it in the editor. Nothing needs saving by hand.

Also on that right-click menu, and worth knowing early: Duplicate Document (for a second pass at a scene you do not want to lose), Toggle Pin (keeps a document at the top of the panel while you are working on it), and Visibility…, which controls who sees it in an export — see audiences.

If you are starting a project from nothing and want the whole path rather than this one step, see workflow-first-project.

Copying and removing one

Duplicate Document makes a copy with its own identity -- a separate document that happens to start with the same text, not a link -- which is the way to try a different version of a scene without losing the one you have. For versions that stay attached to the original, see document-variants instead.

Delete Document removes it, and a container takes its children with it: the manuscript walk starts at the top and descends, so a document whose parent is gone is never reached. The app tells you how many documents that is before you agree to it.

See also: Reorder chapters and scenes · Rename something, or move it somewhere else · Write a screenplay · Keep a daily working note · Format text: bold, alignment, lists and spacing · Start your first project

A node can carry a note that only you ever read.

Leave one. In the Branching panel, right-click the node and choose Note to Yourself… — or select the node and use the note button on the panel's toolbar (the small page with a turned-up corner, beside Edit Text). Type the note and press OK.

Anything you want to remember about that node goes here: "VO: weary, he has said this before", "check this against the treaty date", "needs a shorter take for the trailer".

What a note does and does not do

• It is never shown to a reader and never changes how the story plays. It is not spoken, not exported, and no condition can test it.
• It travels with the node — copy, move or reorder the node and the note goes with it.
• It is searchable. Type its words into File ▸ Quick Open… and the node comes back. That is the point of writing one down: the only way back to a note is the words you used.
• Clearing the text and pressing OK removes it.

A note is not a tag. A tag is a short label you filter and search by, and the Branching panel can fade every node that does not carry the one you chose. Use a tag for needs-vo; use a note for the sentence explaining what it needs.

A note is not a comment. A comment is a conversation about the node — it has an author, it threads, and it gets resolved. A note is part of writing the node, has no author and never resolves. Use a comment when someone else needs to answer; use a note when you are talking to yourself.

Variables have one too. The variable editor's "Note to yourself (optional)" field is the same idea applied to a variable, so you can record what a piece of story state is actually for.

See also: Find a line of dialogue · Write a branching, choice-based scene · Make a branch depend on what happened · Leave a comment on the text · Tag a line of dialogue, and filter the graph by tag · Comment on one line of dialogue

An option can carry its own condition, so it is offered only to a reader the condition holds for. Three options with three different requirements need no Condition nodes at all.

Set one. Right-click the node the options leave and choose Links Leaving This Node…. Pick the link, then Set when this option is offered… and type an expression over your variables — hasKey, gold >= 50 AND NOT metRhys. Leave it empty and the option is always offered.

The same menu also offers Relabel this link… (what the reader reads) and Remove this link.

On the canvas the condition is drawn beside the link in square brackets, shortened if it is long; the full text is on the tooltip. A conditional option otherwise looks exactly like an unconditional one, and "why does this option never appear?" is not a question a graph can answer if it does not show the gate.

A condition is not a guard, and a link can have both

• The guard — Always, When the condition is true, When the condition is false — says which side of a Condition node this link leaves. You set it in the same menu, on a link leaving a Condition.
• The condition says whether the option exists for this reader at all.

They are tested independently. A link can be the false branch of a Condition and be offered only when the reader carries the amulet.

An unreadable condition shuts the option. A typo, a bracket left open, a variable you deleted — the option is not offered, and the Problems tab says "An option leaving … has a condition that cannot be read." Treating it as true would quietly offer an option you had gated, which is the failure that costs.

Hidden, or shown greyed out

By default an option whose condition fails is simply not there. Often you want the opposite: "[Requires 10 Charisma] Talk him down", greyed because the reader has 8. An option that vanishes teaches them nothing; one shown with its requirement tells them what to go and get.

Choose Set what happens when it is not offered… on the link, then Hide it or Show it greyed out. Picking the second asks you for the words to show — "Requires 10 Charisma" — which are yours to write, not the expression: charisma >= 10 is what the story tests, and putting a variable name in front of a reader leaks the machinery into the fiction. Leave it empty and the option shows greyed with no explanation, which some games want.

A greyed option cannot be taken. Telling a reader what they cannot do is the design decision; letting them do it anyway is not.

Use the Play tab with Debug ticked to see every option including the hidden ones, with the reason each is open or closed — and to take one anyway.

See also: Write a branching, choice-based scene · Make a branch depend on what happened · Play a scene and watch the story change · Start a playthrough mid-story, and force a shut branch

The Branching panel's Play tab reads your scene the way a reader would: one line at a time, with the graph still on screen above it.

Walk it. The current line is at the top. Under it is a button for each way onward — a Choice's options by their own labels, or Continue where the story simply goes on. Click one and you move.

Watch the state. The variable table beside the transcript shows the story's state right now. Enter a node that changes a variable and you see it change. Reach a condition further down and it takes the branch that state actually permits — which is the whole point: you find out that your gate never opens by walking into it, not by reasoning about it.

Step Back goes back one line and puts the variables back exactly as they were when you arrived there, so you can take the other branch from the same spot. Restart returns to the scene's first line with everything at its starting value. Copy Transcript puts the whole run on the clipboard, with each choice you took marked > so it reads as a script rather than as more dialogue.

It follows jumps out of the scene. A Jump into another scene is taken like any other step, and the story's state travels with you — see Jump from one scene to another.

Play is not the Problems tab, and both are worth having. Problems answers "can a reader ever get here?" by examining the whole graph at once. Play answers "what happens if I go this way?" Neither can be built from the other: the analysis has no current line and no history, and a playthrough that explored every branch at once would not be a playthrough. They share the same effect and condition logic, so they can never tell you different things about the same node.

See also: Write a branching, choice-based scene · Make a branch depend on what happened · Jump from one scene to another · Note to Yourself on a dialogue node

Open the Markdown Preview panel from the Windows menu.

It renders the document you are in as formatted output, updating as you write.

Use it when you want to check how something will come out — a table, a list, an embed — without exporting.

See also: See the Markdown behind the prose · See the page as it will print

An embed shows another object's content inside this document, so one piece of text lives in one place and appears wherever it is needed.

1. Put the cursor where the content should appear.
2. Insert an Embed… and choose the target. The marker looks like ![[something]].
3. The content appears inline as you write.
4. If a target has changed and the view looks stale, Refresh Embeds.

What each kind of target shows: an entity appears as its name, category and summary; a document as its title, synopsis and body, or one named section of it; a spreadsheet or chart as a table; a map as its region list. A target that no longer exists shows an italic note rather than vanishing silently.

Embeds expand on export, so a Markdown, HTML, Word, EPUB, PDF or standard-manuscript file shows the transcluded content rather than the raw marker.

Use it for the thing you would otherwise copy and paste — a stat block referenced in three scenes, a description you do not want to keep in step by hand.

See also: Search and replace across the whole project · Export your manuscript · Set up a project for a tabletop campaign

1. Put the cursor where the table should go and choose Insert Table….
2. Give it a size. You are not stuck with it.
3. Type into the cells.
4. To grow it: Insert Row Above, Insert Row Below, Insert Column Left, Insert Column Right.
5. To shrink it: Delete Row, Delete Column.

A table is part of the prose and exports with it.

If what you actually want is data — something with formulas, or something that should stay in step with the codex — use a spreadsheet and embed it instead. A table typed into prose is text, and text does not add up.

See also: Keep a spreadsheet in your project · Pull one document into another

The order documents sit in is the order the manuscript compiles in, so rearranging them rearranges the book. Nothing needs renumbering afterwards.

Three places to do it, same result

1. The document list — drag a document up or down. Dropping between two items places it there; dropping onto a folder puts it inside that folder.
2. The Corkboard — the same documents as index cards. Drag the cards. This is the one to use when you are thinking about shape rather than looking for a specific chapter.
3. The Outline panel — the reading view of the same structure, with each document's status and word count, for deciding what to move before you move it.

Nesting is the hierarchy

Dropping a document onto another makes it a child. That is how a chapter gets scenes under it, and how a part gets chapters. Drag it out again to promote it back up a level.

What moves with it

Everything: the prose, its synopsis, status, word count, comments and any timeline events linked to its scenes. A document is one thing, not a row in an index that has to be kept in step.

Every move is one undoable step — Edit ▸ Undo returns it to where it was.

Locking does not stop a move. A locked document "can be read and moved, but not changed or deleted" — the lock protects the words, not the position. So you can still restructure a draft whose finished chapters are locked.

Without dragging

Move Up and Move Down on a document's menu shift it one place among its siblings, and they carry Ctrl+Shift+Up and Ctrl+Shift+Down. That is the way to do it in a long manuscript, where dragging a chapter from the top of the list to the bottom means dragging against a scrolling panel.

They move a document among its siblings only. To change how deeply it is nested, use Promote and Demote, or drag it onto or out of another document.

See also: Work with index cards · See the manuscript as an outline · Rename something, or move it somewhere else · Export your manuscript

A shopkeeper's greeting reached from six conversations used to be authored six times and fixed six times. Call it instead: author it once, and every conversation that calls it comes back to its own next line.

Making one. Right-click the canvas → Add Node… → Call a scene. Then right-click the new node → Call Which Scene?… and pick the scene and the entry point to enter. The scene you are calling needs a Return to caller node — add one the same way — for the story to come back.

Call versus Jump. A Jump is one-way: the story goes there and carries on from there. A Call remembers where it came from, so the same greeting called from the Market, the Docks and the Gate returns to three different lines. On the canvas a Call is drawn with a dashed purple outline and a Return with a solid one, because the difference decides whether the line after the node is ever read.

They nest. A called scene may call another, and each returns to its own caller in order — the return addresses are a stack, the same way ink's tunnels work. Three deep unwinds through all three.

Scene variables start fresh on every call. A variable whose lifetime is This scene is returned to its declared starting value each time the scene is entered, including the second time it is called. Global variables carry through untouched — that is the whole difference between the two lifetimes, and it is what makes a called scene reusable rather than a scene that remembers its last visit.

Playing it. The Play tab walks straight through a call. The transcript marks the seam: [ into: greet ] where the story entered the called scene and [ back ] where it returned, so you can see that each caller came back to the right place.

A Return with nothing to return to simply ends the story, so you can open a greeting on its own and play it without deleting anything first.

If the Problems tab says “starts a chain of calls with no way out”, a scene calls itself, or calls something that calls it back. Every entry would push a return address and nothing would ever pop one, so the playthrough refuses to follow it. Break the loop — usually by making one of the calls a Jump, which does not come back.

See also: Jump from one scene to another · Write a branching, choice-based scene · Play a scene and watch the story change · Make a branch depend on what happened

In the Branching panel, right-click the node and choose Who Says This?…. One window asks four things about the same decision.

Spoken by lists every character in your codex, plus Nobody in particular — which is a real answer, not a blank one. Narration and stage directions are spoken by nobody, and saying so is different from not having got round to it. The speaker is stored as a link to the codex entity, so renaming that character later does not un-cast a single line.

Called here is what the reader is told, when it differs from the character's name — the hooded figure before a reveal, Father from one character and the King from another. The entity is still the speaker underneath, so casting, the cast list and every reference keep working while the reader is told something else. Leave it empty for the character's own name.

Portrait offers the images in that character's gallery — so add pictures to the character in the Codex first (open the character, use its gallery strip). Pick one and it is drawn on the node in the graph. Change the speaker and the list changes with them: it will never offer one character's face for another's line.

Delivered is free text for how the line is performed — weary, shouted, under her breath. It shows on the node's tooltip and travels with the line into the voice list, where a director reads it.

Where it shows up afterwards. The node's heading in the graph reads Line — Wren. The Play tab's transcript reads as a script: Wren (shouted): Hold the gate!, and Copy Transcript puts that on the clipboard for a table read. Voice line extraction fills the speaker column and derives the cast list from the graph — one entry per character who actually speaks, so it cannot go stale the way a hand-kept list does; the actor, contact and voice note you type against a cast member are kept when it is re-derived. The translation export carries the speaker to a translator as context, because register, formality and grammatical gender all depend on who is talking.

If the character is deleted, the node shows (missing character) and the Problems tab says "…" names a character this project no longer has. A deleted portrait is reported separately — "…" shows a portrait this project no longer has — because one is a character to re-pick and the other is a picture to re-choose. Neither is silently dropped: a line that quietly became narration is how a deletion goes unnoticed until a recording session.

See also: Write a branching, choice-based scene · Play a scene and watch the story change · Note to Yourself on a dialogue node · Voice-over scripts and takes · Send your book to a translator

Edit ▸ Find in Project… searches everything you have written, not just your chapters, and replaces across all of it in one undoable step.

What it reaches. Document titles, synopses and prose; codex entry names, aliases and text fields; dialogue — every node, its choice labels and the notes on it; spreadsheet cells; task titles and descriptions; map pin and region names; timeline titles, descriptions and event text; canvas and chart titles; comments; language names, grammar notes and lexicon entries; media captions; random table entries; source titles and fields; stat block names, values, actions and notes; and voice script lines. Seventeen kinds of content, all of them.

Results are grouped by object, and each group says what kind of thing it is — "Codex entry — Coriander (4 matches)" — because two things can share a name and "4 matches in Ravens" does not say whether that is a chapter, a character or a scene. Each row says where the match is: Body, Alias, Cell B4, Line. Double-click a row to go there.

Replacing safely

A replace across the project is one undoable step: if it went wrong, one Undo takes all of it back. Each object changes as a unit, so a replace touching two cells of one sheet lands both or neither.

Match case is exact upper/lower case. Whole word matches whole words only, so searching "art" does not hit "start". Regex treats the search as a regular expression, in which case the replacement can use \1, \2 and so on to keep what was matched.

Choosing where to look

Five selectors, and they combine — every one you set has to hold.

• Search in — Everywhere, The current selection (the document you have open and the codex entry you have picked), or one kind of content: Documents only, Dialogue only, Spreadsheets only, and so on for all seventeen.
• Category — only codex entries in one category. Leave it on Any category to ignore it.
• Tag — only objects carrying one tag (Any tag to ignore it).
• Audience — only objects restricted to one audience (Any audience). An object with no audience set is visible to everyone and is not in a named audience, so this really does narrow to the handful marked for one readership.
• Status — only documents at one status (Any status). Nothing else has a status.

Every list is filled from your project, so you can only narrow to something that is actually there.

Narrowing before replacing is the point. A rename across a 300-object project produces more matches than anyone can read, and the alternative to a scope is running it everywhere and hoping.

See also: Jump to anything by name · Find everything you tagged · Find a line of dialogue

Open the Document Info panel from the Windows ▸ Writing submenu.

It holds the details a document carries besides its text — synopsis, status, and the other fields the Outline and Corkboard display.

Setting a status is what makes "which chapters are still first drafts" answerable at a glance.

Marking how far along a document is

The Status card is a drop-down with four ready-made steps — To Do, Draft, Revised and Final — plus a blank first entry, which means no status set and is what a new document starts on.

It is an editable box, not a fixed list: type anything you like over it — "needs a read", "with my editor", "cut?" — and that becomes this document's status. The four presets are there so a project that does not need its own vocabulary does not have to invent one; nothing is limited to them.

Status shows in the Outline and on Corkboard cards, so the state of a whole manuscript is readable without opening anything, and Find in Project can filter by it.

What else the panel holds

Each detail is a card: Point of view — whose eyes the scene is seen through, which the POV Balance analysis counts — Tension on a scale that starts at Unrated, and Target, a per-document word goal that starts at No target.

Scene date places the document on the timeline. A document with one appears as an event, which is how prose and chronology stay in step without maintaining the same fact twice.

Change Kind… turns a document into another kind — prose, folder, note — after the fact, for when something you started as a scene turns out to be a container. Edit Tags… is the same idea for tags: they are what saved searches and tag: filters look at.

See also: See the manuscript as an outline · Work with index cards

View ▸ Markdown Source Mode shows the Markdown your document is actually stored as, instead of the formatted view.

It is useful when you want to see exactly what will land in the file, or fix something the formatted view makes awkward.

The stored form is the same either way — this changes what you look at, not what is saved.

See also: Where does my writing live? · See the page as it will print

View ▸ Page Layout View lays the text out on pages with margins, rather than as a continuous column.

It is a view, not a mode you have to write in: your text is unchanged, and turning it off puts you back where you were.

For the real thing on paper, export a PDF.

See also: Export to PDF · Write without the rest of the app · See the Markdown behind the prose

1. Open the Style panel from the Windows menu with a document open.
2. Read the list. It covers the usual prose checks and your own house-style rules, so a banned word sits in the same list as everything else rather than in a separate report.
3. Click a finding to go to it in the text.
4. Fix it, or do not. Every item is a suggestion, and a style checker that is always obeyed produces flat prose.

It reports; it never rewrites. Nothing changes in your document unless you change it.

For the same material across the whole manuscript rather than one document, export a Health Report — it gathers style issues with statistics, readability and balance into one file you can read away from the app.

Right-click a finding

Go to Issue puts the cursor on it, and any fix the rule can apply itself is offered by name. Copy Description puts the wording on the clipboard, for a note to yourself or a bug report.

The rest is how you make one stop, at three widths:

• Ignore "…" — those exact words, wherever they appear in the project. This is the one for a habit you are defending: "I use 'very' on purpose." Offered for a short flagged span only.
• Ignore just this one — this single finding and no other. It is remembered by what is flagged rather than by where it sits, so it survives you editing the paragraph around it and does not come back the moment you add a line above.
• Ignore all … issues — the whole rule, for a piece of advice you have decided does not apply to this book.

One set of ignores, every surface. Silencing something here also clears its inline underline and removes it from the Conflicts panel, and an ignore made on a squiggle shows up here — they are the same list, not three lists that happen to agree.

Stop ignoring style issues brings everything back — there is always a way out, because a checker you have accidentally silenced is worse than a noisy one.

See also: Keep your spellings consistent · Export a manuscript health report · See the shape of your draft · Run a revision pass over a finished draft

Ordfoss has always been able to say which lines a reader could reach. Nothing said which ones anybody had — so a branch that works and has never been read by a human looked exactly like one played a hundred times.

Runs record themselves. Play a scene on the Play tab and the moment it reaches an ending the path is recorded. For a run you stopped halfway through — checking one branch, then moving on — press Record This Run and what you walked so far counts. Recording is undoable, so a run you did not mean to count is one Ctrl+Z away.

Forced steps are not counted. In Debug you can take a branch the story's own state forbids; that proves the branch reads well and proves nothing about whether a player can get there. A run is recorded up to its first forced step and no further.

Read the scene. The Coverage tab, beside Play, says how many of the scene's lines and branches have been walked and over how many runs, then lists what is left:

• Never played — a line a reader could reach and nobody has.
• Branch never taken — an option somebody stood in front of and did not pick. Branches out of a line nobody has reached are not listed: that line is already on the list above, and repeating its options would bury the decisions people actually made.
• Ending never reached — an ending no run has finished at.
• Nothing can reach this — listed last and worded differently, because it is not work for a tester. Nothing can arrive there, which is a defect the Problems tab reports; sending somebody to go and play it would waste their afternoon. This is the distinction the report exists for.

Double-click any row to select that line on the canvas.

See it on the graph. The eye button above the canvas rings every line no recorded run has walked. It is drawn around the node rather than filling it, so a line that is also a start node, or coloured by review state, still says all of those things at once.

Import what your game recorded. QA does not happen in the editor. Right-click the Coverage tab ▸ Import Recorded Runs… and pick a JSON file your build wrote:

{ "runs": [ { "scene": "<scene id>", "source": "Build 412", "nodes": ["<line id>", "..."] } ] }

The ids are the ones in the engine export, so a runtime that plays an exported script already knows them. A run naming no line this project has is reported rather than dropped in silence — that usually means the build is older than the script, and a silent import would show a coverage number that quietly ignored half of QA.

Starting again. Right-click ▸ Forget Runs of This Scene clears the runs that began here; Forget Every Recorded Run clears the project's whole testing record, and asks first.

See also: Write a branching, choice-based scene · Play a scene and watch the story change · Why an effect does nothing · Track who owns each line and how far it has been reviewed

1. File ▸ Manage Audiences… and register the readerships you need — Players and GM, or Beta readers and Everyone. Do this before writing much: marking a hundred existing entries afterwards is the tedious version of the same job.
2. Mark the material. Right-click a document or codex entity, choose Visibility…, and tick the audiences that may see it.
3. Leave the ordinary material alone. An object with no audience set is visible to everyone, so you only mark the exceptions.
4. Inside prose, use a GM-only Callout… for a passage rather than a whole document — it sits in the scene and drops out for other audiences.
5. Check it. Export with an audience selected and read the result, because the export is the thing that actually goes to someone.

The whole point is one project rather than two. Two copies of a manuscript, one with spoilers and one without, drift apart the first time you edit in a hurry.

See also: Audiences: who is allowed to see what · GM-only notes inside the prose · Export without the spoilers

Delete a node another one leads to and the link used to simply vanish — leaving a canvas that looked completely correct, while the only evidence was a line in the Problems list nobody was reading.

Now the graph says so. A link whose far end no longer exists is drawn as a short red dashed stub ending in a no-entry marker, hanging off the node that survived. It points away from the node so two broken links on one node do not sit on top of each other, and it is deliberately too short to reach the next box — a stub that ended under another node would read as a link between them.

Click the marker to select the node the broken link belongs to. That is the node you have to edit, and the one you cannot pick out of a canvas of identical boxes.

A jump or call is marked on its own box, in a red dash-dot outline, because its destination lives in a field rather than on a link — there is no line to hang a stub from. It is marked when the node it names is gone, when the scene it names is gone, and when it names nothing at all, which is where an unfinished jump starts.

Everything here doubles a finding that is already in Problems, deliberately: the list says it in words for somebody reading a list, and this says it where the author is actually looking.

See also: Write a branching, choice-based scene · Why an effect does nothing · See which branches have actually been played

A branch fifty nodes into the story is a branch nobody checks, because reaching it means clicking through the other forty-nine every time. Two things in the Play tab fix that.

Start somewhere else

The Start in box begins the run in a saved story state instead of at the story's own beginning. Walk to a state you care about, press Save Start…, and give it a name — "after the coronation", "poor and hunted". It records every variable as it stands. Pick it from the box any time and the run restarts there.

These never change your story. A variable's declared starting value is what the story actually begins from, and what every export, validator and analysis reads. A saved start is a lens for looking at the middle of a story without rewriting its beginning. Saving one under a name you have used before replaces it.

Debug

Tick Debug and the Play tab stops showing you only the ways a reader could go. It shows every way onward, including the ones the story's current state forbids, and each button's tooltip says why: "gold >= 50 is false — this way needs it true". That names the condition to go and look at, which "the branch is shut" does not.

Clicking a shut branch takes it anyway, marked — forced on the button. That is the practical way to check that the prose behind a gate reads well without first arranging the state that opens it.

A forced run says so. The transcript marks the step [FORCED]. A run that went somewhere the story forbade proves the branch reads well and proves nothing whatever about whether a reader can ever get there — and a transcript that did not say so would be evidence of a run that never happened. Stepping back off a forced step clears the mark.

See also: Play a scene and watch the story change · Make a branch depend on what happened · Write a branching, choice-based scene · Jump from one scene to another

A node can carry any number of tags — needs-vo, review, act 1 — and the canvas can be filtered to one of them.

Tag a node. In the Branching panel, select the node and either press the tag button on the panel's toolbar (the luggage label, beside the note button) or right-click the node and choose Tags…. The Tags window opens: Add… offers every tag already used anywhere in the project and lets you type a new one, Remove takes one off. Press OK. It is one undoable step — Edit ▸ Undo puts the tags back as they were.

Tags are free-form, and they are the project's one vocabulary: the tag you put on a character in the codex and the tag you put on a line are the same tag. They match without regard to case, so Needs-VO and needs-vo are one tag; the spelling you typed is the one you see.

Filter the graph. The box at the right-hand end of the Branching toolbar reads All tags. Choose a tag and every node that does not carry it fades back; the nodes that do carry it stay at full strength. The faded nodes are still there and still editable — filtering is a way of looking at the scene, not a lock on it, and hiding them outright would leave every link that runs through one as a line to nowhere. Choose All tags again to clear it.

The box lists only the tags actually used by nodes in the scene you are looking at, so it is a list of what this conversation is marked with rather than of everything in the project.

Where else tags show up

• Hover a node and its tags are on the tooltip, under the note.
• Search. Type tag:needs-vo into File ▸ Quick Open… or the search box and the tagged nodes come back with everything else carrying that tag. Quote a tag that contains a space: tag:"act 1". See Find everything you tagged.
• Exports. File ▸ Export ▸ Dialogue Script… carries them into the script. In ink each tag is written under the knot as # tag: needs-vo. In Yarn they go in the node header as tags: needs-vo — Yarn tags cannot contain spaces, so act 1 is written act-1 and the export report says so, line by line.

A tag is not a note and not a comment. A tag is a label you sort and filter by, so it is worth reusing the same few. A note (right-click ▸ Note to Yourself…) is a sentence only you read. A comment is a conversation about the node that someone else answers.

See also: Find everything you tagged · Note to Yourself on a dialogue node · Write a branching, choice-based scene · Export your branching scenes as ink or Yarn Spinner · Find a line of dialogue · Comment on one line of dialogue

1. Open the Voice panel from the Windows menu and create a script.
2. Add lines. Type them, or pull them from a branching scene — every spoken node becomes a line, and pulling a second time keeps takes already recorded rather than wiping them.
3. For each line, set who speaks it: right-click and choose Who Speaks This…, and pick the character or Narration. A line typed by hand has no speaker until you do this, and casting depends on it.
4. Cast the Character… attaches an actor to that character. A cast crosses every script, so you do this once per character rather than once per line.
5. Export the line list as a CSV the studio can open.
6. On the recording day, Log a Take… against each line as it is recorded — take number, director's note. The first take is marked as the chosen one automatically.
7. Log more takes as needed, then Use This Take on the one you are keeping.
8. Watch the Status column. It is worked out from the takes, so it moves on its own.

The reason to bother with all of it: if you later rewrite a line that has already been recorded, its status changes to needs pickup by itself, and the takes pane marks the stale take. Nothing else in the project would notice that the recording no longer matches the script.

See also: Voice-over scripts and takes · Write a branching, choice-based scene · Author a branching scene end to end

There is no play mode you click through, and that is deliberate rather than missing. Clicking one path only ever tests the path you clicked, and the branch you forgot is the one that is broken.

The Problems tab beside the graph simulates the scene as you build it, and it explores every choice rather than one. A Choice is the reader's decision, so the walk follows all its options — the branch behind the option you did not take is exactly the one you want told about. A Condition is the story's decision, so only the branch the variables permit is followed, and that is what makes a never-taken branch visible.

What it reports

• A scene with no start node — nothing has an entry point.
• A node nothing can reach from the start.
• A node that leads nowhere: an ending, or an unfinished branch.
• A choice with fewer than two options.
• A condition that tests no variable, so it can never decide anything.
• A condition testing a variable the project no longer has.
• A jump, or a link, pointing at a node that is not in this scene.
• A node with no text yet.

And the one you would never find by hand

“is connected, but no playthrough can reach it — every path in is gated by a condition that is never true.” That node looks perfect on the canvas: arrows point at it. No reader will ever see it. Nothing but simulating the scene finds that, which is the reason the simulation exists.

Double-click any finding — or right-click it and choose Show the Node — to jump to the node it is about.

A condition on a variable that is missing counts as false rather than stopping the walk. The list above already reports the missing variable, and refusing to run would tell you the same thing twice while denying you the walk that shows what else is wrong.

See also: Make a branch actually change something · Write a branching, choice-based scene · Make a branch depend on what happened

Real dialogue conditions test things the game owns — inventory, player class, faction standing, level, world flags. Declare one as a variable the game supplies and you can use it in any condition without keeping a shadow copy in step by hand.

Declaring one. In the Branching panel's Variables tab, right-click → New Variable…. Answer the usual questions — name, what it holds, its starting value, how long it lasts — and then the last one: Supplied by the game? Give the key it comes under (player.level, faction.thieves_guild) and leave it empty for a variable this story owns. The Supplied by column then reads The game — player.level instead of This story.

The starting value becomes the default a playthrough uses. There is no game answering while you are walking a scene in the Play tab, so it reads what you declared. Set it to whatever makes the branch you are testing reachable.

Conditions read it; effects must never write it. playerLevel >= 5 is as ordinary a condition as gold >= 50. But a host that is the real authority on player level will not read a value back from the story, so a node effect that set it would be silently discarded at runtime — the Problems tab reports “…” writes a variable the game supplies, which the game will not read back. That is the one rule that makes the binding worth having.

A binding key is the contract, so a variable marked as supplied by the game with no key is reported too: A variable is marked as supplied by the game but says nothing about how the game supplies it. Nothing can implement it, and every condition on it reads the default for ever.

Handing the contract to your engine. File › Export › Game Data… offers Variables the game supplies as a slice: every external variable with its binding key, its type, its default and your description, sorted by key so two exports diff cleanly. That file is what a programmer implements against — the same thing ink does with EXTERNAL declarations and Yarn does with its variable storage interface, except you write it in the editor rather than in the code.

See also: Make a branch depend on what happened · Make a branch actually change something · Write a branching, choice-based scene · Export your world for a game engine

Open the Branching panel and choose the Quests tab. Right-click → New Quest….

A quest is a codex entry. The window's first question — This quest is: — picks one, and its description, audience visibility and properties live on that page, exactly like a character or a place. Nothing about a quest is a second copy of the codex. Make the codex entry first if it does not exist yet.

Its states are yours, comma-separated, in order: Unassigned, Active, Success, Failure is the usual set, but an investigation might want Unheard, Suspected, Proven, Disproven. The first one is where the quest starts. There is no fixed vocabulary, because no fixed vocabulary survives contact with a real story.

Objectives are the lines in the journal — Find the ledger, Confront the harbourmaster — and each has its own states. That is the point: one line can be complete while the next is still active and a third was never offered. Add Objective starts a new line from the quest's own states, which is usually what you want; edit the cell if that objective needs different ones. Remove Objective takes the line and the state it held.

Advancing it from dialogue. Right-click a node → Effects… → add an effect. The variable list shows quests by name — Rescue the Cartographer: Find the ledger — and picking one turns the value box into that objective's own states, so you choose from the list you wrote rather than typing a state and misspelling it. The node body on the graph then reads Rescue the Cartographer: Find the ledger = Complete.

Watching it. Quest state is ordinary story state, so the Play tab's variable table shows it changing as you walk the scene, and a Condition node can test it — rescue1 = "Complete" — the same as any other variable. The Variables tab shows quest rows under the quest's own name, with the identifier an expression must use in the tooltip.

Deleting a quest deletes the variables holding its state, and says how many before it does. Any effect that set them stops meaning anything, and the Problems tab reports those. Edit › Undo brings the whole thing back — the quest and its variables together, in one step.

Exporting. File › Export › Game Data… offers Quests as a slice: every quest, its states, each objective and the variable name its state lives in — so a runtime rendering a journal knows which piece of story state to read for each line. Quest state also saves and reloads with the project like everything else.

If a quest shows as “(missing quest)”, its codex entry has been deleted. The Problems tab says so; re-point the quest at a codex entry, or make the entry again.

See also: Write a branching, choice-based scene · Make a branch depend on what happened · Make a branch actually change something · Export your world for a game engine · Play a scene and watch the story change

On a team every line has a state — drafted, reviewed, approved, locked, needs rewrite — and somebody answerable for it. Ordfoss records both on the line itself, so "how much of this scene is signed off" is a number rather than a meeting.

Declare your states first. The Review tab, at the bottom of the Branching panel beside Budgets and Play, holds them. Right-click ▸ Use the Standard States takes the five above in one gesture; right-click ▸ Add State… writes your own. Each state has a name in your team's words, a colour, and a tick for whether work in it counts as signed off — which is what "not yet approved" means when you filter by it, and what the scene's approved count adds up. A project that declares no states simply does not track review, and nothing changes for it.

Mark a line. Right-click a node ▸ Review State…, choose the state and type or pick an owner. The owner is a name, matching the one your comments are signed with (Preferences ▸ Review), so "everything of mine" works with no accounts to set up.

Read the scene. The Review tab says, above the table, how many of the scene's lines are signed off, and lists every state with how many lines are in it — including the states nobody has used yet, because a pipeline stage that vanished when it was empty would read as a stage you do not have. Only lines are counted: a condition or a jump is structure, and nobody signs off a fork.

Find what is left. Above the canvas, the review-state chooser offers Not yet approved — the question a lead actually arrives with — as well as each state on its own, No state yet, and Any state to stop narrowing. Beside it, the owner chooser offers Mine first, then everyone with a line in this scene, then Nobody yet for the unclaimed ones and Anyone to stop narrowing. Use the two together for "everything of mine that is not yet approved". Filtered-out nodes fade rather than disappear, so the shape of the scene stays readable and you can still edit what you filtered to.

See it at a glance. The highlight button beside the choosers paints every line in its state's colour. It is a way of looking rather than a setting: it starts off each session, and a node that is unreachable or leaves the scene still says so through its outline while it is coloured.

Renaming a state carries the lines with it, in one undoable step across the whole project. If you remove a state that lines still carry, Ordfoss says how many first; those lines keep the word and are reported in Problems as a state the project does not declare, so they are never quietly counted as unreviewed.

One vocabulary, everywhere. The same states appear in the document inspector's Status box, so a chapter and a line of dialogue are marked from one list. A project that has declared none still gets the old suggestions there — To Do, Draft, Revised, Final.

See also: Write a branching, choice-based scene · Tag a line of dialogue, and filter the graph by tag · Comment on one line of dialogue · Keep lines inside a length or time budget

Make a script and get lines into it

1. Open the Voice panel from the Windows menu.
2. Press Create a Script (or the + button on the toolbar). The picker at the left of the toolbar chooses which script the table below shows.
3. Add lines one of two ways: the Add a line to this script button types them in, or right-click in the table and choose Pull Lines from a Scene… to take every spoken node out of a branching scene at once, so dialogue written there is not typed twice.

Say who speaks each line

1. Select a line and use Who Speaks This… from its right-click menu to name the character, or mark it Narration when nobody in the codex says it.
2. Cast the Character… attaches an actor to that character. The Character and Actor columns both matter — you work in character names, the studio schedules by actor.

Log takes as they are recorded

1. Right-click the line and choose Log a Take…. Give it the take number the studio used, and a director's note if there is one.
2. When one is the keeper, choose Use This Take. The Takes list beside the table shows every take against the selected line, with the chosen one marked.

Change or remove a line

Edit the selected line (the toolbar's rename button, or Edit Line… from the right-click menu) rewrites the text. Do this and any take already recorded against it becomes a pickup -- see below, because that is the point of the Status column. Remove Line deletes the row and every take logged against it, and asks first.

What the Status column tells you, without anyone maintaining it

Status is worked out from the takes every time it is drawn, never stored — so it cannot drift. To record means no takes. Recorded means takes exist but none is chosen. Approved means a take is chosen and matches the line as it currently reads. Needs pickup means the chosen take was recorded against text you have since rewritten: it still plays, still sounds fine, and is now wrong. That last one is the whole reason the feature exists.

The header totals them — "3 to record, 8 recorded, 12 approved, 1 need a pickup" — so you can see where a session stands without reading every row.

Send it to the studio

1. Export the line list as a CSV the studio can open writes line number, character, actor, the line, its status, take and note. A director, session engineer or agent opens it in Excel or Sheets and prints it.

The status column is computed at the moment you export, so the list is true when it is sent rather than when somebody last remembered to update a field.

A take whose audio has not been imported yet shows Not imported yet — a normal state on a recording day, not an error.

Managing scripts and takes

The script toolbar has Rename the current script and Delete the current script; deleting takes its lines with it.

Remove Take drops one recording of a line. Takes are kept per line rather than per script, so removing a bad take leaves every other line's recordings alone -- which is why re-recording one awkward sentence does not cost you the session.

See also: Have your prose read back to you · Line IDs, and why a recording survives a rewrite · Write a branching, choice-based scene · Export your manuscript

Add Node… asks What kind of node? and offers seven. The kind decides what the node does when a reader reaches it, and what else you can then set on it.

• Line — something the reader is shown. Most of a scene is these: the prose, a line of dialogue, a description. It has one way out.
• Choice — options the reader picks between. Each outgoing link is one option, and each option can carry a condition of its own so it only appears when it should.
• Condition — the story decides rather than the reader, based on a variable. Two links leave it, labelled When the condition is true and When the condition is false.
• Jump — sends the reader to another node and does not come back. Use it to rejoin a thread or to move into another scene entirely.
• Hub — a place paths come back to. Ten branches that all end up at the same conversation point at one Hub instead of each carrying its own copy of what happens next.
• Call a scene — runs another scene from here and does come back afterwards, which is the difference from a Jump. Use it for anything reused: a shop, a save prompt, a stock exchange.
• Return to caller — where a called scene hands control back to whoever called it.

Picked the wrong one

Change Type… converts a node in place. It drops what no longer applies — a node that stops being a Condition loses the variable it was testing, one that stops being a Jump loses its target — so changing your mind twice can never quietly resurrect a setting you had forgotten about.

Line and Choice are the two you will use most. The rest are structure: Condition and Hub shape the path, Jump, Call a scene and Return to caller connect scenes to each other.

See also: Write a branching, choice-based scene · Make a branch depend on what happened · Reuse a scene — call it and come back · Jump from one scene to another

Effects… ▸ Add… opens a single form rather than a chain of questions, so you can change an earlier answer without starting again.

• Variable: — which one this effect writes. It lists the story variables the project has declared; if it is empty, declare one on the Variables tab first.
• What it does: — the operation. Underneath it, a one-line note says what that operation will do when the reader arrives — "A negative amount subtracts: −10 takes ten away", "Yes becomes no, no becomes yes", "Back to the value its declaration starts at, which is not necessarily zero" — so you do not have to remember which of the five is which.
• Value: — what to write. The box itself follows the variable's type: a No / Yes picker for a yes/no variable, a number box, a plain text field, or, when the variable holds a quest's state, that quest's own list of states rather than free text.
• Amount: — the same row, renamed, when the operation is Add to it. It is renamed because the number means something different: a difference to apply, not a new value to store.
• Copy from: — appears instead of Value, only for Set it to another variable, and offers the other variables of the same type.

Why a row vanishes

The bottom row is not hidden and greyed; it is not there. Flip it and Reset it to its starting value take no operand at all — nothing to type — so the form is two rows for them. That is deliberate: a disabled box you cannot use still looks like something you have failed to fill in.

When Copy from has nothing to offer

If the project declares no other variable of the same type, the form says so — "This project declares no other number variable to copy from" — and OK stays disabled. Saving would write an effect that names no source, which the Problems tab would then report as broken: a defect you never chose to make. Declare the second variable first, or pick a different operation.

See also: Make a branch actually change something · Make a branch depend on what happened · Why an effect does nothing · Track a quest, and advance it from dialogue

An effect the story cannot carry out is skipped rather than guessed at — the simulation will not invent an answer, because a walk that did would explore a branch no reader can reach. That leaves nothing visible on the canvas, so the Problems tab beneath the graph is what tells you.

Open the Branching panel and look at Problems. Four findings are about effects.

"…has an effect that names no variable"

The effect was never finished. Right-click the node, choose Effects…, select the row and either Edit… it to name a variable or Remove it.

"…sets a variable this project no longer has"

You deleted the variable after writing the node. Either declare it again on the Variables tab — same name is fine, but the effect points at the old one by id, so you must re-pick it in Effects… — or remove the effect.

"…copies from a variable this project no longer has, so it writes nothing"

The Set it to another variable operation reads a source, and that source is missing or was deleted. This is reported separately from the finding above on purpose: the destination is still fine, which is exactly why the node looks like it works. Open Effects…, edit the row, and pick a source under Copy from.

"…has an effect that does not suit its variable's type"

Adding to a yes/no variable, flipping a number, or copying a name into a counter. None of them has an answer the story could give, so none of them happens.

The editor will not let you build one — it only offers the operations a variable's type can carry, which is why Add to it does not appear for a yes/no and Flip it does not appear for a number. A project can still acquire one through an import or through an MCP call, and that is what this finding is for. Open Effects…, edit the row, and either pick a different operation or point it at a variable of the right type.

Why this matters more than it looks

Every one of these leaves a node that draws exactly like a node that works. The only symptom is a condition somewhere downstream that never fires — often branches away from the cause, and often discovered as "this whole section of my scene is unreachable". Checking Problems first will save you the hunt.

Related: Make a branch actually change something · Story variables · Testing a branching scene

See also: Make a branch actually change something · Make a branch depend on what happened · Test a branching scene and find the paths that are broken · Write a branching, choice-based scene

Make a scene and put nodes in it

1. Open the Branching panel from the Windows menu.
2. Press Create a Scene (or the + on the toolbar). The picker at the left chooses which scene the graph shows.
3. Add nodes with the Add a node button, or by right-clicking the canvas and choosing Add Node…. It asks What kind of node? and offers seven — Line, Choice, Condition, Jump, Hub, Call a scene and Return to caller. See what kinds of node a scene can hold for what each one is for.
4. Edit Text… on a node writes the words the reader actually sees — the node's label on the canvas is a handle, not the prose. Change Type… converts one type into another if you picked wrong.

Jump To…, on a Jump node, chooses which node it sends the reader to. A jump to itself is not offered: a loop with no exit reads to the reader as the story hanging.

Link them up

1. Select two nodes, then use Link Selected Nodes. The link runs from the first you picked to the second, so selection order is the direction.
2. Links Leaving This Node… lists what leaves a node and lets you relabel or remove each one. On a Condition the two links are labelled When the condition is true and When the condition is false — labelled, not ordered, so rearranging them can never invert your story.
3. Start the Scene Here marks where a playthrough begins.
4. Arrange Automatically lays the graph out top-down when it has become a tangle.

Check it as you go

The Problems tab beside the graph simulates the scene while you build it and reports what is broken — including a node that is connected and still unreachable in play. Testing a branching scene covers what it finds and why there is no click-through play mode.

Then

Dialogue written here need not be retyped for recording: the Voice panel's Pull Lines from a Scene… takes every spoken node out of a scene at once. And to make a branch depend on what happened earlier, declare a story variable first — the Variables tab is beside Problems, and a Condition has nothing to test until one exists.

Making and naming scenes

Right-click the canvas for New Scene… — a scene is the container a set of linked nodes lives in, so a story with three chapters of choices is usually three scenes rather than one large one. Rename Scene… retitles the one you are in; the title is what the scene picker and any jump target show, so it is worth naming them for where they happen rather than "Scene 2".

Where a scene begins, and getting rid of one

Start the Scene Here on a node makes it the entry point -- the node a reader arrives at. Every scene needs one, and the Problems tab reports a scene that has none, because a scene with no start is unreachable rather than merely untidy.

The scene toolbar has Rename the current scene and Delete the current scene, and the canvas menu has Delete Scene. Deleting takes the nodes with it, so it is the one to be sure about.

See also: Make a branch actually change something · Test a branching scene and find the paths that are broken · Make a branch depend on what happened · Voice-over scripts and takes · Reuse a scene — call it and come back · What kinds of node a scene can hold

Open the Barks panel. It is a table, not a graph — a large share of a game's lines are one-offs triggered by state (“Halt!”, “Mind the step”), and drawing a box for each of a thousand of them makes a canvas nobody can read.

Collections. Press New Collection… to start a named set — Town guards, Combat, Idle chatter. A project holds several, because a collection is what you work through in a sitting and what stays reviewable in version control, instead of one enormous file every change touches.

Each column. Line is what the reader hears. Speaker links to a codex character (the same link a dialogue node uses, so renaming them in the codex does not orphan six hundred barks). Trigger tags are what the game keys on — combat/start, enter/tavern — several per bark, comma-separated; the vocabulary is yours, since no list written here would survive contact with a real game. Only when is a condition over the story's variables, in the same language a branching condition uses. Once means it may play only once for a reader — a reveal, a warning, a joke that lands once. Cooldown (s) stops it repeating in the same breath. The two are different problems, which is why they are separate.

Adding in volume. Add Bark adds one and starts typing. Add Many… takes a whole block — paste or type one bark per line, choose a speaker and tags that apply to all of them, and set anything individual in the table afterwards. That is faster than answering six questions per line, which is what sends people back to a spreadsheet.

Finding one. The Speaker and Tag filters narrow the table, and the counter beside them says “12 of 200 shown” — so a filter left on is never mistaken for barks that have gone missing. Set the speaker filter back to Anyone to stop narrowing; Anyone is also what a bark's own Speaker column says when the line belongs to nobody in particular, which is the right answer for a crowd murmur or a sign. Editing is in the table itself; there is no per-line dialog.

Export Table… writes a CSV a spreadsheet opens: line, speaker, tags, condition, once, cooldown. It exports the whole collection, not the filtered view — an export that quietly honoured a filter is how a studio receives two-thirds of a recording list and finds out at the session.

Why not just use a spreadsheet? Because a bark here is connected to everything else. It appears in Find in Project and in find-and-replace, so renaming a character reaches every bark that names them. It goes to a translator with its speaker as context, alongside your graph dialogue. And it pulls into the Voice panel as a recordable line that keeps its takes when you fix a typo — matched by identity, not by its words, which is precisely what a spreadsheet cannot do.

See also: Write a branching, choice-based scene · Say who speaks a line, and how they say it · Voice-over scripts and takes · Send your book to a translator

View ▸ Distraction-Free Mode puts the text on screen and takes the rest away. Esc brings it back.

Two related modes sit beside it. Typewriter Mode keeps the line you are writing at a fixed height instead of letting it drift to the bottom. Focus Mode dims everything except the sentence or paragraph you are in.

They compose — you can have all three at once if that is how you work.

See also: Write against a timer · See the page as it will print · Put the window arrangement back

Some facts are not one value. A faction has members, a character speaks languages, a creature resists several damage types by a different amount each. Written into a text field those are a sentence with commas in it: nothing can count them, put them in order, or notice when one of the people named in them is deleted.

Two property types hold them properly.

• A list holds many entries of one kind, in an order you choose.
• A map holds pairs — each key with its own value.

Declare one

1. Right-click a category (or an entity) in the Codex tree and choose New Property….
2. Give it a Name.
3. Set Type to list or map.
4. Set Each entry is a — a map calls it Each value is a — which is what every entry must be: text, number, boolean, date, reference, choice or url.
5. A map also asks Each key is a.
6. A list may set At least and At most, and tick Every entry must be different. Leave both counts at no limit if there is no rule to state; that is the default.
7. Press OK.

Choosing reference as the entry type is the interesting one: the entries become links, so a faction's members are the actual characters, and deleting one is reported instead of quietly leaving a name behind. Picking it also shows the Points at row — name a category there to limit the entries to it, exactly as for a single reference property.

Fill one in

Open the entity in the Codex and expand the property's card.

• Add entry — a map says Add pair — puts a new, empty row at the bottom.
• Each row is edited with the control its type deserves: a drop-down of entities for a reference, a tick-box for a boolean, a box to type in otherwise.
• ↑ and ↓ move an entry up and down. The order is yours and it is kept.
• ✕ removes that entry, or on a map that pair.

Every edit is a single step on the undo stack, so Edit ▸ Undo puts the property back.

If At most is set and the list is full, Add entry goes dim rather than letting you type an entry that would be refused afterwards.

See what gets checked for the findings a list or map can raise, and for the two things a list deliberately will not do.

Through the AI

add_field(category, label, type: "list", element_type: "reference", reference_category: "Character") declares one; min_count, max_count and unique state the rules. Setting values is a plain JSON array — update_entity(entity: "The Guard", fields: {"Members": ["Beregond", "Bergil"]}) — and references inside it resolve by name, so the AI never has to know an id. A map takes a JSON object: {"Resistances": {"fire": 50, "cold": 10}} — set that way its pairs come out sorted by key, because a JSON object has no order to keep; arrange them yourself in the codex if the order matters. Reading an entity back names the targets rather than printing their ids.

See also: Properties, and who they belong to · A property that points at another entry · Make a number behave like a number · What a list or map gets checked for

A Reference property holds a link to another entry rather than text you type. "Home town" on a character points at a place; "Member of" points at a faction. The link is the real thing, so renaming the target keeps the reference pointing at it.

What it may point at

A reference offers Anything in the project by default, which is what every reference in every existing project already is. Naming a category instead limits the choices to that category and anything filed beneath it — so "Home town" offers places, and the cities and villages under Places, rather than every entity you have ever written. That is the difference between a picker you can use and a list of your whole world.

Restricting changes the choices, not what is already stored. A value the new restriction excludes — because the property was narrowed after it was filled in, or the target was moved — is still offered and labelled (outside this property's category). A picker that quietly showed "none" instead would delete the value the next time anybody touched it.

Empty, and never itself

A reference can be left at — none —, which is what an unset one shows: the property exists and points at nothing yet. That is a different state from a property you have not added.

An entity is never offered as its own reference, because pointing a thing at itself says nothing.

Where a property BELONGS — the entity, the category, and what inherits it — is the codex-properties entry. This is only about what the value may be.

See also: Properties, and who they belong to · Add a character or place · See how your characters connect

Right-click in the Codex panel and choose New Entity…, or use the New menu at the top of the panel.

An entity belongs to a category — Characters, Places, whatever you have defined — and picks up the properties that category gives it.

If you make the same shape of entry often, save one as a template and create the next from it.

Dates a character lives between

Lifespan… records Born and Died in your project's own calendar. Those dates are what the timeline validates against, so an event that happens before a character is born or after they die is reported as a conflict rather than sitting unnoticed.

Each of the two rows starts with a Known tick box, and the year, month and day beside it stay greyed out until you tick it. That is how you say "not settled yet" -- you leave Known unticked rather than clearing a field, because there is no blank to leave. Untick it later and the date is dropped again, which is the same thing said in reverse: an open death date is a normal state for a story in progress, not missing data, and only the ticked ones are validated.

The month list is your project's own calendar, and the day box adapts to the month you pick -- a 28-day month will not let you type 30.

Deleting one

Delete Entity removes it, and Edit ▸ Undo brings it back with its properties and links intact. What it does not restore is anything that referred to it: a reference elsewhere pointing at a deleted entity is reported by the validator, so a deletion never fails silently.

Where an entity is referred to, Open the referenced entity jumps to it, which is how you follow a chain of relations without going back to the tree each time.

Renaming, moving between categories, merging and splitting each have their own answer -- see rename-and-move and merge-and-split-entities.

See also: What is the codex? · Organise the codex into categories · Reuse the same shape of entry

A sword can be an Item and a Cursed Object. A character can be a Character and a Faction Leader. Until 0.3.0 you had to choose: duplicate the second set of properties onto the first category — giving them to everything in it — invent a combined category for every pairing, or keep the second role as loose text nothing could check.

An entry now carries as many categories as it needs.

Its primary category still decides where it lives. The sword sits under Items in the codex tree, once, because a thing shown in two places is a thing you lose track of which copy you edited. Everything else is what it also is.

Make one two things

1. Select the entry and find the Also a card in the Inspector.
2. Pick a category from — add a category —.

Its properties appear immediately, each labelled with where it came from: Price from Item, Curse from Cursed Object. Removing the entry from a category takes that category's properties back off it — the values are kept, so putting it back restores them.

When two categories declare the same property

The first one wins, and the other is marked shadowed with a note saying so. Use ↑ in the Also a card to change the order and so change which wins. Nothing is silently dropped: two categories that both declare "weight" usually mean different things by it, and you should be told rather than shown one at random.

Everything that knows about a category knows about this

• A validation rule written for Items catches the sword, even though Item is not where it lives.
• The category's spreadsheet lists it.
• Tidy Up Properties counts it as a user of the category's properties, so it will not offer to take one away that the sword is relying on.
• Its own category's properties are unaffected — nothing else in Items gains a Curse.

Through the AI

update_entity(entity: "Sting", also_categories: ["Cursed Object"]) sets the list, in the order they apply; [] clears it. The categories must already exist — a name that matches nothing is refused rather than created, because a second category names something that already means something and inventing one from a typo would give the entry a type nobody defined. get_entity labels each property with the category it came from, and list_category includes everything that carries the category, not only what lives in it.

See also: Organise the codex into categories · Properties, and who they belong to · Add a character or place · Edit a codex entry's fields

Narrowing the graph down to the question you are asking is the relationships entry. This is what to do with what is left.

Layout

The three arrangements answer different questions. Force-Directed spreads an arbitrary graph so you can see its shape. Hierarchical lays out a family tree or a chain of command top-down. Radial rings a focus by depth, which is the one that pairs with Focus Here and Expand Neighbours.

Reset Layout discards the arrangement and lays it out again from scratch.

When you have lost the graph

Panning and zooming a large graph gets you somewhere with nothing on screen, and it looks like the view has broken. Fit in View scales and centres the whole graph so everything drawn is visible again — the way home rather than a zoom level. The timeline uses the same command with the same name, for the same reason.

Reading it at a glance

Colour by category fills each node with its entity category's colour and shows a legend, so a graph of a hundred entities reads as groups rather than as a hundred labels. It is a view setting — it changes nothing about the entities.

A grey Uncategorized swatch appears in the legend when any entity on the graph is not filed under a category. It is worth noticing rather than styling away: an uncategorized entity inherits no properties from anywhere, so it is usually one that was created in a hurry and never put somewhere.

Getting it out

Save Image… writes the graph as it is currently drawn — focus, filters, layout and all — to a picture file, which is how a relationship map gets into a document or a pitch. What you export is what you narrowed to, so the narrowing is worth doing first.

If the file cannot be written — a folder that is gone, a drive that is read-only — it says so instead of finishing quietly, so a missing picture is never something you find out about later.

See also: See how your characters connect · What is the codex?

Properties used to belong to a whole category whether you meant it or not, so an older project can carry empty slots on everything.

Opening such a project offers, once, to move properties only one entity ever used down onto that entity. It backs up first, it never changes a value, and one Undo puts it all back.

For the rest, right-click the codex and choose Tidy Up Properties…. Each property can be removed, kept on a category you pick, or handed to a single entity. Nothing is chosen for you and anything you skip is left alone. The same window also finds categories that are one category written two ways and offers to merge them.

What you choose for each property

The wizard lists what it found and leaves every decision to you. Each row offers three:

• Remove it — the property goes.
• Keep on a category — it becomes a property of the category, so every entity in that category inherits it.
• Keep on one entity — it stays on the single entity that actually uses it.

Rows start at — choose — and nothing happens to a row you leave there, so you can work through a long list in several sittings without it acting on the ones you have not decided.

Getting out of it, and getting through it faster

Not Now closes the wizard without changing anything -- it is offered because the wizard can appear when you opened the project to do something else, and dismissing it must not count as a decision.

Use my next choice for every property still unanswered applies whatever you pick next to the whole remaining list. It is the way through a long tidy-up when the answer really is the same for all of them, and it only touches rows you have not already decided.

The offer you get on opening an older project

Tidy Up runs the one-time move described above; Leave Them declines it. Declining changes nothing and loses nothing — the wizard is still on the codex's right-click menu whenever you want it, so there is no cost to saying no while you are in the middle of something else.

See also: Properties, and who they belong to · Organise the codex into categories

The Inspector panel shows whatever you have selected in the codex and lets you edit its properties.

Select an entity and its fields appear; select a category and you edit what that category defines for everything beneath it.

It is the main place codex work actually happens — the tree chooses, the Inspector edits.

The gallery on an entity

An entity's images live in the Inspector, and the picture that represents it everywhere else is whichever one is first. Right-click any image for Set as Cover, or Move Left and Move Right to reorder — those are the same thing said two ways, and reordering is how you change the cover without hunting for a setting.

Link Existing Image… attaches a picture already in the project rather than importing another copy of it, which is what you want when several entities share one map or crest.

Aliases

The Aliases card holds the other names an entity goes by, comma-separated — Strider, Elessar. They are not decoration: prose is matched against them as well as against the entity's name, so a paragraph that calls him Strider still links to Aragorn, and a search for either finds him.

Mentioned in and Mentions

A free-text field that names other entities grows a Mentions: row inside its own card, listing each one as a link you can click to jump there. It sits in the field's card rather than in a row of its own so it is always obvious which field the links were read from.

Mentioned in is the other direction: the entries whose prose or fields point at this one. Together they are how you walk a world without searching for anything.

See also: Properties, and who they belong to · Add a character or place · What is the codex?

Editing fifty entities one at a time in the Inspector is the slow way. A bound spreadsheet is the fast one.

1. Open the Spreadsheet panel from the Windows menu.
2. Build a data table from the category — the toolbar button does it in one step — or bind an existing sheet with Codex ▾ ▸ Bind to Category….
3. Edit in the grid. Each row is one entity and each column is one of the category's fields.
4. Codex ▾ ▸ Save Selected Rows to Codex writes back only the rows you highlighted.
5. When you trust it, Save All Rows to Codex does the lot.

Do a couple of rows first and look at the result in the codex before saving all of them. The write is undoable, but checking is cheaper than undoing.

The header row is the field names. Renaming a header does not rename a field — it is the binding that decides which column is which.

See also: Turn codex entities into a spreadsheet · Keep a spreadsheet in your project · Properties, and who they belong to

This answer has not yet been checked against the application.

Some facts arrive in sets. A creature has stats; an item has a cost breakdown; a place has coordinates. Written as loose properties they are held together by nothing but their names — statsStrength, statsDexterity — so adding a seventh stat means editing every category by hand, nothing can say "this list holds coordinates", and an export hands whoever reads it a flat bag of keys to reassemble by guesswork.

A property block is that set, given a name.

Define one

1. Right-click in the Codex tree and choose Property Blocks….
2. Press New Block… and name it — Stats.
3. With it selected, press Add Property… for each property it holds. The form is the same one the codex uses, so a block's property can be any type: text, number, reference, a list, or another block.
4. Move Up and Move Down put them in the order you want them read. That order is what every entity shows.

The line under the lists says how many properties across the project use the block. Every change you make here reaches all of them — that is the whole point of it, and it is said before you edit rather than after.

Use it

Add a property as usual (New Property…), set Type to block, and pick your block under Group of properties. One property; the whole set.

Open an entity and the block's card shows a labelled row per property, ready to fill in — a property you have never filled in still gets its row, because the block's definition is what draws the form.

A list whose entries are blocks is how you say "this recipe has several ingredients, each with a material and a weight": set Type to list and Each entry is a to block.

Reach inside one

A value inside a block is named with a dot: stats.strength. That path is how a rule, a rollup, a search column or an export names one value in the group, and it means the same thing in all of them.

Renaming and deleting

Renaming a block changes only what it is called — every property using it keeps using it, because a property points at a block by identity rather than by name.

Deleting one asks first, and says how many properties will be affected. Those properties keep their values and are reported in Conflicts until you point them at another block or bring the old one back with Edit ▸ Undo. See what can go wrong.

Through the AI

property_block(name: "Stats") defines one and property_block(action: "add_property", name: "Stats", label: "Strength", type: "number") fills it; action: "list" shows what there is. Then add_field(category: "Character", label: "Stats", type: "block", block: "Stats") gives a category the group, and update_entity(entity: "Beregond", fields: {"Stats": {"strength": 14}}) sets values. Exports write a block as a nested object, so a game engine receives a structure rather than six flat keys.

See also: Properties, and who they belong to · The New Property form, row by row · A property that holds many values · What can go wrong with a property block

1. Select the entity — in the Codex panel, or by clicking its name in the prose.
2. Edit ▸ Next Mention moves to the next place it appears in the manuscript.
3. Edit ▸ Previous Mention goes back.

It is how you re-read every scene a character is in without searching for their name and wading through false matches.

Mentions follow aliases, so a character written as "the smith" for three chapters is only found in them if "the smith" is on the entity as an alias. If a mention seems to be missing, that is the first thing to check.

See also: Track a character through the book · Add a character or place · Search and replace across the whole project

Names in your prose connect to the codex, and you can make that connection from the writing rather than from the codex.

1. Select the text — a character's name, a place.
2. Right-click and choose Create Entity from Selection to make a new codex entry named after it, already linked.
3. Or choose Link to Existing Entity… to point it at an entry you already have.
4. Remove Link takes the connection away again without touching the words.

A linked name takes you to the entry when you follow it, and the entry knows the passage mentions it.

Ordfoss also finds mentions on its own by matching names and aliases, so you do not have to link everything by hand. Linking explicitly is for the cases matching cannot get right — a nickname used once, or a name that is also an ordinary word.

Resize Image… on a selected image is in the same menu, for when a picture in the prose is the wrong size.

See also: Add a character or place · Jump between mentions of a character · Track a character through the book

This answer has not yet been checked against the application.

A Number field holds a number, a Yes / no field holds a boolean, and a Reference holds the id of the thing it points at. That sounds obvious; it was not always true. Until 0.3.0 every value was stored as text whatever the field said, so 9 sorted after 10, a column of prices could not be added up, and a link was a spelling of an id rather than the id itself.

Values written from now on are typed as you enter them. Values written before need one pass.

Convert what you already have

1. Right-click anywhere in the Codex tree.
2. Choose Give Values Their Types….
3. Read what it is about to do: how many values will be converted, and how many it will leave alone.
4. Press OK.

It is one step on the undo stack, so if you dislike the result, Edit ▸ Undo puts every value back exactly as it was.

Run it again whenever you like — after an import, for instance. A value that already holds its declared type is left alone, so a second run simply reports there is nothing to do.

What it will not convert, and why that is the point

If a Number field contains "about forty", that is not a number and no conversion would be honest. Those values are left exactly as they were and listed individually in the details, naming the entity and the field. Nothing is lost — the words you wrote are still there — but until the value reads as a number it cannot be summed, sorted or compared.

Press Show Details in the confirmation to see the list. Fix them by editing the entity and typing a value the field can read, then run the command again.

Why an edit is sometimes refused

Typing about forty into a Number field now gets you a message in the status bar, and the field keeps what it had. That is deliberate. Storing it would leave you with a "number" that nothing could add up and no sign anything was wrong, which is the state this change exists to end.

Text, Choice and Url fields accept anything, as before. A Date keeps the text you type: dates are read against your project's own calendar, and converting them without it would silently rewrite them.

Reading a yes or a no

Converting a Yes / no field accepts true, yes, 1 and on, and their opposites, in any casing — because projects written before this existed hold whatever their author typed, and failing a conversion over yes would be refusing a value whose meaning nobody could mistake.

See also: Properties, and who they belong to · A property that points at another entry · Clean up properties on an older project

When the same thing has two entries

1. Find them. AI ▸ Find Similar Entities… is good at this if you have a world index; otherwise search the name.
2. Right-click the one you want to lose and choose Merge Into….
3. Pick the entry to keep.

The surviving entry takes what the other held. Check the result before moving on — a merge combines two sets of properties and the outcome is worth a glance.

When one entry has become two things

Right-click it and choose Split… — for the character who turned out to be twins, or the city that needed to be a city and a region.

Both are undoable. Merging is the one worth being careful with, because it is the one that combines data rather than copying it.

What the split dialog asks

Name the new entity, tick the properties it should take a copy of, and decide about Copy birth/death dates — a lifespan is worth copying for the character who turned out to be twins and worth leaving behind for the city that became a city and a region. Nothing is taken away from the original; a split copies.

See also: Add a character or place · Find entities like this one · Clean up properties on an older project

Right-click the codex and choose New Category…. Categories nest, so Characters can hold Nobility, and everything beneath inherits what the category above defines.

A category can also sit under a single entity rather than under the project — a noble house's retainers belonging to that house, for instance. It inherits nothing from above by default; you tick which properties above it should apply.

Getting a category back out

A category that sits under an entity can be moved out again: right-click it and choose Move to Top Level, and it becomes a category of the project like any other. The option appears only on a category that is nested under an entity, since there is nowhere to move a top-level one to.

Its entities and properties go with it. Nesting is where a category sits, not what it contains.

See also: What is the codex? · Properties, and who they belong to · Add a character or place

A property belongs to whatever you add it to. Adding one while an entity is selected adds it to that entity alone. Adding one to a category gives it to every entity in that category and in the categories beneath.

Each property says which of the two it is, so you can see whether an edit changes one thing or all of them.

A value that never varies can be marked fixed and held on the category — every entity beneath shows it read-only, and changing it on the category changes it everywhere at once. A sub-category can untick an inherited property it does not need; nothing is deleted, and values reappear if you tick it again.

To make one, right-click in the Codex tree and choose New Property… — every row of that form is explained in the New Property form. A property can also hold many values; see lists and maps.

The category properties editor

Two boxes, and the headings are the whole model in four words each. Declared here is what this category owns — it retitles itself to Declared on "Nobles" once a category is selected, so you are never guessing which one you are editing. Taken through the entity above is what reaches it by inheritance, with Take all and Take none to accept or refuse the lot: nothing crosses from an entity unless you say so.

Give to the entities using it… is the way back out. It takes the property off the category and hands a copy to each entity that actually has a value for it — the move to make when a property turned out to describe a handful of entities rather than a kind.

Properties are shown in the order you arrange them: Move property up and Move property down in the Inspector reorder them, and that order is what every entity in the category shows.

Requiring a value

A value is required marks a property that ought to be filled in on every entity that has it. Nothing refuses a save over it, and nothing should: a half-filled world is the normal state of a project in progress, and a tool that would not let you close a character sheet would be answering a question nobody asked. What it does instead is make them findable.

• In the Inspector, an unfilled one reads Required — not filled in where its value would be, so it is visible with the card open or collapsed.
• The manuscript health report ends with a Required properties table naming every entity and property still outstanding — the list to work down before handing a world to somebody else.

It can be marked on a category, in which case every entity beneath inherits the requirement. It cannot be combined with a category-supplied fixed value: the category is already answering, so there is nothing for the entity to fill in, and ticking one clears the other. A yes/no property is never reported as unfilled, because an unticked box is already an answer.

Removing one

Remove field — the ✕ on a property's card — takes it off whatever declared it. On the entity's own property that is the entity alone. On one that reaches it by inheritance, it comes off the category that declares it and every category beneath, and you are told which category and asked first, because that is a much larger change than the card it was clicked on suggests.

Values already entered are kept either way, so Edit ▸ Undo brings the property back with its data rather than as an empty slot.

See also: A property that points at another entry · Organise the codex into categories · Clean up properties on an older project

A property normally holds one value. State Over Time… lets it hold different values at different points in the story.

1. Right-click the entity and choose State Over Time….
2. Pick the property that changes — location, rank, whether they are alive.
3. Add Change adds one: the point in story time it takes effect, and the value from then on. Remove takes a change back off.

The base value is what holds before any timed change. Each change applies from its own instant onward.

It is for the thing that would otherwise be wrong half the time: a character whose location is "the capital" is wrong for every chapter before they arrive, and a note saying "moves in chapter nine" is not something the timeline can check.

See also: Properties, and who they belong to · What the timeline is for · Track a character through the book

Renaming

Right-click the thing and choose the rename command — the menu names what you clicked, so it is Rename Entity… on an entity, Rename Document… on a document, Rename Category… on a category. There is no separate "properties" trip.

Renaming is safe. Everything that refers to an object does so by its identity, not by its name, so backlinks, embeds, timeline participants and spreadsheet bindings all keep pointing at it. You do not have to hunt for references after a rename.

Before you commit to a name, the assistant's check_name tool reports near-matches across every object title and alias by edit distance — it catches the collision a text search cannot, like "Marda" against "Martha". Worth it for a cast that has grown past what you can hold in your head.

Moving an entity to a different category

Two ways, and they do the same thing:

1. Drag it onto the category in the codex tree.
2. Right-click it and choose Move to Category…, then pick the category. Use this when the destination is far away in a long tree and dragging is a nuisance.

Move to Top Level takes it back out of whatever category it is in.

A category can nest under another category, so moving an entity into a sub-category is the same gesture — drop it on the sub-category itself. What the entity inherits changes to match its new home: it picks up the properties defined by the category above it.

Moving a document

Drag it in the document list. Dropping it onto a folder puts it inside; dropping between two items places it there in order. See reordering the manuscript for what that does to the compiled book.

All of it is one undoable step. Edit ▸ Undo puts it back where it was.

See also: Organise the codex into categories · Add a character or place · Reorder chapters and scenes · What the assistant can do with your codex

Right-click an entity and choose Save as Template…, then create the next one with New Entity from Template….

A template carries the category and the pre-filled property values, so a new entry starts where you want it rather than empty.

Manage Entity Templates… lists what you have and lets you remove any you have outgrown.

See also: Add a character or place · Properties, and who they belong to

1. Open the Relationships panel from the Windows menu. Entities are nodes; the links between them are edges.
2. A whole codex at once is unreadable, so narrow it. Focus Here on an entity centres the graph on it.
3. Expand Neighbours (+1 depth) pulls in one more ring of connections. Do it twice and you have a character's world without the rest of the project.
4. Hide This Entity removes a node that is adding noise; Show Hidden Entities brings them back when you have lost track of what you hid.
5. Hide Unconnected Entities clears everything with no links at all — usually the fastest single improvement.
6. Filter by relationship type to see one kind of link at a time: family, allegiance, whatever you have defined.
7. Open in Inspector, on a node's right-click menu, goes to that entity's fields without leaving the graph.

An entity with no links does not appear connected to anything because it is not. The graph draws what the codex says, so a sparse graph is a fact about the codex rather than a fault in the view.

When the graph comes up empty

Narrowing stacks: a category filter, a relationship-type filter, hidden entities, Hide unconnected and a focus depth all apply at once, and together they can leave nothing to draw. The canvas says which to reach for rather than going blank:

• No relationships within reach — increase the depth or clear filters. The focused entity is on the graph but nothing else survived. Raise Depth, set Direction back to Both, or clear the focus with the ✕ beside the Focus button.
• Every entity is filtered out. Nothing survived at all. Re-check a category under Categories ▾ or a type under Types ▾, turn off Hide unconnected, or use Show Hidden Entities (n) in the right-click menu — the count in that item tells you how many you hid.

If the graph is empty before you have filtered anything, the codex has no entities yet: add some and link them with Reference fields, which is what the canvas says in that case.

Arranging what is left, colouring it and getting a picture out of it is a separate job — see relationship-graph-view.

See also: Arrange, colour and export the relationship graph · What is the codex? · Add a character or place · Arrange ideas freely on a canvas

Right-click in the Codex tree and choose New Property…. Some rows appear only when the type you pick makes them mean something, so the form is short whatever you are making.

• Name — what the property is called. It is also what a new property's stored key is derived from, so renaming later keeps the values.
• Type — text, number, boolean, date, reference, choice, url, list or map. The type decides what the value is checked against and which control you edit it with.
• Choices — for a choice property, the comma-separated values the drop-down will offer. A choice with no choices is a menu that never opens, so OK stays disabled until you list some.
• Points at — for a reference property, and for a list or map of references. Leave it at Anything in the project, or name a category to limit the link to it and everything filed beneath it.
• Each entry is a / Each key is a / At least / At most / Every entry must be different — for a list or a map. See lists and maps.
• Belongs to — appears when an entity is selected, and asks whether the property is that entity alone or every entity in its category. It defaults to the entity, because adding a property while looking at one character used to give it to every character in the project.
• A value is required — marks it as something that ought to be filled in. See properties and who they belong to.
• The category supplies the value — ticking it reveals Fixed value. Type the answer once, here, and every entity beneath shows it read-only. Use it for a fact none of them can vary: the realm every one of these cities is in.

Required and the category supplies the value cannot both be set: the category is already answering, so there is nothing left for an entity to fill in. Ticking one clears the other.

Editing an existing property reopens the same form with Belongs to hidden — a property is moved between an entity and its category by promoting or demoting it, which carries the values with it, not by re-picking here.

See also: Properties, and who they belong to · A property that points at another entry · A property that holds many values · Make a number behave like a number

1. Create the entity in the Codex — right-click, New Entity…, category Characters.
2. Add any aliases they go by. That is what makes a nickname in the prose count as a mention.
3. Write as normal. Mentions are picked up from the text.
4. Open the entity in the Inspector to see where it is mentioned.
5. Edit ▸ Next Mention and Previous Mention step through the manuscript from one appearance to the next.
6. Open the Relationships panel to see who they are connected to.

If a name is not being found, check the aliases — a character called Tam who is written as "the smith" for three chapters needs "the smith" as an alias to be tracked through them.

See also: Add a character or place · See how your characters connect · Search and replace across the whole project

What gets checked

Open Windows ▸ World ▸ Conflicts and press Check Now. A list or map can report:

• Entry is the wrong kind — an entry, key or value that is not what the property declares.
• List is too short / List is too long — fewer entries than At least, or more than At most.
• List repeats an entry — only when Every entry must be different is ticked.
• Map repeats a key — always, whatever the settings say, because one of that key's two values could never be read and which one survives is an accident of ordering.
• Entry points at something deleted — a link inside the list whose target is gone. This is the finding the whole type exists for: as a paragraph of names, deleting one of the people named changed nothing anybody could detect.

Each is a rule of its own in the conflicts list, so you can silence one without losing the others, and a finding is anchored to the property it is about — silencing one list's finding does not silence another list on the same entity.

A list is not editable from the category spreadsheet

The sheet shows the list, with links named rather than printed as ids, and pushing the sheet back leaves list and map columns exactly as they were.

That is deliberate. A cell reading "Aragorn, Boromir" cannot be turned back into two entries without assuming the comma is a separator rather than part of a name — and one wrong assumption there would replace a list of five members with a single long string. Edit lists in the Codex, where each entry has a row of its own.

Converting a text property to a list does not split it

The words you already wrote become one entry, not several, for the same reason. Nothing is lost: open the property and split them into rows yourself, which takes a moment and cannot guess wrong.

See also: A property that holds many values · Find everything wrong with your project · Make a number behave like a number

Open Windows ▸ World ▸ Conflicts and press Check Now. A property block can report three things.

Property block is missing

A property uses a block the project no longer defines — you deleted it, or opened a project whose block files did not come with it.

The property's values are kept. Nothing is retyped and nothing is dropped, because retyping the property to text would discard every value beneath it and a writer who has just deleted a block by accident wants it back, not flattened. Edit ▸ Undo brings the block back with everything intact; so does defining a block again and pointing the property at it.

Value has no property to sit in

A block holds a value under a name the block does not declare — almost always a property renamed or removed after somebody had already filled it in.

Left exactly where it is, and reported. The words are yours; losing them silently is worse than being told about them. Either add the property back under its old name, or open the entity and move the value where you want it.

Property block contains itself

A block that contains itself, directly or through a chain of blocks, has no end — every attempt to draw, save or export it would run forever.

You cannot make one through the app: Property Blocks… refuses the change, and so does the AI, before the edit rather than after. It is checked anyway because a project is a folder of text files that anything can write, and a shape with no end is the kind of fault that would otherwise show up as a crash instead of a message.

Not a problem: a property nobody has filled in

A blank row in a block is a blank on a form. It is only reported if the property is marked required — see properties and who they belong to.

See also: Group properties that belong together · Find everything wrong with your project · What a list or map gets checked for

The codex is your world's encyclopedia: characters, places, factions, objects — anything you want to keep track of.

Entries are organised into categories you define, carry whatever properties you give them, and link themselves into your prose, so a name in a chapter can take you to the entry behind it.

It is the half of Ordfoss that keeps the world straight while the manuscript is being written.

Seeing more or less of it

Expand All and Collapse All open or close every branch of the codex tree at once. Collapsing is the useful one on a large world: it puts you back to a screenful of categories, which is the view to navigate from when the expanded tree has grown past what fits.

See also: Add a character or place · Organise the codex into categories · Properties, and who they belong to

Open the Timeline panel and choose + Event, or right-click the timeline and choose New Event….

An event carries a date on your world's calendar, a description, and whatever entities it involves — which is what lets the validator reason about who was where.

If your scenes already say when they happen, Generate from Scenes will build the events for you rather than making you type them twice.

When you do not know the exact date

Most of what a writer knows is "about then", and a timeline that only took exact dates would be useless for a draft. The date qualifier says which kind of knowledge this is:

• Exact date — the ordinary crisp date.
• Circa (approximate) — near enough.
• Before this date / After this date — one-sided: all you know is that it happened by then, or not until then.
• Sometime during — inside a stretch rather than at a point.

The soft ones draw as a band or bracket instead of a hard mark, without changing the stored instant — so an event does not silently move when you admit you are guessing, and the validator knows not to flag an ordering it was never told was firm.

On the timeline itself the label says so too, with a short prefix in front of the date: c. for circa, and before, after or during for the other three. An exact date has no prefix. So "c. 1200 — the tower falls" is an event you have told the project you are guessing at, and one without a prefix is one you have said is firm.

Open Scene jumps from an event to the document it came from, when the event was made from a scene's date.

See also: What the timeline is for · Build the timeline from your scenes · Find everything wrong with your project

An expression is exact, and a blank line is a bad place to start. Build Rule… assembles one from menus instead.

Open it

Windows ▸ World ▸ Timeline, then Manage Continuity Rules…. Select a rule's row — or Add Rule first — and press Build Rule….

Three choices

• Property — everything the rule's objects actually have: their own fields, the members inside a block (Stats › Strength), and one hop through a reference (Owner › Name, Inventory › Weight).
• Requirement — only what that property's type allows. A number offers the comparisons; text offers must contain, must start with, must match, and the length tests; a yes/no offers yes and no; a list offers how many, must include, and must every one be above. Offering all of them would let you write a rule that is not wrong so much as meaningless.
• Compared with — four kinds:
  • a value you type;
  • another property of the same entry — "died after they were born";
  • a property through a reference — "its owner's homeland";
  • a property of a named entry — "less than John's money". This is the one that makes a rule about two different entries possible.

Above the menus, the rule in words: "Sue's money must be less than John's money." Three dropdowns are a shape rather than a sentence, and the mistake they hide is picking the wrong one of two similarly-named properties.

Three rules, start to finish

• Every Shop item costs something. Applies to Every Shop · Property Price · Requirement must be greater than · a value 0.
• Sue never has more money than John. Applies to Sue · Property Money · Requirement must be less than · a property of a named entry → John → Money.
• Nothing weightless in the pack. Property Inventory › Weight · Requirement must every one be above · a value 0.

When the menus cannot say it

Write It Myself… drops to the expression editor, carrying what you had built so you are never starting from nothing. Back to the Menus returns whenever what is written is something they can show; anything else stays in the editor rather than being approximated into a rule you did not write. See write a rule as an expression.

What it produces is an ordinary rule. It is stored as an expression like any other, so it can be edited by hand afterwards, it names other entries by identity so renaming is safe, and its violations appear in Conflicts naming the entries and values involved.

See also: Set your own continuity rules · Write a condition or a rule as an expression · Name another object inside an expression · One rule that covers everything of a kind

Generate from Scenes on the Timeline panel reads the scenes that carry a date and creates events for them.

It saves entering the same chronology twice — once in the prose and once on the timeline — and means the timeline reflects what the manuscript actually says.

Events made this way are ordinary events: you can edit them, and regenerating does not throw away what you changed by hand.

See also: Add an event to the timeline · What the timeline is for

This answer has not yet been checked against the application.

The View… settings decide how the timeline is drawn, separately from what it contains.

Fitting more on screen

Density switches between Compact and Comfortable. Row height and Bar thickness tune it further — a timeline of five events reads better loose, one of five hundred reads better tight, and there is no single right answer.

Axis minor ticks controls how much subdivision the axis shows. More detail helps when you are reading months inside a year, and becomes noise across three centuries.

How events are shaped

Series shape draws a series as Stepped or as an Area. Stepped is right when a value holds until it changes — a ruler's reign, a border. Area is right when it accumulates.

Ordinal (sequence) mode lays events out in order rather than to scale. This is the setting for a story whose dates are not real dates. If you know the coronation comes before the siege but not by how long, ordinal mode stops the timeline implying a precision you do not have.

What gets marked

Conflict marks show where the validator has found a contradiction, so a problem is visible on the timeline rather than only in the Conflicts panel. Density strip shows where events cluster, which is how you spot a year doing all the work while a decade sits empty.

Every one of these is a view setting: it changes what you see and never what is stored, so nothing here can damage the project.

Colour coding

The Colour menu decides what the colour of an event means, and it is the fastest way to read a crowded timeline at a glance:

• No colour coding draws everything the same.
• Colour by character, Colour by location, Colour by status, Colour by tag and Colour by plot thread each take the colour from that property, so a run of scenes with one point-of-view character, or every unresolved event, stands out as a band rather than something you have to read for.

That is a view setting: it changes what you see without touching the events. One event can also be given a colour of its own -- right-click it and Set Colour…, or Clear Colour to put it back under whatever the Colour menu is doing.

Exporting it as a picture

Export Timeline writes the timeline as an image. From year and To year choose the stretch, and Detail chooses the resolution: Screen (1x) for something to look at on screen, Large (2x), Wall (4x), and Poster (8x) for printing large enough to pin up. The higher settings exist because a wall-sized chronology is a thing people actually print, and 1x looks fine until it is a metre wide.

See also: Save a place, or a view, on the timeline · What the timeline is for · Find everything wrong with your project

1. Open the Timeline panel from the Windows menu.
2. Edit Calendar… if your world does not use ours — set the months and their lengths first, because every date after this is written on that calendar.
3. Add events with + Event, or Generate from Scenes if your scenes already carry dates.
4. Attach the entities each event involves. That is what lets the validator reason about who was where — an event with no participants cannot contradict anything.
5. Write the rules your world obeys, so the validator has something to test against.
6. Open the Conflicts panel and read what it found. Each finding names the events involved.
7. Fix, and watch the finding disappear.

The validator only knows what you told it. An empty Conflicts panel on a timeline with no rules and no participants means nothing has been checked, not that nothing is wrong.

See also: What the timeline is for · Find everything wrong with your project · Set your own continuity rules

Open the Conflicts panel from the Windows menu.

It lists everything the project's checks found, whichever part of the product noticed it:

• Timeline continuity — someone in two places at once, an event before the person in it was born, an ordering that cannot happen, a journey nobody could make in the time available.
• Your own continuity rules — the assertions you wrote about particular objects.
• Branching scenes — a scene with no start, a node no reader can reach, a choice with one option, an effect that writes a variable you deleted.

Each row is headed by the name of the rule that found it, then the finding itself. Each names the objects involved, so you can go straight to the one that is wrong rather than re-reading the chapter.

Colour tells you how much it matters, and so does the rule name: dark red for an error, amber for a warning, grey for a suggestion. Nothing here is distinguished by colour alone.

Narrowing the list

Two pickers sit above it.

• Show: — Everything, Errors only, or Warnings and errors. The three nest, so "warnings and errors" is everything except suggestions.
• The rule picker — All rules, or one rule on its own. It offers only the rules that actually found something, so it is never a list of thirty rules that found nothing.

Both filter what is displayed; neither re-runs the checks, so switching between them is instant even on a large project.

What you can do with a finding

Right-click one. Copy Description puts the wording on the clipboard, for a note or a bug report. Re-check Timeline runs the check again once you have changed something, so you can confirm a fix rather than assume it.

Suggest Fix with AI… asks your configured provider what would resolve the contradiction. It proposes; nothing is applied until you accept it, which matters here more than most places — the model can see that two dates conflict, and cannot know which of them your story needs.

When the panel is empty

It says "Nothing to report — the project validates clean." That covers every check, not just the timeline's, so it means rather more than it used to.

Silencing a finding you disagree with

Findings from every surface share one set of ignores, so silencing something in the Style panel or on an editor squiggle also removes it here — and the other way round. See Ignoring a style suggestion.

See also: What the timeline is for · Set your own continuity rules

1. Open the panel. Windows ▸ World ▸ Timeline. An empty project says "No timelines yet" — that is the starting state, not a problem.

2. Make the timeline. Press + Timeline on the panel's own toolbar and give it a title. The title is what you will pick between later, so name it for what it covers ("Main history", "Book One") rather than "Timeline 1".

3. Decide the calendar before you add many dates. If your world uses its own months or year count, set it up first — see custom-calendar. Dates entered under one calendar do not silently re-interpret themselves under another, so this is much easier before the events exist than after.

4. Put events on it. + Event asks for a title and a date. Two things there are worth doing from the start rather than retrofitting:

• Link the event to the entities involved. That is what makes the timeline part of the world rather than a separate list — a character's page can then show what happens to them.
• If a date is a guess, say so. There is a qualifier for approximate and uncertain dates, so "around the third year" stays honestly vague instead of pretending to a precision you do not have.

5. Or build it from what you have already written. If your scenes already carry dates, Generate from Scenes creates the events rather than making you retype them. See timeline-from-scenes.

6. Check it. Once events exist, the timeline validates them — a character present before their birth, two events that cannot both be true. See timeline-conflicts. This is the reason to keep the timeline rather than a list in a document: a document cannot tell you it contradicts itself.

A project can hold several timelines (multiple-timelines), so a separate one for a flashback strand or a rival kingdom is a normal thing to make, not a workaround.

See also: What the timeline is for · Add an event to the timeline · Build the timeline from your scenes · Use your world's own calendar · Use more than one timeline in a project · Find everything wrong with your project

Manage Eras… on the Timeline panel names stretches of history — the Third Age, Before the Flood, whatever your world calls them.

An era is drawn behind the events it covers, so the shape of your history is visible rather than inferred from dates.

Manage Markers… is the related tool for a single moment worth labelling rather than a span.

Removing one

Pick an era in the list and Remove Selected takes it out. Removing an era does not touch the events inside its span -- an era is a label drawn behind the timeline, not a container -- so this is a safe thing to try when you are still deciding how to divide your history.

See also: Use your world's own calendar · What the timeline is for

An expression usually talks about the thing it is attached to — the object a rule is checking, the variables a scene carries. Put an @ in front of a name and it talks about anything in your world instead.

@Rhys.stats.strength > 10

The same line works in a continuity rule, a spreadsheet cell ([email protected] * 2) and a branching condition — one resolver serves them all, so they cannot disagree about what it means.

Writing the name

Type @ and the suggestions appear. A name with spaces is typed with underscores — @Rhys_ap_Gwilym — the same convention story variables use. Aliases work too.

Going deeper

After the object, a dot goes inside it:

• @Rhys.title — a field.
• @Rhys.stats.strength — a property inside a block.
• @Rhys.homeland.climate — across a reference, into the object it points at.
• @Rhys.inventory[].weight — every element of a list; [2] takes the second one.
• COUNT(@Faction.members) — how many.

As of a moment

Add # and a moment to read the value as it stood then:

@Rhys.title#Coronation = "King"

The moment can be a timeline marker, an era, or a date your calendar understands. Without it you get the value as it stands now.

Renaming is safe

What gets saved is the object's identity, not the letters of its name — the name is only what you see and type. Rename Rhys and every rule, formula and condition that mentions him keeps working, and starts showing the new name by itself.

Deleting is not silent

If the object is gone, the expression says so — "This names an object that has been deleted" — and a finding appears in Conflicts. It never quietly answers zero, because a rule that stopped checking anything while still being counted as protection is worse than no rule at all. The id is still in the expression, so putting the object back repairs it.

What you are allowed to see

An expression reads as you do. Reading the project as an audience that cannot see Rhys, an expression naming him is refused rather than answered — otherwise @Rhys.stats.strength > 10 returning 1 would tell you his strength just as plainly as the field would. See who can see what.

See also: Write a condition or a rule as an expression · Set your own continuity rules · Make a branch depend on what happened · Keep a spreadsheet in your project · Audiences: who is allowed to see what

A continuity rule used to name one entry: "Aragorn is King after the coronation". That is exactly right for a fact about Aragorn, and no use at all for "every Item has a price" — which had to be written three hundred times, or not written.

A rule now says what it applies to.

Set it

Open Windows ▸ World ▸ Timeline, then Manage Continuity Rules…. The Applies to column offers:

• one entry, by name — what every rule was, and still the right choice for a fact about one thing;
• **Every *Category*** — everything filed directly in it;
• **Every Category, and everything beneath** — that category and its subcategories;
• **Everything tagged *tag***;
• Everything in the project.

The Matches column beside it says how many objects the rule currently covers, and updates as you change the picker. A rule you can see the reach of before saving is a rule you can trust afterwards.

It keeps up with the world

Nothing is copied when you save. The rule asks the project what is in its scope each time it runs, so an Item you create next month is covered without touching the rule, and an entry you move out of a category stops being covered. That is the difference between a scope and three hundred rules.

Every category counts

An entry that is also a second category is in scope for rules written against either. A sword that is an Item and a Cursed Object satisfies — or fails — both.

"Applies to nothing"

A rule whose scope matches no object is reported in Conflicts rather than passing quietly. A rule that checks nothing is worse than no rule, because it gets counted as protection. You will see this after deleting the last entry of a category, or after a rule's entry is deleted.

Through the AI

create_continuity_rule(name: …, field: …, applies_to: "under:Item") scopes a rule to a category and everything beneath it; "category:Item" is that category exactly, "tag:act-one" a tag, and "project" everything. Give entity: instead for a rule about one entry. The reply says what the rule applies to and how many objects that is.

See also: Find everything wrong with your project · Set your own continuity rules · Organise the codex into categories

A timeline covering three centuries is not navigable by scrolling. Four tools help.

Go to Date… jumps straight to a date on your world's calendar.

Bookmarks save a span you keep returning to — Save current span… records where you are, and Manage Bookmarks… edits the list.

View presets save a whole arrangement: which lanes are shown, how they are ordered, the zoom. Save Current View as Preset… records it and Manage Presets… edits them. That is how "the war years, political events only" becomes one click.

Lanes and series can be reordered, collapsed or hidden individually, and reset from the same menu when the arrangement stops helping.

Grouping and filtering

Group ▾ decides what the lanes ARE — By character, By location, By tag or By plot thread — so the same events regroup around whichever question you are asking. Filter ▾ narrows which events appear at all.

Lanes ▾ works on the lanes you have: Hide lane removes one from view, Single lane collapses everything into one, Show all lanes brings them back, and Reset lane arrangement undoes reordering. Hide series and Reset series arrangement do the same for series.

If a menu says No lanes to arrange or No lanes to filter, nothing is grouped yet — pick something in Group ▾ first and the rest becomes available.

Zoom with + and −, and Fit brings the whole timeline back into view when you are lost.

How the timeline is DRAWN — density, row height, axis detail, what gets marked — is separate; see timeline-appearance.

Filtering what the timeline shows

The Filter menu narrows the timeline to what you are working on -- By character, By location, By tag -- and the button counts what it is hiding: it reads Filter (7) rather than plain Filter while seven events are out of sight. That count is the guard against the commonest confusion with any filter, which is forgetting one is on and concluding the events are gone.

Manage Markers… edits the named marks drawn down the timeline -- the ones a bookmark or a view can jump to. Markers are the fixed points ("the war starts here"); bookmarks are where YOU were looking. Both survive a filter, so a marked moment does not vanish because you narrowed the view.

See also: What the timeline is for · Use your world's own calendar · Mark eras and ages on the timeline

A continuity rule says what your world does not allow — and the timeline is checked against every rule you have written.

Rules live in the project, so they travel with it and apply to every event, including the ones you add later.

The Conflicts panel is where the results show up.

What continuity rules check, and what checks the rest

Continuity rules are about the timeline: they catch a character in two places at once, an event before the birth it depends on, a rule of your world being broken by a date. That is their scope, and it is deliberate — the timeline is the one place a contradiction is provable rather than a matter of taste.

Other things are checked, just not here:

• Prose — the Style panel, for repetition, passive voice, wordiness and your own house style.
• Spelling — including the invented words a conlang adds.
• Branching scenes — the Problems tab, for a node nothing can reach or a condition testing nothing.
• Translations — entries that have gone stale against a changed source.

So "can I only validate timelines?" is no: the timeline is what continuity rules validate, and each other kind of checking has its own panel.

Not sure what to type? Build Rule… assembles a rule from menus — see build a rule without writing an expression.

The columns in the rules window

• Name — what you call the rule; it appears in any conflict it raises.
• Applies to — one entry, or a whole set. See one rule that covers everything of a kind.
• Matches — how many objects the rule currently covers, updating as you change the scope.
• Field — the property being checked, by label or key.
• Requirement — how the value is compared: must be, must not be, must contain, must be at least, must be non-empty, must be one of, and so on.
• Value — what it is compared against; ignored by must be empty and must be non-empty.
• From year — the story year to check as of, for a fact that only becomes true later. Leave it blank to check the value as it stands.
• Expression — for anything one field against one value cannot say: a range, two fields compared with each other, a count, a pattern. Fill it in and that is what the rule checks; the Field, Requirement and Value are ignored. See write a rule as an expression.

See also: Find everything wrong with your project · What the timeline is for · Write a condition or a rule as an expression · Build a rule without writing an expression

Some findings are right about the facts and wrong about your book. Silence them — but say why.

Silence one

Right-click it in the Conflicts dock and choose Silence This Finding…. The window asks two things:

• Why — required. A silenced finding with no reason is indistinguishable from a mis-click six months later, and a project full of those is one where you either restore everything or trust nothing.
• Lapses — optional, off by default. Tick Bring it back on and pick a date, and the finding returns on its own that day. Use it for "I'll deal with this before the December draft".

It disappears from the dock, and from the inline underline where it had one.

Find them all again

Right-click in the Conflicts dock and choose Silenced Findings…. One row per silence, with a column each for What kind it is, What it covers, Who did it, Why, When, and Until it lapses. A row past its date reads (lapsed) — that finding is already back. A project that has silenced nothing says so: Nothing is silenced in this project.

Select a row and press Restore to start being told about it again.

Three widths of silence

• One finding — this repetition, in this chapter, on purpose.
• A rule inside one category — "Items are allowed to have no price", decided once instead of three hundred times.
• A whole rule — you disagree with the advice, not with one instance of it. Style rules can also be silenced by phrase: "I use 'very' on purpose."

Before you save a rule

Write a new rule against a project that already has a hundred entries and it may be right in principle and unhappy about a great deal of work already done. So saving one shows you first:

47 findings would appear straight away. Checked against 312 objects.

Three ways out: Save and fix them, Save and Silence These — every existing violation is silenced with the reason "Already true when the rule was written", so the rule only applies from now on — or Cancel. Rules you already had do not ask again; only new or changed ones do.

They travel with the project

Silences are saved and reopened with everything else, including the reasons, so a shared project shows who decided what. A file written by an older version still opens; it simply has no reasons in it yet.

See also: Find everything wrong with your project · Set your own continuity rules · Build a rule without writing an expression · See what the style checker found

Manage Timelines… on the Timeline panel holds more than one.

That is for the project where one chronology is not enough — the history of the world and the events of the book, or two factions' versions of the same century.

Compare… shows two against each other, which is the point of having them: the question is usually how they line up, not what each says on its own.

Rename, reorder or delete one

Open Manage Timelines… from the Timeline panel and pick a timeline in the list:

• Rename… asks for a new title.
• Move Up / Move Down change where it sits. The list is in the same order the Timeline panel stacks its lanes, so moving one here moves its lane there — put them in the order your story runs rather than living with alphabetical. Move Up is greyed out on the first row and Move Down on the last.
• Delete removes the timeline and every event on it, which it warns you about first. Nothing is selected by default in that warning, so pressing Enter does not delete anything.

Every one of those is a single undo away (Ctrl+Z), including the delete.

Each timeline has its own events and is validated on its own. They share the project's calendar and reckonings, so dates mean the same thing across all of them.

See also: What the timeline is for · Save a place, or a view, on the timeline · Mark eras and ages on the timeline

Edit Calendar… on the Timeline panel defines your world's months and how long each one is.

Once set, every date in the project is written and read on that calendar — the timeline, event dates, and anything that reports a date.

Manage Reckonings… handles worlds that count years from more than one starting point, so a date can be given in whichever reckoning the scene would use.

Editing the months and the week

The calendar editor holds two lists. Months each have a name and a length, and Weekdays are the names of the days in a week -- add one and it arrives as New Day for you to rename.

Both lists have Move Up and Move Down, and the order is the calendar: month three is whatever sits third, and a week is as long as its list. That is how a year of ten forty-day months with a five-day week gets built -- there is no separate "week length" setting, because the list of weekday names IS the week.

Changing the shape of the year moves the dates you have already written

Every date in a project is stored as a position in time, and the calendar is what turns that position into "25 Harvestmoon, Year 1250". So adding a month, removing one, or changing how many days a month has makes the same stored position read as a different date -- an event you dated last week will show a new date, and so will lifespans, dated scenes, markers and era bands.

Ordfoss asks before it does this. If your edit changes the length of any month, OK raises a warning that says how long the year becomes and how many dated things will read differently, and you can say no and keep your dates. If the answer is yes, Undo puts the old calendar back.

Renaming a month, adding or reordering weekdays, setting the Era name, and editing the named-era table all leave every date exactly where it was, so none of them raises the warning.

Counting years from more than one starting point

Manage Reckonings… on the Timeline panel is for worlds where two peoples number the years differently. Each reckoning has a Name, an Era, and an Epoch (primary year) — the year in the primary calendar at which this reckoning's own year 1 begins. Add makes one and Remove takes it away.

A reckoning dates the same instants from a different starting point, so nothing moves: the timeline can show a date in whichever reckoning the scene would actually use, which is how a chronicle written by one people reads correctly to another.

See also: What the timeline is for · Mark eras and ages on the timeline

The timeline holds the events of your story in the order they happen, on whatever calendar your world uses.

Its point is that it checks itself. Rules you set — someone cannot be in two places at once, a child cannot act before they are born — are tested against the events, and anything that breaks one is reported in the Conflicts panel.

That turns "does my chronology work" from a thing you re-read for into a thing you look at.

See also: Add an event to the timeline · Find everything wrong with your project · Use your world's own calendar

A condition tests one variable against one value; a continuity rule tests one field against one value. That covers most of what anybody writes — and none of "the price is between 0 and 10,000", "they died after they were born", or "at least three members, and no repeats".

Both take an expression instead, in the same language the spreadsheet computes with.

In a branching condition

1. Add a Condition node in the Branching panel, right-click it, choose What Does It Test?…
2. The window offers two forms:
   • Test one variable — the picker: Variable, Compared how (is, is not, is less than, is at least) and a Value. Still right for most conditions.
   • Test an expression — one line, for what the picker cannot say.
3. Write it: gold >= 50 AND NOT hasKey. Variables are named as on the Variables tab, with an underscore for each space — last town is typed last_town.

In a continuity rule

Windows ▸ World ▸ Timeline, then Manage Continuity Rules…, and use the Expression column at the end of the row. When it has something in it, that is what the rule checks and the Field, Requirement and Value are ignored.

Names are the checked object's fields. A dot goes inside something: owner.name is the name of what owner points at, traits.height a property in a block. A list field gives one value per element, which is what makes MIN(members.age) >= 18 a rule rather than a report. To name a DIFFERENT object — @Rhys.stats.strength — see name another object.

What you can write

Numbers, text in double quotes, TRUE/FALSE, + - * / with brackets; the comparisons = == <> != < > <= >=, with a name allowed on both sides (deathDate > birthDate); and AND, OR, NOT (also !), which bind more loosely than the comparisons so gold >= 50 AND NOT hasKey reads as it is said.

Functions: SUM COUNT DISTINCT AVERAGE MIN MAX PRODUCT LEN (or LENGTH) WORDCOUNT ISEMPTY MATCHES CONCAT LEFT RIGHT MID UPPER LOWER TRIM IF ABS INT ROUND MOD POWER SQRT. MATCHES(text, pattern) is a regular expression matching anywhere in the text — anchor with ^ and $ for a whole-value test. DISTINCT(x) = COUNT(x) is "no duplicates".

As you type

Start a name and suggestions appear — the variables or fields actually available, plus the functions. Under the line is the answer, run against a real subject: the variables at their starting values in a condition, the first object the rule applies to in a rule, with (true) or (false).

"Cannot be read"

A misspelt name or an unclosed bracket appears in red under the line and OK stays disabled. An expression that cannot be read is false when the story runs, so a condition carrying one would silently delete a branch and a rule carrying one would check nothing while counting as protection.

Being false is fine — a rule that is currently violated is a rule doing its job, and it saves. A field nobody has filled in is empty rather than an error, so ISEMPTY(motto) works; a name that exists nowhere on the object is an error and says which one.

Through the AI

create_continuity_rule(name: …, applies_to: …, expression: "price >= 0 AND price <= 10000") writes one, refusing an expression it cannot read rather than saving it to fail quietly. list_continuity_rules shows it as the expression you wrote.

See also: Name another object inside an expression · Make a branch depend on what happened · Set your own continuity rules · One rule that covers everything of a kind · Keep a spreadsheet in your project

A map in Ordfoss is an image with data on top of it. You supply the image — this is not a map generator — and everything you put on it is stored as data, so the image can be replaced later without redrawing the contents.

1. Open the Maps panel from the Windows menu and press New Map.
2. Set the map's background image and choose your image file.
3. Drop a pin: turn on the drop a labelled pin tool and click the map. Give it a label.
4. Link the pin to the codex — right-click it and Open Linked Entity goes to the entry, so the city on the map and the city in the codex are one thing rather than two.
5. Outline a region: turn on the outline a region tool and click points around it. Use Edit the selected region to adjust it afterwards.
6. Group what you have drawn into layers, and use Show or hide region layers to turn sets on and off. That is how one map serves the players' view and the GM's.
7. For a tabletop battle map, Overlay a square or hex grid.
8. Edit travel speed and routes between locations if journeys need to take a believable time.

Rename the current map and Delete the current map sit beside the map chooser. A project can hold as many maps as you like — a world, a continent, a city, a single inn — and a region on one can open another, so they form a hierarchy rather than a pile. See map-regions.

Pins, regions, routes and layers are all project data. Nothing you add is baked into the image.

Each part has its own answer: map-pins, map-regions, map-tokens, map-travel, map-layers.

See also: Link a place on the map to its codex entry · Show different things on the same map · Set up a project for a tabletop campaign

A pin on a map can point at a codex entity.

That is what stops a map being a picture: the city on the map and the city in the codex are the same object, so renaming it renames both, and clicking through takes you to what you know about it.

Dropping one. Turn on Click the map to drop a labelled pin and click where it goes. Give it a label, and set Location to the codex entity it stands for.

Afterwards. Right-click a pin for Edit Pin…, Delete Pin, and Open / Go to Link, which jumps to the linked entity — the point of the link, and the reason to follow a map into the codex rather than searching for the place by name.

"No pinned items" means this map has none yet, not that something failed.

Pins, regions and routes are all stored in the project as data, not baked into the image — so the image can be replaced without redrawing everything on it.

See also: Draw a map of your world · What is the codex?

Edit travel speed and routes between locations opens Travel & Routes. It answers the two questions a journey raises: how far, and how long.

Set the scale first. Map width (distance across image) is how far it is from one edge of the image to the other, and Distance unit is what you are counting in — miles, kilometres, leagues, whatever your world uses. Until the width is set the map is just pixels and no distance can be real. Everything else depends on this one number.

Travel speed (units/hour) turns a distance into a duration. Set it to what your travellers actually manage — a marching column and a courier on a fast horse are not the same story.

Routes (distance between two locations) records the journeys that matter. Add Route… asks From, To and Distance, so a road that winds through a pass can carry its true length rather than the straight line the map would measure. Remove Route deletes the selected one.

Measure distance and travel time between two points is the quick answer: pick two points on the map and it reports both.

This is what stops a week's ride happening in a chapter and a day's walk taking a month — the distances are written down once and the manuscript can be checked against them.

See also: Draw a map of your world · Link a place on the map to its codex entry · What the timeline is for · Set up a project for a tabletop campaign

A region is an outlined area rather than a single point — a kingdom, a forest, a district.

Drawing one. Turn on Click points on the map to outline a region and click around the edge. Afterwards, Edit the selected region reopens the outline for adjustment and Delete the selected region removes it. Right-clicking a region on the map offers Edit Region… and Delete Region directly.

What the region dialog asks

• Label is what it is called.
• Location links it to a codex entity, the same way a pin does — so the kingdom on the map and the kingdom in the codex are one thing.
• Sub-map points the region at another map. This is how you go from a world map to a city map: put a region around the city, set its sub-map, and the region becomes a way in. It is the most useful thing in the dialog and the label alone does not say so.
• Layer decides which set it belongs to, so it can be shown and hidden with the rest of that set. See map-layers.

Keeping things from players. Right-click a region and choose Reveal to Players or Hide from Players. With Show only regions revealed to players turned on, the map shows what the table is allowed to see, so one map serves both sides of the screen instead of two.

A hidden region is never published. Exporting a website leaves it out entirely -- no outline, no label, no link, and nothing in the site's search box. "Hidden from players" means hidden from readers, and a published folder has only readers, so the setting is not something you have to remember again at export time. To publish a region, reveal it first.

Regions are project data, not paint. Replacing the map image leaves every outline in place.

See also: Draw a map of your world · Link a place on the map to its codex entry · Show different things on the same map · Set up a project for a tabletop campaign

Tokens are the pieces you move during a scene. Pins mark places permanently; tokens mark who is standing where right now.

Placing them. Turn on Click the map to place a token; drag a token to move it, then click. Dragging moves a token — no dialog, no confirmation, because a fight moves faster than a form.

Editing them. Right-click a token for Edit Token… and Delete Token. The token dialog takes a label and a Colour, which is the practical way to tell sides apart at a glance: one colour for the party, another for whatever is trying to eat them.

The grid. Overlay a square or hex battle-map grid opens the Map Grid dialog:

• Grid chooses None, Square or Hex.
• Columns is how many cells fit across the map's width. That is the only measurement it needs — set it so the cells land on a scale you recognise, and the rows follow automatically.

A grid is drawn over the image, never into it, so turning it off leaves the map exactly as it was.

Tokens live in the project with the map, so a fight left half-finished is still half-finished when you come back to it.

See also: Draw a map of your world · Outline a region on a map · Set up a project for a tabletop campaign · Stat blocks for creatures and NPCs

Layers group what is drawn on a map, and each can be shown or hidden.

That is how one map carries political borders, trade routes and spoiler-only markings without becoming unreadable — you turn on the set you want.

It is also how a GM keeps the players' view and their own on the same map rather than maintaining two.

Show or hide region layers lists every layer on the map with a tick beside each. A layer comes into existence when you type its name in a pin or region's Layer box — there is no separate step for creating one, which is why "No layers yet" simply means nothing has been assigned to a layer so far. Anything left blank sits in (No layer) and is always shown.

See also: Draw a map of your world · Link a place on the map to its codex entry

Everything about a language lives in one window, in eleven tabs that build on each other. You do not have to fill them all in — sounds and syllables alone are enough to start generating words.

Make the language

1. Open the Languages panel from the Windows menu.
2. Press the + button on its toolbar (New Language — create a constructed language).
3. Type a name and press OK. It becomes the language the picker at the left of the toolbar points at, and every tab below edits that one.

Give it sounds — the Phonology tab

1. Fill in Consonants and Vowels as space-separated symbols.
2. Set Patterns (C/V) to the syllable shapes you want, such as CV CVC, and set Min syllables and Max syllables for word length.
3. Press Generate Words → Lexicon to hear what the language sounds like. The words land in the Lexicon tab, so this is also how you start filling it.

Tighten the rules — the Phonotactics tab

1. Define sound categories: a symbol and the space-separated sounds it stands for, so templates can be written in terms of groups rather than individual letters.
2. Add syllable templates, each with a weight — a higher weight means that shape appears more often. Length dropoff (Equiprobable, Slow, Medium, Fast) controls how quickly long words become rare.

Fill the dictionary — the Lexicon tab

1. Add Word enters one at a time: word, gloss, IPA, part of speech, semantic field, notes.
2. Generate Vocabulary → Lexicon makes many at once. Leave Meanings blank and it uses the Swadesh core list — the words every language has — which is the fastest route to a language that can actually translate something.

What the other tabs add

Grammar sets typology, word order and adjective position, and holds affix rules. Pronouns and Numbers holds a pronoun table and how counting works. Sound Changes holds named rulesets. Orthography maps phonemes to graphemes so the language can be spelled. Conscript and Script are for drawing your own letters. Translate glosses text with what you have built, and Reference Grammar writes the whole language up as a document.

Derive a related language

Once a language has at least one sound-change ruleset, the Derive Daughter Language button on the toolbar applies that ruleset across the whole lexicon and produces a second language — so a family stays related instead of being invented twice.

Deleting a language cannot be redone across a reload, which makes it the one action here that Ctrl+Z will not always bring back.

Each tab of the panel has its own Add and Remove, making the thing that tab is about -- templates, rules, mappings, numerals. See language-editor.

See also: Generate words that fit your language · Draw your language's alphabet

Work down the editor's tabs in order — each one depends on the one before it.

1. Open the Languages panel from the Windows menu and press New Language.
2. Phonology — enter the consonants and vowels the language uses, and the syllable patterns in C/V form. Set the minimum and maximum number of syllables a word may have.
3. Phonotactics — say which sound sequences are not allowed. This is what stops the generator producing words that feel wrong.
4. Back on Phonology, press Generate Words → Lexicon to get words built from those sounds. Keep the ones you like.
5. Lexicon — give each word its meaning. Generate Vocabulary → Lexicon fills a starter vocabulary rather than making you coin every word by hand.
6. Grammar and Pronouns and Numbers — how the language builds sentences, and its closed classes.
7. Orthography — how it is spelled in the Latin alphabet.
8. Translate — type something and read it back. This is the test: if a translation looks wrong, the fault is usually in phonotactics or orthography.
9. Reference Grammar — the document it writes about the language, for you or a collaborator.

You do not have to finish a tab before moving on. A language with twenty words and no grammar is still useful for naming things.

See also: Build a constructed language · Generate words that fit your language · Draw a writing system and set text in it · Make a related language from an existing one

The Generator tab on the Script canvas derives a glyph's shape from how its sound is physically made, rather than from your hand. A family of related sounds comes out looking related — which is hard to achieve by drawing and is most of what makes an invented script feel designed rather than assembled.

Channels and marks

An articulation is described as channels with marks on them. Add channel and Remove channel manage the channels; Add mark and Remove mark manage the marks on the selected one. Show switches what the preview draws — channels and nodes, or the finished stroke.

The route

The route chooses how the marks are joined into a stroke:

• Nearest unclaimed draws the way a hand moves — always to the closest place it has not been.
• In time order follows the order the sound is actually made in.
• Around the outside traces the perimeter.

The three give visibly different scripts from the same articulation, so it is worth trying all three before settling.

Anchored ends starts and ends every glyph in the same places. That is what makes a connected script actually join up, and it is usually the setting people are missing when their letters sit next to each other instead of running together.

For drawing a glyph by hand, and for the canvas controls, see drawing-glyphs. For setting the script up in the first place, see writing-systems.

See also: The glyph canvas: drawing, snapping, and shaping letters · Draw your language's alphabet · Draw a writing system and set text in it · Build a constructed language

A script belongs to a language, so make the language first — even a bare one with its sounds entered.

1. Open the Languages panel and select the language.
2. Go to the Conscript and Script tabs. This is where the alphabet is defined and drawn.
3. Set the guide lines first — a baseline, a headline, a centre line, wherever your letters sit. Drawing before the guides exist means redrawing.
4. Draw a glyph. Use freehand, lines, rectangles, ovals, polygons, stars, arcs or the pen tool, and turn on symmetry when a symbol is mirrored so the other half draws itself.
5. The panel lists the sounds, syllables or words still undrawn — pick the next one from there rather than tracking it yourself.
6. Reshape as you go: flip, rotate, scale, slant, shear, line points up, or even out the spacing — applied to the selected strokes, the current letter, or every letter at once.
7. When enough is drawn, type a passage and read it back in your own letters.
8. Export the script, a specimen sheet, or a single letter.

Two shortcuts worth knowing. You can trace a scan or photograph of letters you already have. And you can derive a letter from how its sound is made — draw the articulation as lines, and where they cross becomes a shape you can then edit like any other.

See also: Draw your language's alphabet · Build a constructed language from nothing · Build a constructed language

Drawing a writing system happens inside the Languages panel, not in a window of its own. Two of its tabs are involved, and they do different jobs — the Script tab is where you draw, and the Conscript tab is the list of what you have drawn.

(Do not confuse either with the Script Console, which is the automation console and has nothing to do with letters.)

Set the system up

1. Open the Languages panel from the Windows menu and select the language.
2. Go to the Conscript tab.
3. Give it a Script name (e.g. Keshan runes) and a Direction — left to right, right to left, or top to bottom.

Draw the letters — the Script tab

1. Switch to the Script tab. The Inventory list down one side is every sound, root or word in the language that could need a glyph.
2. Tick Only what is still undrawn to see what is left, and use Next undrawn to move straight to the next one rather than hunting for it.
3. Pick whether you are drawing Letters or Parts — parts are pieces you reuse across several letters, so a shared stroke is drawn once.
4. Draw on the canvas. Every stroke stays editable point by point no matter which tool made it, and Copy/Paste carry strokes into another glyph.
5. Fill in Name: and Writes: so the glyph is tied to the sound it spells, plus the note field for what it derives from and why it is shaped that way.

The other ways to get a shape

The Trace tab brings in a scan of letters that already exist and traces over them. The Generator tab derives a shape from how the sound is physically articulated — articulation channels and marks — so a family of related sounds comes out looking related. Transform applies a change across glyphs, and Preview sets a passage in the letters you have drawn.

Check it

The Conscript tab's table lists each glyph with its Name, Grapheme, SVG Path, Variant Of and Transform. A glyph that is a variant of another — a final form, a small capital — is recorded as such rather than drawn twice.

Orthography is the separate tab that says which glyph spells which phoneme. Drawing a letter does not by itself decide how a word is spelled; that mapping lives there.

Adding letters and ligatures

Add Glyph creates a letter for a sound the writing system does not have one for yet, and Remove Glyph takes it back out. Add Ligature and Remove Ligature do the same for a combined form — the single shape a pair of letters takes when they are written together, which is what makes a script look written rather than assembled from tiles.

See also: Build a constructed language · Generate words that fit your language

Word generation uses the language's own sounds and the syllable shapes you said it allows, so what comes out sounds like the rest of it instead of like a random string.

Words you keep go into the dictionary, where each can record what it is built from, more than one meaning, and where it came from.

A word can also record its opposite sense, for languages that flip a meaning rather than using a separate word.

Adding one by hand

Add Word puts an entry into the lexicon directly, for the words you invent rather than generate — the ones that matter enough to choose. Remove Word takes one out. Generated and hand-written words live in the same lexicon and behave identically afterwards.

Spelling and invented words

Edit ▸ Preferences ▸ Editor ▸ Check spelling and highlight invented words is the switch. Left on, it does the thing that matters for invented vocabulary: every entity name and alias in your codex, every category name, and the entities of any library you have mounted are treated as known words — so a name you coined stops being underlined once the codex knows it.

For a word the codex does not hold, right-click it. Add to Dictionary keeps it for good in your own dictionary; Ignore accepts it for this session only.

See also: Build a constructed language · Draw your language's alphabet

1. Build the parent language first — it needs sounds and a lexicon for anything to descend from.
2. Open the Sound Changes tab and write the changes that separate the daughter from the parent: which sound becomes which, and where.
3. Derive the daughter language from those changes. Its vocabulary comes out already shifted, so the two are related in the way real languages are rather than two unrelated word lists.
4. Edit the daughter from there. It is an ordinary language once derived — change its grammar and spelling freely.

Sound changes apply in the order you write them, which matters: a change that fires before another can feed it, and reordering the list changes the result.

This is how a family stays coherent. Inventing each language separately and hoping they look related does not survive a reader who checks.

See also: Build a constructed language from nothing · Build a constructed language

This is the detail of the Script tab in the Languages panel. For getting started — making the writing system, tracking what is still undrawn — see the writing-systems entry.

Strokes stay editable

Whatever tool made a stroke, it stays a set of points you can move afterwards. Nothing is flattened into an image, so a letter drawn on day one is still adjustable on day ninety.

Keeping things straight

• Guides and Hold points to the grid snap what you draw, so strokes line up between letters without measuring.
• Angle step constrains a stroke to fixed angles — useful for runic and other angular scripts where freehand wobble reads as sloppiness.
• Symmetry draws the mirrored half as you go.
• Rulers and Points toggle what the canvas shows while you work.

Editing a stroke

Split at selected point breaks one stroke into two. Join with next does the reverse. Reverse direction flips which end is the start, which matters when a stroke is animated or when its taper runs the wrong way. Simplify to reduces a hand-drawn stroke to fewer points, and Even redistributes them at equal spacing — both report how many points they removed, so you can see whether it went too far.

Giving strokes weight

Nib width, Nib angle and Taper shape a stroke like a pen rather than a wire, and Tremor adds controlled irregularity so a hand-cut look does not require hand-cutting every letter. Width varies turns weight variation on for the stroke.

The shape of the writing box

Box aspect sets the proportions of the box every glyph is drawn in, and Writing line places the baseline inside it — the two together are what make a script sit consistently on a line rather than each letter floating at its own height. Grid divides the box for snapping.

Compare with ghosts a neighbouring glyph behind the one you are drawing, so a new letter can be matched to the ones it will sit beside. It is the single most useful control for making a script look like one alphabet rather than a collection of drawings.

How a stroke carries weight

The pressure model decides where a stroke swells. Even keeps it uniform; As drawn uses the pressure your tablet recorded; From the shape swells on a pull and thins on a push, so a script drawn with a mouse — which records no pressure at all — still looks written; Both combines them.

Tracing from a picture

Show through sets how strongly the reference image reads behind your strokes, Pin to the window holds it in place while you work, and Trace into strokes converts it. Simplify to controls how many points the trace keeps.

For deriving a glyph from its sound rather than drawing it, see glyph-generator.

For reshaping a glyph you have already drawn -- rotate, scale, slant, flip -- for tracing one from a scan, and for the SVG and JSON exports, see reshaping-glyphs.

See also: Transform, trace and reuse parts of a glyph · Draw your language's alphabet · Derive a glyph from how its sound is made · Draw a writing system and set text in it

The Languages panel edits one language at a time, and every tab carries the same pair of buttons making a different thing. That is the usual confusion -- there is no single Add that guesses what you meant; each tab's Add makes the thing that tab is about.

• Add Template / Remove Template — syllable templates (CV, CVC and so on), which are what the word generator draws from.
• Add Rule / Remove Rule — phonotactic rules: the constraints that stop the generator producing shapes your language would not allow.
• Add Mapping / Remove Mapping — orthography, how a sound is spelled. This is what turns a phonemic word into something a reader can pronounce.
• Add Numeral / Remove Numeral — the number system's digits and their values.
• Remove Change — drops a sound change from the list used to derive a daughter language.

For adding words see conlang-words, and for glyphs and ligatures see writing-systems. For the order to build a language in, see workflow-build-a-language.

The number system

Counting base is how many digits the language counts in before it rolls over -- ten for a decimal language, twelve for a duodecimal one, and any base you like for a species with a different number of fingers. Number formation is how bigger numbers are built out of those digits, which is what makes "twenty-three" come out in the language's own logic rather than English's.

Delete the current language removes the whole language and everything defined on it, so it is the one button on the panel to be certain about.

Romanization

Default scheme is which romanization is used when a word has to be written in the Latin alphabet -- glosses, exports, anywhere the invented script cannot be shown. A language can carry more than one scheme; this picks the one that stands in by default.

See also: Build a constructed language · Generate words that fit your language · Draw your language's alphabet · Build a constructed language from nothing

Drawing a glyph from scratch is the drawing-glyphs entry. This is what you do to one that already exists.

Transform

Rotate and Rotate back turn a glyph in steps. Scale up and Scale down resize it. Shear and Slant lean it — which is how an italic form is derived from an upright one rather than drawn a second time. Flip across the horizontal axis and Flip across the vertical axis mirror it, and Mirror does the same live while you draw.

Spread across and Spread down distribute the selected points evenly, and Fit frames the glyph in the view. Even out points and Simplify are the two tidying passes: one redistributes points, the other removes them.

Tracing from a picture

1. Load a reference image… brings in a scan or a photograph.
2. Ink threshold decides how much of it counts as ink, and The drawing is dark on light tells it which way round your source is.
3. Trace into strokes converts what it finds, and Use as the glyph's drawing accepts it.

What comes out is ordinary strokes, so it can be simplified, reshaped and re-weighted exactly like anything drawn by hand. Tracing is a starting point, not an import format.

Guides and shared parts

Add guide and Remove guide manage the lines strokes snap to. Add part and Remove part manage pieces reused across letters, so a shared stroke is drawn once and used everywhere — change the part and every letter built from it changes. Next undrawn jumps to the next unit with no glyph yet.

Getting the script out

Export this glyph (SVG) for one letter, Export a specimen sheet (SVG) for the whole set, and Export the preview passage (SVG) for a sample of real text set in your script. Export the script (JSON) and Import a script (JSON) move a writing system between projects.

What a transform applies to

Apply to sets the scope for everything under Transform: The selection, This glyph, or Every glyph. The last is the one to reach for when a letterform decision changes after the alphabet is half drawn — a slant or a weight applied once, everywhere, instead of forty times.

See also: The glyph canvas: drawing, snapping, and shaping letters · Draw your language's alphabet · Draw a writing system and set text in it

Mark Screenplay Revision records a revision pass over the script, the way a production draft is marked when pages change.

It is for the point where a script is circulating and people need to know which pages moved.

For "what did this look like last week" on any document, Version History is the more general tool.

See also: Write a screenplay · Get an earlier draft back

This answer has not yet been checked against the application.

File ▸ Import ▸ Screenplay… reads Fountain (.fountain) and Final Draft (.fdx).

File ▸ Export ▸ Screenplay… writes either of the same two.

Those are the two formats the rest of the screenwriting world actually exchanges, so a script can come from Highland or Final Draft, be worked on here, and go back.

See also: Write a screenplay · Bring in work from another app

1. Open the Screenplay panel from the Windows menu, or set a document's kind to screenplay so it opens that way from then on.
2. Write. The formatting happens as you go — scene headings, action, character, dialogue, parentheticals and transitions each take the shape they should, so you are not setting indents by hand.
3. If the formatting drifts, or the script arrived from somewhere else and looks wrong, run Tidy Screenplay Formatting. It normalises the whole document rather than making you fix elements one by one.
4. Mark a revision pass with Mark Screenplay Revision when the script is circulating and people need to know which pages moved.
5. Export with File ▸ Export ▸ Screenplay… to Fountain or Final Draft (.fdx) — the two formats the rest of the screenwriting world exchanges.

What the panel shows above the script

The formatted pages are not all the panel gives you. Above them, and updated as you write, is a report you would otherwise be counting by hand:

• A summary line — so many pages · so many scenes · so many speaking characters.
• A cast table: every speaking Character, with their Lines and Words, which is what answers "does the second lead actually say anything in act two".
• The Stripboard — the production strip view, one row per scene, with the scene number, I/E (interior or exterior), Location, Time of day, and the Cast in it. Rows are tinted in the traditional strip colours: white for interior day, blue for interior night, yellow for exterior day, green for exterior night, and grey when the heading does not say.

All of it is read from the scene headings, so the way to fix a wrong strip is to fix the slug line — INT. KITCHEN - NIGHT — rather than to edit the table, which is a report and not an input.

A screenplay is an ordinary document in the project, so the codex, timeline and everything else work on it exactly as they do on prose. A character in a script is the same entity as a character in a novel.

See also: Move a screenplay in or out · Mark a screenplay revision · Export your manuscript

Insert a Footnote in the editor and write it. The Footnotes panel lists every footnote in the document so you can review them together.

Numbering is worked out for you and renumbers itself when you add or remove one.

How footnotes come out depends on the export format — some carry real footnotes, others fold them into the text — so check the output if they matter to you.

Finding where a note is anchored

Jump to Reference moves the editor to the marker a footnote belongs to. Reading the notes list tells you what you wrote; this tells you where it applies, which is the question you actually have when a note no longer seems to fit the passage.

See also: Keep your research and cite it · Export your manuscript

A comment can be pinned to one line of a conversation rather than to the whole scene.

Leave one. In the Branching panel, select the node and either press the speech-bubble button on the panel's toolbar or right-click the node and choose Comment…. Type the comment and press OK. It is one undoable step.

The line is marked. A node with an unresolved comment on it gets a red dot in its bottom-right corner, beside the ochre dot that means the writer left themselves a note. Hover the node and the tooltip says how many comments are still open on it. The mark clears when the last of them is resolved.

Follow it up in the Comments dock. The thread is listed under the scene, with a row of its own naming the line — so a scene with review on three of its forty nodes reads as three lines, not as a pile of comments about "the scene". From that row:

• Double-click, or right-click ▸ Go to This Line, and the Branching panel comes forward with the graph centred on that node and the node selected.
• Reply threads underneath, and the reply stays pinned to the same line.
• Resolve settles it. Resolved threads are hidden until you tick Show resolved, and the node's red dot goes with them.
• The count beside the line's row and beside the scene's row are both open comments, so the numbers say how much work is left rather than how much was ever said.

If the line is deleted, its comments are not: the row reads "(a line this scene no longer has)" and still opens the scene, so a review is never silently thrown away by an edit.

Comment, note or tag? A comment is a conversation somebody else answers and that gets resolved. A note (right-click ▸ Note to Yourself…) is a private sentence with no author and no reply. A tag is a short label you filter and search the graph by.

See also: Leave a comment on the text · Note to Yourself on a dialogue node · Tag a line of dialogue, and filter the graph by tag · Write a branching, choice-based scene

1. Open the Gallery panel from the Windows menu to see the project's images.
2. Add a file. It is copied into the project's assets folder, so it travels with the project and stays an ordinary file you can open in anything.
3. Rename… gives it a name that means something; Remove takes it out of the project.
4. Open one in the Media panel to view it — that panel handles audio and video too.
5. Give it a caption, so a reference photograph carries its own explanation instead of relying on you remembering what it was for.
6. To put an image in the prose, insert an Image… in the editor. Right-click a placed image for Resize Image…, which asks for a Width in pixels and keeps Keep aspect ratio ticked — untick it only if you mean to stretch the picture, which is almost never. The resize is a display size in the document; the file in assets is untouched, so nothing is thrown away and you can make it large again later.

Media lives in the project folder rather than in a database, so backing up the folder backs up the pictures, and nothing is lost if you stop using Ordfoss.

An image can also carry annotations — marks laid over it rather than burned into the file.

Finding one thing in a full gallery

The type filter narrows the list to Images, Audio, Video or Documents, and back to All types; the search box filters by caption at the same time.

Open Externally hands a file to whatever program the system uses for it — the escape hatch for the formats the built-in viewer does not play, and the way to edit a picture in a real image editor and have the change appear here, since the file is the one in the project.

See also: Generate an image · Draw a map of your world · Mark up an image · Where does my writing live?

1. Open the Sources panel from the Windows menu and add a source.
2. Choose its kind — book, book chapter, journal article, magazine article, newspaper article, website, report, thesis, conference paper, unpublished manuscript, or other. The kind decides which fields a citation needs, so pick it before filling anything in.
3. Fill in the bibliographic fields. What you record is what a citation requires, rather than a free-text note you have to re-read later.
4. While writing, insert a Citation… where the claim is and pick the source.
5. Keep the source itself to hand with File ▸ Open PDF…, which docks beside the editor.
6. For an aside rather than a reference, insert a Footnote instead — the Footnotes panel lists every one in the document.

Sources are project data, so a bibliography travels with the project and is exported with it.

Bringing in a bibliography

Import BibTeX… reads a .bib file -- what Zotero, Mendeley, JabRef and most reference managers export -- and adds each record to the source library. That is the way in for research you have already collected somewhere else, rather than retyping it; the citation fields come across with it, so citing works immediately.

Keeping the PDF with the source

Attach PDF… links a file to a source record, so the citation and the document you took it from travel together. Opening the source afterwards offers the PDF beside your writing -- see pdf-reading -- instead of leaving you to remember which file on disk the reference meant.

See also: Add a footnote · Read a PDF beside your writing · Work with an editor or beta reader

1. Put the cursor where the note belongs and choose Add Comment….
2. The Comments panel lists every comment in the project, so a round of notes can be read together rather than hunted for.
3. Reply… records what you decided, which keeps the decision next to the note that prompted it.
4. Edit… changes a comment; Delete removes it outright.
5. Open Object jumps from the panel to the text the comment is about.
6. Mark it resolved when it is dealt with. That is what gives a round of notes an end state instead of a list that only grows.

Comments are not part of the prose. They never appear in an export, so there is no cleanup step before sending a draft, and you can use them as freely as you like.

For a note that belongs in the finished text, use a footnote. For material only the GM should see, use a GM-only callout.

A line of dialogue can carry one too. In the Branching panel, select a node and choose Comment…: the thread is pinned to that line, the node is marked on the graph, and the Comments dock lists it under the line rather than under the scene. See Comment on one line of dialogue.

See also: Add a footnote · GM-only notes inside the prose · Work with an editor or beta reader · Keep two versions of the same scene · Comment on one line of dialogue

An image in the project can carry annotations — marks and labels laid over it rather than burned into the file.

Open the image in the Media panel and add an annotation where you want it. Delete Annotation removes one.

Because annotations are stored beside the image rather than drawn into it, the original file is untouched and you can change your mind later.

Use it for the reference photograph that needs three things pointed out, or the sketch that needs labelling before anyone else can read it.

See also: Keep images and audio in your project · Draw a map of your world · Keep your research and cite it

This answer has not yet been checked against the application.

File ▸ Open PDF… opens a PDF in the PDF panel, which docks beside the editor like anything else.

It is for having the source in view while you write about it, rather than switching windows.

The PDF is read where it lives; it is not copied into the project.

Moving around it

The panel's toolbar is Previous page and Next page, Zoom in and Zoom out, and Fit width, which sizes the page to the panel — the one to reach for when the PDF is docked narrow beside the editor. The page indicator reads "Page 3 of 40", so you always know where you are in a long source.

Taking a quote out of it

Capture a quote from this page as a note is the point of reading in here rather than in a separate viewer. Select the passage (or edit the text in the dialog), choose Capture, and it becomes a note in the project — attached to the source, so the quotation and where it came from stay together instead of the quote surviving and the citation being reconstructed later.

See also: Keep your research and cite it · Add a footnote

1. Decide what they should see. If the project has audiences, set the reader's one and export with it selected so spoiler material is left out.
2. File ▸ Export ▸ Manuscript… in the format they can actually use — Word for most editors, PDF for a read-only pass.
3. When notes come back, put them where the text is: add a comment at the place each note is about, rather than keeping a separate list that drifts out of alignment.
4. Reply to a comment to record what you decided, and mark it resolved when it is done. That gives a round of notes an end state.
5. For a suggestion you want to try without losing what you have, make a variant of the document and write the alternative there. You can compare the two afterwards.
6. Comments are not part of the prose and never appear in an export, so there is no cleanup step before sending the next draft.

Ordfoss has no live multi-user editing. Collaboration here means exchanging files and keeping the notes attached to the text, which is what most editing relationships actually are.

See also: Leave a comment on the text · Audiences: who is allowed to see what · Export your manuscript · Keep two versions of the same scene

1. Open the Charts panel from the Windows menu.
2. New Chart… and give it a title.
3. Choose the kind — bar, line, area or pie.
4. Enter the data in the grid. Add Category adds a column along the category axis; Add Series adds a named row of values, which is what the legend shows. Remove Category and Remove Series take them away again.
5. Name the axes if you want them labelled. A legend appears once there is more than one series — with only one, its name is already the chart's title.
6. For a pie chart, only the first series is drawn — one slice per category, labelled with its share.

A chart holds its own numbers. It is not bound to a spreadsheet, so changing a sheet does not change a chart, and there is no link to set up. If the figures come from a sheet, you are copying them across, and they will need copying again when they change.

A chart lives in the project and can be embedded in a document like anything else.

If the chart looks empty

• "No data yet. Edit the chart to add categories and a series of values." — the chart exists but has no categories, or no series. It needs both: categories say what the columns are, a series says what the numbers are.
• "A pie chart needs at least one value above zero to divide up." — a pie shows each value's share of a whole, so it has nothing to draw when every value is zero, or when they are all negative. Negative values are skipped rather than drawn wrongly; the slices that remain still add up to the full circle. Use a bar chart if the numbers can go below zero.
• A bar chart with all values zero correctly draws no bars — the axis is there, the bars have no height. That is the data, not a fault.

Negative numbers are fine on bar, line and area charts. The value axis extends below zero, the zero line is drawn firmly, and bars hang below it.

See also: Get numbers out of your project and into a chart · Keep a spreadsheet in your project · Pull one document into another

Worth knowing before you start: a chart is not bound to a spreadsheet. A chart holds its own categories and series. Nothing links the two, so this workflow ends with a deliberate copy rather than a live connection.

1. Gather the numbers first. If they are codex fields, open the Spreadsheet panel and build a data table bound to the category — that part is live, and refreshes from the codex.
2. Arrange the sheet so it reads the way the chart should: one column per category, one row per series.
3. Open the Charts panel and choose New Chart….
4. Pick the kind, then Add Category for each category and Add Series for each row of values, and enter the numbers.
5. Embed the chart in a document if it belongs beside the prose.

When the underlying figures change, the chart does not. Edit it again, or rebuild it. If that matters for something you update often, keep the sheet as the source of truth and treat the chart as a snapshot you refresh on purpose.

See also: Chart your data · Keep a spreadsheet in your project · Turn codex entities into a spreadsheet · Pull one document into another

1. Open the Spreadsheet panel from the Windows menu and press New.
2. Type into cells. A formula starts with = and appears in the formula bar above the grid, where it is easier to read and edit than in the cell.
3. Click a cell while editing a formula to insert a reference to it. References use readable names rather than internal ids, so a formula reads the way you would say it.
4. Format with the toolbar. Number Format offers plain, number, currency, percent and scientific; Increase Decimals and Decrease Decimals adjust precision; Clear Formatting puts a cell back to plain.

Making it readable

Alignment -- Align left, Align centre, Align right -- and Fill colour and Text colour are on the toolbar. Alignment is per cell, so a column of numbers can sit right while its heading sits centred.

Sorting

Sort Rows sorts the sheet: choose Sort by column and Order (Ascending or Descending). Tick First row is a header (keep it in place) so your column titles are not swept into the sort -- the single most common way a sheet gets scrambled.

1. Data ▾ ▸ Import brings in a CSV or TSV; Data ▾ ▸ Export writes one out.

Moving data in and out

Import CSV and Import TSV bring a file in; Export TSV writes one out. Cut, Copy and Paste move cells within the sheet and to and from other applications, so a block pasted from Excel arrives as cells rather than as text.

Insert Table puts a small table into a document instead -- that is prose formatting, not a sheet, and it does not calculate.

Sheets live in the project, so they are versioned and exported with everything else — no second file to keep in step.

If the data is really your codex, do not type it twice: Bind to Category makes the sheet a data table of those entities, refreshing from the codex and pushing edits back. See entities-to-spreadsheet for that whole workflow.

Rows and columns

The Data menu holds the structural commands, including Delete Row(s) and Delete Column(s) -- they act on whatever is selected, so selecting three rows deletes three. Formulas elsewhere in the sheet that referred to a deleted cell report the break rather than silently resolving to zero, which is what makes deleting safe enough to do while you are still shaping the sheet.

See also: Turn codex entities into a spreadsheet · Chart your data · Get numbers out of your project and into a chart

A spreadsheet can be bound to a codex category: the first row is the category's field names, and each row after it is one entity. Once bound, it refreshes from the codex and pushes edits back.

The short way

1. Open the Spreadsheet panel from the Windows menu.
2. On its toolbar, press the build a data table from entities button.
3. Choose the category — Characters, Places, whatever you want tabulated.

You get a sheet already filled and already bound.

If you already have a sheet

1. Open the Spreadsheet panel and select the sheet.
2. Open the Codex ▾ menu on its toolbar.
3. Choose Bind to Category… and pick the category.
4. Choose Refresh from Codex to fill it.

Which entities get a row

Everything that IS in the category, which is wider than what is filed directly under it: entities in its sub-categories, and entities that carry it as a second membership. A sword that is an Item and a Cursed Object appears in the Items sheet, and so does everything in Items ▸ Weapons.

That is deliberate, and it is the same set the push-back writes to — so a name you type into the sheet always means the entity you can see on the row above it.

Keeping the two in step

Codex ▾ ▸ Refresh from Codex pulls the current values in, overwriting the sheet. Codex ▾ ▸ Save All Rows to Codex writes the sheet back to the entities, and Save Selected Rows to Codex does only the rows you highlighted — which is the safer one while you are learning what it does.

Both directions are one undoable step, so a push that went wrong comes back with a single Ctrl+Z.

Refresh from Codex appears only when a sheet is bound. If you cannot see it, the sheet is freeform — bind it first.

See also: Keep a spreadsheet in your project · Edit many entities at once through a sheet · Organise the codex into categories

1. Open the Canvas panel from the Windows menu and choose New Canvas….
2. Add Card… and pick what the card points at — a note, an entity, whatever already exists in the project.
3. Drag cards into the arrangement that makes sense. Position is the point: a canvas says what goes near what.
4. Select two or more cards and Connect Selected Cards to draw a relationship between them.
5. Rename Card… to label a card differently from the thing it points at.
6. Open on a card goes to what it references, so a canvas stays a way into the project rather than a copy of it.
7. Remove Selection clears cards from the canvas — it does not delete what they point at.

A canvas holds references, not content. Removing a card loses the arrangement, never the note or the entity.

Use it for thinking about material that already exists. For rearranging the manuscript itself, the Corkboard is the tool, because moving a card there moves the chapter.

Putting something on it

The add dialog has two tabs, and they answer two different questions. Write a Note makes a card out of nothing -- a thought that has no home in the project yet. Add Existing Item puts something already in the project onto the board, so the card and the thing stay the same thing rather than a copy that drifts.

On an empty project the second tab says so ("Nothing else in the project to add yet — write a note on the other tab") rather than showing an empty list, which is the difference between a dead end and a direction.

See also: Work with index cards · See how your characters connect · Keep images and audio in your project

Open the Genre Tools panel from the Windows menu. It gathers three small utilities that do not each deserve a panel.

Dice Roller — standard notation: 3d6+2, 1d20, 4d6kh3 for keep-highest. The individual dice are shown as well as the total, because a keep-highest roll cannot be reconstructed from its total.

Name Generator — names in a chosen style: Fantasy, Harsh or Elvish. For when an NPC needs a name now and the one you would invent under pressure is "Bob".

Conlang Words — enter consonants, vowels and syllable patterns and generate words from them. It is the quick version of the same idea as the Languages panel: no language object, no lexicon, just words that hang together.

None of them changes your project on its own — except that a generated name can be kept with Save as Codex Entity…, which creates the entry there and then rather than making you retype it.

If you want generated words to belong to a language — with meanings, grammar and spelling — build a language in the Languages panel instead.

Keeping a generated name

A generated name is throwaway until you say otherwise. Right-click one in the list and choose Save as Codex Entity… to turn it into a real codex entry in a category you pick — which is how a name you like stops being a line in a scratch list and starts being a character.

Initiative (Run Mode)

The turn tracker for running a session rather than writing one. Type a Combatant name with its init value and Add; Next ▶ and ◀ Prev move through the order, Remove drops one that has left the fight, and Clear empties it between encounters. It is deliberately plain -- the point is that it is already open next to your notes instead of on paper.

Encounter Balance

Give it the party size and level and it reports whether an encounter is easy, medium, hard or deadly, so a fight can be checked before the table finds out the hard way.

Lore Prompts

Generates a starting point when the answer to "what is through that door?" needs to arrive in the next ten seconds. A prompt is a nudge, not content -- keep the ones that fit, ignore the rest.

See also: Roll dice · Build a constructed language · Is it useful for TTRPG campaigns?

The Tasks panel holds the list. The Board panel shows the same tasks as columns you drag cards between.

A task can be attached to a document or an entity — right-click either and choose New Task for… — so the job and the thing it is about stay together.

They are the same tasks either way: the two panels are two views, not two lists.

Dates on a task

Has due date is a tick rather than a blank date field, because "no date" and "a date I have not chosen yet" are different things and a blank box cannot tell them apart. Untick it and the task simply has no deadline; the agenda leaves it out of what is due rather than treating it as overdue.

See also: See what is due · Set a writing target

1. Open the Beat Sheet panel from the Windows menu.
2. Apply Beat Template to start from a known structure rather than a blank list.
3. Assign a scene to a beat — from the beat sheet, or Assign Beat on the document.
4. Look for the beats with nothing assigned. That is the whole value: the gap between the structure you intended and the scenes that exist.
5. Cross-check with Pacing to see whether the beats you have filled are the right length relative to one another.

A beat is recorded by name, not by position, so the mapping survives if a template's beat order is ever revised — your scenes do not silently shift to different beats underneath you.

Nothing forces a document to belong to a beat, and a book that departs from the template entirely is allowed. The sheet reports; it does not enforce.

See also: Track a plot thread through the book · Work with index cards · See the shape of your draft · Run a revision pass over a finished draft

1. Open the Random Tables panel from the Windows menu.
2. Create a table and name it for what it produces — Roadside Encounters, Tavern Names.
3. Add entries. Weight the ones that should come up more often, rather than repeating a line to make it likelier.
4. Roll on it from the panel. The result is shown with what was rolled, so you can see it was fair.
5. Right-click a table for the rest — duplicating one is the quick way to make a regional variant.
6. To share it, File ▸ Save as Content Pack… exports it as a file someone else can apply.

Tables live in the project, so they travel with it and are versioned like everything else.

Building the table

Add Outcome puts a result on the table and Remove Outcome takes one off. Each outcome carries a weight, so a common result can be made common without padding the table with duplicate rows -- which is the difference between a table you can read and one that is mostly repetition.

See also: Roll dice · Stat blocks for creatures and NPCs · Is it useful for TTRPG campaigns? · Reuse a project setup elsewhere

1. Open the Genre Tools panel from the Windows menu.
2. Type the roll in the usual notation — 1d20+2, 4d6kh3 for keep-highest, and so on — and press Roll.

The result shows the individual dice as well as the total, because a keep-highest roll cannot be reconstructed from its total, and because seeing the dice is most of the point.

Sharing a roll

If you have set up a notification channel, a Share button appears beside the result after a valid roll, and posts it — the notation, the dice and the total — to every channel you have configured.

If you cannot see a Share button, that is expected: it is absent rather than greyed out until there is somewhere to send a roll. Set a channel up under Edit ▸ Notifications… and it appears. It also stays absent in a build compiled without networking, and before your first roll of the session, since there is nothing to share yet.

Nothing is posted automatically. A roll goes out only when you press it.

See also: Random tables · Stat blocks for creatures and NPCs · Is it useful for TTRPG campaigns? · Send a message to your own chat channel

1. File ▸ Export ▸ Health Report… and read it away from the app. It covers statistics, readability, dialogue balance, point-of-view balance, style issues and world coverage in one file.
2. Open Pacing, POV Balance and Tension and look at the shape. A dip is a question, not a verdict — but it points at a place you have stopped noticing.
3. Open the Style panel and work through what it raises, including your own house-style rules.
4. Set a status on each document in Document Info as you finish it, so the Outline panel shows what is left.
5. Use Version History on any document before a heavy rewrite, so the earlier version survives the change of mind.
6. Re-run the health report at the end and compare.

Resist fixing while reading the first time. The report is most useful as a map of where to work, and a draft edited in the order the problems occur to you tends to get uneven.

See also: Export a manuscript health report · See what the style checker found · See the shape of your draft · Take a finished draft to a publishable file

Open the Outline panel from the Windows menu.

It lists the manuscript with each document's title, status and word count, so the shape of the whole thing is one glance rather than a scroll.

It is the reading view of the structure. The Corkboard is the same information as cards you can move.

See also: Work with index cards · Plan with a beat sheet · Word counts and writing statistics

Three panels chart the shape of a draft rather than counting it. Each measures something specific, and knowing what makes them worth reading.

Pacing plots each document's own word count in reading order, left to right. It shows the manuscript's rhythm — the run of short scenes, the chapter twice the length of its neighbours. A document's count is its own body only, not its children's.

POV Balance shares the manuscript out by point-of-view character: how many words and how many scenes are told from each. Scenes with words but no point of view set land in an unassigned bucket, which is usually the first thing worth fixing, because an unassigned scene is invisible to the rest of the analysis.

Tension charts the dramatic tension you rated each scene at, from 1 to 10. Only scenes you have rated appear — an unrated scene is left out rather than drawn as zero, so the curve is the arc of what you have mapped, not a graph with holes punched in it. Rate a run of scenes before expecting the curve to tell you anything.

None of the three is a verdict. A dip in the middle is a question about a place you have stopped noticing, and sometimes the answer is that the scene is fine.

Getting a chart out of the panel

Right-click any of the three. Save as Image… writes the chart to a picture file, which is the one for a progress post or a note to an editor. Copy All as Text puts the underlying numbers on the clipboard instead, and Copy Scene Info or Copy This Share takes just the point under the cursor. Go to Scene jumps to the scene a point is about — the one that turns a dip in the curve into the passage that caused it.

See also: Word counts and writing statistics · Export a manuscript health report · Plan with a beat sheet · Run a revision pass over a finished draft

Open the Agenda panel from the Windows menu.

It gathers everything in the project that has a date — tasks, goals, submission deadlines — into one list, so "what is due" is a single glance rather than four panels.

It reports; it does not nag. Nothing pops up.

The four headings

Rows are grouped by when they are due, not listed flat: Overdue, Today, This week, and Later for everything beyond that. A heading with nothing in it does not appear at all, so an empty week is not four lines of nothing. Overdue rows are tinted red.

Two things keep a task off the list entirely: being done, and having no due date. So a task you cannot find here either needs its date filling in or is already ticked off.

Right-click a row

Go to Linked Object opens whatever the entry is attached to — the document, the entity, the submission — so the agenda is a way in rather than a list you then go hunting from. Delete Task removes the task itself.

See also: Set a writing target · Track submissions to publishers · Keep a to-do list

Open the Goals panel from the Windows menu and set a target.

It tracks what you have written against it, so the question "am I on course" has an answer that does not need arithmetic.

Sprint is the short-form version — a timed session with a count — and Agenda shows what is due when you have several things with dates on them.

Whether you will get there

Recent pace is your words per day over the trailing window rather than an all-time average, so a fortnight off does not haunt the number for months. Projected finish turns that pace and what is left into a date.

Both are estimates from what you have actually done, which is the point: a deadline you set is a wish, and a projected finish is the arithmetic on your own last two weeks.

See also: Word counts and writing statistics · Write against a timer · See what is due

1. Open the Stat Blocks panel from the Windows menu.
2. Create a block and name it after the creature or NPC.
3. Fill in its numbers. Add Stat and Remove Stat manage the statistics table — a labelled value each, held as structured data rather than as a paragraph of text, so they can be read back by other parts of the app.
4. Add Action and Remove Action manage the second table: the creature's named attacks, spells and traits, each with its own text, in the order you put them. That is the half a paragraph of prose cannot give you — an attack you can find at the table without reading a block of text to locate it.
5. Right-click for the actions that apply — duplicating a block is usually faster than building a variant from nothing.
6. Pin the ones you use at the table with Toggle Pin, and they sit in the Pinned panel.

A stat block is an ordinary project object: it is versioned, exported, shareable in a content pack, and reachable from the assistant.

Keep the creature's story in a codex entity and its numbers here. The two are different jobs and mixing them makes both harder to use at the table.

Choosing a system when you make one

The new-block dialog asks for a Name and a System template. The template decides which fields the block starts with, so picking the system you actually play saves filling them in by hand. Custom (system-neutral) is there for a homebrew or a system with no template — it starts plain and you add what the creature needs.

The template is a starting point, not a constraint: fields can be added and removed afterwards, and nothing checks the block against the system's rules.

See also: Is it useful for TTRPG campaigns? · Random tables · Roll dice · Set up a project for a tabletop campaign

1. Open the Plot Threads panel from the Windows menu and choose New Thread….
2. Set Colour… — right-click a thread for it — puts a coloured swatch beside the thread in the panel, and beside it again in every scene's membership checklist, which is where you are actually choosing between threads.
3. Attach things to it. A thread can hold documents, codex entities and timeline events, so a subplot is traceable across all three rather than living in your head.
4. Character Arc… is the version of this for one character's change through the book.
5. Open Scene from the panel goes to a document the thread runs through.
6. Read down the thread and look for the gap. A thread with nothing between chapter four and chapter nineteen is the answer to "where did that storyline go" — which is the question this exists for, and the one you usually ask two hundred pages too late.
7. Rename… and Delete manage the list as the book changes.

A document can belong to several threads at once, which is usually what is actually happening in a scene that is doing two jobs.

See also: Plan with a beat sheet · Work with index cards · What the timeline is for · Run a revision pass over a finished draft

Open the Submissions panel from the Windows menu.

It records what you sent, where, when, and what came back — the log that otherwise lives in a spreadsheet nobody keeps up to date.

Deadlines and response windows show up in Agenda alongside everything else with a date on it.

What a submission records

Recipient type says what you sent it to -- an agent, a publisher, a magazine -- which is what makes "how many agents have I queried?" answerable rather than a memory exercise.

Has submitted date is a tick beside the date for the same reason a task's due date is: a submission you are preparing and one you have sent are different states, and an empty date box cannot say which.

See also: Export in standard manuscript format · See what is due

Open the Statistics panel from the Windows menu for counts across the project — words, characters, and how they are distributed.

How much there is

Total words and Total characters for the project; Average words / document, Longest document and Shortest document for how it is distributed. Those three together are the ones worth reading side by side -- a healthy average hiding one enormous chapter and a dozen stubs is a structural problem the total never shows.

Words today and Writing streak track the habit rather than the book.

How it reads

Reading ease and Grade level are the standard readability scores, Avg sentence is mean sentence length, and Dialogue is the proportion of the prose that is spoken. None of them is a target to hit -- they are for noticing a chapter that does not match the rest of the book.

Reading ease is Flesch Reading Ease, 0–100, and higher is easier. It is shown as the number with a plain-English band beside it -- "62 (plain)" -- so you do not have to remember what 62 means:

• very easy — 90 and above
• easy — 70 to 89
• plain — 60 to 69
• fairly hard — 50 to 59
• hard — 30 to 49
• very hard — below 30

Grade level is Flesch–Kincaid: the US school grade that could read it comfortably, shown as "Grade 7.4". A band is a description, not a verdict -- literary fiction sitting at fairly hard is doing its job, and a children's book at fairly hard is the finding.

Reading time estimates how long the manuscript takes to read aloud, which is what a submission or a recording session actually needs.

How the world is holding up

Entity mentions and Avg mentions / entity count how often the codex is actually referred to in the prose. Isolated entities are the ones no document mentions at all, and Entities needing work are the thin ones -- both are lists of things you invented and then left, which is the most common way a world goes stale.

Timelines and Timeline events count what has been recorded, so a timeline that has stopped keeping up with the draft is visible as a number rather than as a feeling.

Taking it away

Copy Statistics puts the lot on the clipboard for a progress email or a journal. Health Report is the fuller version, written to a file, and includes the style and pacing analysis.

For a target rather than a count, use Goals. For today's session specifically, use Sprint.

The status bar carries a live count for the document you are in, so you rarely need to open anything to answer "how long is this".

If you use point-of-view analysis, check the unassigned bucket in POV Balance early: a scene with words but no point of view set falls into it, and stays invisible to that analysis until you set one.

What the world rows mean

Past the prose numbers, the panel counts the world. Entities is the codex total and Entities needing work are the ones with few filled-in fields. Timelines and Timeline events count the chronology, which is the quickest way to see that a project has a timeline nobody has put anything on. Entity mentions counts auto-detected mentions in the prose, and Isolated entities are the ones your prose never names — the pair worth reading together, because a world that exists only in the codex is a world the reader never meets.

See also: Set a writing target · Why did my word count change? · Write against a timer

The Corkboard is only as useful as the synopses on it, so write those first.

1. Open a document and give it a synopsis — the Document Info panel, or Edit Synopsis… on the card itself.
2. Set a status too: that is what makes "which of these are still first drafts" visible at a glance.
3. Open the Corkboard panel from the Windows menu.
4. Read the book as cards. This is the view where a structural problem is obvious and a page of prose hides it.
5. Drag a card to move it. That reorders the manuscript itself, not just this view — the Documents tree changes with it.
6. Right-click a card for the rest: edit the synopsis or status, change the kind, add a task, or open the document.

If the cards are blank, the panel cannot help you. Ten minutes writing synopses is what turns it into a working tool.

See also: See the manuscript as an outline · Plan with a beat sheet · Track a plot thread through the book · Run a revision pass over a finished draft

Open the Sprint panel from the Windows menu, set a length, and start it.

It counts what you write during the session, so the number at the end is that session's work rather than the document's total.

Pair it with Distraction-Free Mode if the point is to stop looking at everything else.

The two settings

Duration is how long the sprint runs and Word goal is what you are aiming to write in it. Neither is enforced — the timer stops, the count does not — because the goal is there to aim at rather than to fail.

See also: Set a writing target · Word counts and writing statistics · Write without the rest of the app

File ▸ Import Translations…

It reads the XLIFF or CSV your translator worked in and stores each translated string against the thing it belongs to.

The original text is not replaced. A project can hold translations in several languages at once, each alongside the source rather than instead of it.

See also: Send your book to a translator

File ▸ Import takes work from several other tools: Scrivener, yWriter, Obsidian, Word, Notion, Manuskript, plain text, screenplays, and the worldbuilding tools World Anvil, Campfire and articy:draft.

Each importer preserves what it sensibly can — folders, chapters, scenes, links — and leaves the rest as prose rather than guessing.

An import arrives as one undoable step, so if the result is not what you wanted, one Undo removes all of it.

See also: Import a Scrivener project · Import a Word document · Import an Obsidian vault · Import from World Anvil, Campfire or articy

File ▸ Export ▸ Website…

It generates a browsable static site of the manuscript and the world bible — plain HTML files you can open locally or upload anywhere. There is no server component and nothing phones home.

Audience filtering applies here too, so you can publish a world bible with the spoilers left out.

A folder, or one file you can send

Export as: offers both, and they are different deliverables. A folder is what you serve or browse locally. A single .zip file is what you send someone — it holds the same pages and the images they reference, so it opens straight out of a download instead of arriving as a folder of broken pictures.

There is no upload and no link: the zip is a file on your disk, and where it goes next is your business. That is the whole of "sharing" here, deliberately — a link would need a server, an account, and somebody else holding your unpublished book.

What the reader gets

Every page is self-contained: the styles are embedded, the images travel with it, charts are drawn into pictures and ![[embeds]] are expanded. Open index.html and it works with no internet at all.

See also: Export your manuscript · Export the codex on its own

File ▸ Export ▸ Health Report…

It writes one Markdown or HTML file covering statistics, readability, dialogue balance, point-of-view balance, style issues, world coverage, and every required property still without a value — that last one named entity by entity, which makes it the list to work down before handing a world to somebody else.

It is the same material the analysis panels show, gathered into something you can read away from the app or send to somebody else.

See also: Export your manuscript · Word counts and writing statistics

File ▸ Export ▸ Manuscript…, then choose standard manuscript format.

It writes an RTF laid out the way short-fiction markets expect — the Shunn convention — rather than however your editor looks on screen.

Use it for submissions. For anything else, Word or EPUB will be more use.

See also: Export your manuscript · Export to Word · Track submissions to publishers

File ▸ Export ▸ Manuscript… and choose the codex as the content, rather than the manuscript.

You get the world bible on its own — every entry, its properties and its links — without the prose. That is the form to hand to a collaborator who needs the world but not the book.

Audience filtering applies, so a players' compendium comes out of the same project as the GM's.

See also: Export your manuscript · Export a browsable website · What is the codex?

File ▸ Export ▸ Manuscript…, then choose EPUB.

It writes an EPUB 3 publication of the manuscript — the whole thing, or the part you selected.

Kindle does not take EPUB directly from every route, but Amazon's own Send-to-Kindle accepts EPUB and converts it. If you would rather hand over something Word-shaped, export .docx instead.

See also: Export your manuscript · Export to Word · Export to PDF

File ▸ Export ▸ Manuscript…, then choose PDF.

It renders a paginated document — pages, not a wall of scrolling text — which is what you want for proofing or for handing to somebody who will read it on a tablet.

A PDF is a final form: nobody can edit it back into your project. For that, export Markdown or Word.

See also: Export your manuscript · Export to EPUB

File ▸ Export ▸ Manuscript…, then choose Word.

It writes a .docx package that Word, LibreOffice and Google Docs all open.

If what you actually need is a submission in standard manuscript format — double-spaced, Courier, with the header a publisher expects — choose that instead; it is a separate option and it is not the same thing as a Word file.

See also: Export your manuscript · Export in standard manuscript format · Import a Word document

The export dialog has an audience picker. Choose one, and anything marked as not visible to that audience is left out of the file.

That is how you produce a players' copy from the same project as the GM's copy, or a spoiler-free draft for a beta reader, without keeping two manuscripts in step by hand.

Material with no audience set is visible to everyone — an unmarked project exports exactly as it reads.

See also: Export your manuscript · Audiences: who is allowed to see what · GM-only notes inside the prose

File › Export › Dialogue Script… compiles every branching scene in the project to ink or Yarn Spinner source. Pick the language, pick where to save, and you get a .ink or .yarn file that its own compiler accepts.

Why not just use the game-data export? That one is a versioned JSON contract of ours. If your studio already runs ink or Yarn, adopting it would mean abandoning the runtime you ship on. These two are open, documented and stable, with first-party Unity integrations and Godot support — so this export reaches every engine those runtimes reach, with no plugin from us at all.

What maps to what. In ink, each scene becomes a knot and each node a stitch inside it, named from its own text so the file reads like a script. Variables become VAR, effects become ~ assignments, a choice's options become sticky choices (+) with their requirement as a {guard}, and a Condition node becomes { test: -> a - else: -> b }. Cross-scene jumps become -> knot.stitch. Yarn has no sub-node label, so there each node becomes its own Yarn node, every way onward is a <<jump>>, options carry their <<if>>, and a Start node is written first that <<declare>>s the variables. The speaker set in Who Says This? goes out as Yarn's own Speaker: line convention and as a # speaker: tag in ink.

Everything on the line goes with it. A node's tags, its production direction and its alternate takes are all written into the script in each language's own idiom, and the export report names anything the target language could not express. See Tag a line of dialogue, Direct a line and Give one line several takes.

A Condition's and a Jump's own text becomes a comment, not a line. That text is your label for a fork the reader never sees — emitting it as prose would have the shipped game narrate its own stage directions. The words are still in the file, where anyone reading the script can see them.

It tells you what it could not say. If anything in your story has no equivalent in the language you picked, the file is still written and a window lists every one of them, naming the scene. The common cases: a condition using a function like CONTAINS or SUM (neither language has those, so the option is emitted with no requirement and is always offered), and an option set to be shown and greyed out when its requirement fails (neither language has a disabled option, so it is hidden instead and the reader never learns it exists). Nothing is ever approximated silently — a guard that is right nine times out of ten is worse than one that is absent and said so.

From a script or a build: Ordfoss.exe <project> --export-script ink out.ink (or yarn) writes the same file and prints each note as an EXPORT NOTE: line, so a build can tell a clean export from one that lost something without opening the file.

See also: Write a branching, choice-based scene · Make a branch depend on what happened · Say who speaks a line, and how they say it · Export your world for a game engine · Jump from one scene to another · Tag a line of dialogue, and filter the graph by tag · Direct a line — camera, animation and audio · Give one line several takes

File ▸ Export ▸ Manuscript…

Pick the format — Markdown, HTML, PDF, Word (.docx), EPUB 3, or standard manuscript format — and what to include. You can export the whole manuscript or one part of it, and choose whether the codex goes with it.

The dialog also picks an audience, so you can produce a copy with the GM-only or spoiler material left out.

What the dialog decides

Content chooses what leaves: Manuscript, World Bible (Codex), or Manuscript + World Bible in one file.

Format is Markdown, HTML, PDF, Word (.docx), EPUB, or Standard Manuscript (.rtf) — the last being the shape submissions editors expect rather than a prettier one.

Audience decides who the export is for. Everyone (full manuscript) is everything; choosing a named audience drops what that reader is not meant to see, so one project makes both the players' copy and the GM's without maintaining two.

Scope is the whole manuscript or a single part of it, and Include synopses adds each document's synopsis alongside its text — useful for an outline pass, wrong for a submission.

Manuscript title page fills in what a Standard Manuscript needs: the title, your Pen name if it differs from your own, and a contact block (address, email, phone, one per line).

See also: Export to EPUB · Export to Word · Export in standard manuscript format · Export to PDF · Export without the spoilers

This is the export for another program to read rather than a person: a game engine, a build script, a spreadsheet pipeline.

1. File ▸ Export ▸ Game Data…
2. Which data? — choose one of Codex entities, Timeline events, Research sources, Plot threads or Continuity rules.
3. As what? — JSON (versioned envelope) or CSV (one row per record).
4. Pick where to write it. It confirms with the file name when it is done.

Which format to pick

JSON carries a version field around the payload. That is the one to use from anything that will keep running against future exports: when the shape changes, your importer can tell, instead of silently misreading a renamed field.

CSV is one row per record, for a spreadsheet or a quick script. It is flatter by nature — nested values do not survive as structure — so use it when you want to look at the data, not when something depends on it.

What you get

The export is a slice of the project as it stands, not a live link. Re-export when the world moves on; nothing writes back into Ordfoss from the file.

Entity properties come through with their values, so a Characters export carries whatever fields your categories define rather than a fixed schema — which is what makes it useful to an engine that has its own idea of what a character is.

See also: Export the codex on its own · Turn codex entities into a spreadsheet · Is it useful for TTRPG campaigns?

Narrative teams live in spreadsheets. Producers and localisation leads want a flat table, not a graph — and a graph is not something you can comment on in a shared sheet.

Export. Right-click the Coverage tab in the Branching panel ▸ Export Lines as a Table… and choose a .csv or .tsv name; the separator follows the extension you picked. The columns are Line ID, Scene ID, Scene, Node, Speaker, Text, Condition, Status, Owner and Tags. A line with alternate takes contributes one row per take, each under its own line id, because a take is recorded, translated and approved on its own.

Or keep it in the project. Right-click ▸ Put the Lines in a Spreadsheet makes the same table a spreadsheet inside the project, next to everything it describes. It is a snapshot, not a live view — re-run it when the scene has moved on.

Import. Right-click ▸ Import Lines from a Table… reads an edited file back. Rows are matched on Line ID, so:

• a row whose Scene column is stale still lands on the right line;
• columns can be moved or added — your own Notes column is fine — because they are found by their header name, not their position;
• rows naming a line this project does not have are reported by id, never silently dropped. That usually means the sheet came from a newer or older version of the script, and an import that quietly ignored half a producer's pass would be indistinguishable from one that worked.

What an import can change: Text, Status, Owner and Tags. Everything else is context. In particular Condition is read-only: an expression edited in a spreadsheet by somebody who cannot see the variables is a story bug nobody would catch. The whole import is one undo step, so a pass that went wrong is reverted in one go — never half-applied.

If the file has no Line ID and Text columns, Ordfoss says so plainly: that is the wrong file, which is a different problem from the right file against the wrong script.

See also: Write a branching, choice-based scene · Track who owns each line and how far it has been reviewed · Send your book to a translator · Keep a spreadsheet in your project

File ▸ Import ▸ Scrivener… and choose the .scriv folder.

Folders and scenes come across with their structure intact, so the binder you had becomes a manuscript tree that looks like it.

Scrivener-specific features that have no equivalent here are not invented — what cannot be represented is left out rather than approximated.

See also: Bring in work from another app · Import a Word document

File ▸ Import ▸ Word Document…

It reads a .docx and splits it on its headings, so a manuscript that used Heading 1 for chapters arrives as chapters rather than as one enormous document.

If the document has no headings, you get it as a single document, which you can then split by hand.

See also: Bring in work from another app · Export to Word

File ▸ Import ▸ Obsidian Vault… and choose the vault folder.

Folders come across as folders and [[wikilinks]] are preserved as links between the imported notes, so the web you built stays a web.

Obsidian plugins and their syntax are not interpreted — that content arrives as the text it is.

See also: Bring in work from another app · Import from World Anvil, Campfire or articy

File ▸ Import has an entry for each: World Anvil… takes an article CSV export, and Campfire… and articy:draft… each take that tool's JSON export.

Each article, entry or node becomes a document, keeping the structure the export describes.

Export the file from the other tool first — Ordfoss reads the export, not the live account, so nothing needs a login or an API key.

See also: Bring in work from another app · What is the codex?

1. File ▸ New Project… first. Import into an empty project rather than one you have already worked in — it keeps the result easy to judge and easy to abandon.
2. File ▸ Import, and pick the format. If the tool is not listed, export Markdown, plain text or Word from it and use one of those.
3. Look at the structure before anything else. An import arrives as one undoable step, so if it came in wrong, a single Ctrl+Z removes all of it and you can try a different export.
4. Fix the tree — Move Up, Move Down, Promote, Demote in the Documents panel.
5. Build the codex. The import brought prose; it did not invent your characters. Add entities as you go, or use AI ▸ Generate Codex from Manuscript… to propose them and read what it suggests.
6. If the project came from an older Ordfoss version and the codex has empty fields on everything, right-click the codex and choose Tidy Up Properties….
7. Save. From here it is an ordinary project.

Do not delete the original for a while. An import that looked fine can turn out to have dropped something you only notice in chapter twelve.

See also: Bring in work from another app · Import a Scrivener project · Clean up properties on an older project · Start your first project

File ▸ Export ▸ For Translation…

It writes every translatable string — prose, titles, synopses and footnotes; codex entry names, aliases and property values; category names and field labels; timeline titles and descriptions; comments; and branching dialogue: every scene title, the text of every node, and the label on every choice. In a game project the dialogue is usually most of the words.

The file is XLIFF or CSV, so a translator can work in their own tools. When it comes back, File ▸ Import Translations… reads it in and each string lands back on the object it came from — including the exact node it was spoken by. The original stays where it is; a translation is held alongside it rather than replacing it.

Dialogue is marked as dialogue. Those rows carry the datatype x-dialogue rather than x-markdown, so a translator can see at a glance that a string is spoken aloud — no Markdown conventions apply to it, and length and register matter in a way they do not for prose.

Author's notes on a node and the expressions on a condition are not exported. They are you talking to yourself and code respectively; neither reaches a reader, and sending them out would pay for words nobody reads and invite somebody to translate an operator.

Seeing what is translated and what is not

Every row of the export carries a status, and that is where you read it:

new	never translated
translated	done, and still matches the source
needs-review	somebody has flagged it for a human to look at
needs-translation	translated, but the source text has changed since

That last one is the reason the status is computed rather than stored. Each translation records a digest of the source text it was made from, so rewriting an English line — or a line of dialogue — automatically marks its translations stale. Nobody has to remember which ones were affected, and a translated project cannot quietly drift out of date.

Export again at any point to see the current state: the file is a report as much as a work order, and the count in the status bar afterwards tells you how many strings went out.

There is no in-app panel listing translation status today — the export is where you see it.

See also: Export your manuscript · Bring a translation back in · Find a line of dialogue

1. Run File ▸ Export ▸ Health Report… and read it. Statistics, readability, dialogue and point-of-view balance, style issues — the things worth knowing before anyone else reads it.
2. Fix what you agree with. It is a report, not a verdict.
3. Decide the destination, because it decides the format. A magazine or agent wants standard manuscript format. A publisher or collaborator usually wants Word. A reader wants EPUB. Print or proofing wants PDF.
4. File ▸ Export ▸ Manuscript…, choose that format, and choose what to include — the whole manuscript or one part, with or without the codex.
5. If the project has audiences, pick the one the reader belongs to so spoiler or GM-only material is left out.
6. Open the exported file and read the first page. Export settings are easy to get wrong and trivial to check.

See also: Export your manuscript · Export to EPUB · Export in standard manuscript format · Export a manuscript health report

File ▸ Import, and the list is:

From	What comes across
Scrivener (.scriv)	Folders and scenes, structure preserved
yWriter (.yw7, .yw6)	Chapters and scenes
Manuskript	Outline, characters and world
Obsidian vault	Folders of notes, [[wikilinks]] preserved
Notion (Markdown & CSV export)	Pages and folders
Word (.docx)	Split into sections on its headings
Plain text	Prose, split into scenes on scene-break lines
World Anvil (article .csv)	Each article becomes a document
Campfire (.json)	Project content
articy:draft (.json)	Project content
Screenplay (Fountain, Final Draft .fdx)	Script, formatted

Two of those are worth naming as menu items, because their names are not the tool's: File ▸ Import ▸ Plain Text… for a .txt manuscript, which is split into scenes on scene-break lines rather than arriving as one wall of prose, and File ▸ Import ▸ Notion Export…, which wants the folder Notion gives you when you export to Markdown & CSV rather than a single file.

If your tool is not on that list

Convert a Folder with AI takes any folder of files and turns it into a project — your AI provider reads them and proposes the structure, and you review what it suggests before anything is applied. That is the route for a tool with no importer, or for a decade of loose notes.

What to expect

An import creates real project content, not a linked copy — the original is untouched and nothing depends on it afterwards. Everything imported is undoable as one step, so a first attempt that lands badly comes back with Edit ▸ Undo rather than by deleting things by hand.

Import into an empty project first if you want to see the shape before committing to it.

See also: Import a Scrivener project · Import a Word document · Import an Obsidian vault · Import from World Anvil, Campfire or articy · Turn a folder of files into a project

AI ▸ Ask Your World… answers a question using your own codex as the source.

It needs the world index. If the index is empty, it offers to build it first rather than answering from nothing.

Use it for the things you have written down and forgotten — who ruled before the war, what the third house is called. It answers from your world, not from general knowledge.

See also: Build the world index · Search by meaning rather than words · Does the AI see my writing?

Four of them sit in the editor and work on what you have open.

Summarize condenses the document. Continue Writing carries on from where you stopped. Brainstorm… offers directions rather than prose. Rewrite Selection… reworks what you have selected against an instruction you give.

Each returns an ordinary edit you can Undo. None of them changes anything until you accept it.

See also: Run an AI command on your text · Does the AI see my writing? · Set up the AI features

AI ▸ Generate Codex from Manuscript… reads the manuscript and proposes codex entries for what it finds.

It is for the project that was written before the codex existed — where the characters are all in the prose and none of them are entries yet.

Read what it proposes before accepting. It is working from your text, but it is still guessing at what deserves an entry.

Filling in one entry rather than finding new ones

Draft Details with AI… on a codex entity is the other direction: the entry already exists and you want its properties written. It drafts them from what the project already says about it, which is why it is worth running after the prose exists rather than before.

An entity marked Exclude from AI refuses — untick that on the entity first if you meant to include it.

See also: Chat with the assistant in a dock · Does the AI see my writing? · Add a character or place · What is the codex?

AI ▸ Build World Index reads every codex entity and computes an embedding for it — a numeric form that lets later searches match on meaning rather than on the exact words.

It needs an embeddings endpoint, which is configured separately from the chat endpoint in AI Settings. If none is set, Ordfoss offers to open AI Settings rather than failing quietly.

The index is built when you ask and not before. Rebuild it after adding a lot of entries — otherwise the new ones are not in it.

See also: Ask a question about your world · Search by meaning rather than words · Set up the AI features

Yes, by a different route. Ordfoss ships an MCP server, so Claude Desktop (or Claude Code) can work on your project directly under your existing subscription instead of you paying for API credits.

Help ▸ Connect Claude Desktop… shows the exact configuration snippet to paste.

That is a separate path from the in-app AI features, which need an API key of their own. Many people use only the MCP route.

See also: Claude stopped seeing Ordfoss after the rename · Set up the AI features · What do the AI features cost?

Open the AI Chat panel from the Windows menu. Type a message and press Enter.

It is a conversation rather than a series of questions: the whole exchange so far goes with each message, so the assistant follows what you meant two replies ago. Clear starts a new one, which is what to do when the subject changes — a long conversation about the wrong thing costs tokens on every turn.

Persona picks the voice and role it answers in, from the personas you have set up. It applies to the conversation you are in.

Letting it make changes

Allow the assistant to make changes is off until you turn it on, and read-only chat is unchanged until you do. With it on, the assistant can create and edit entities, documents, timeline events and spreadsheets in this project, and every request applies as one undoable step — so a whole exchange that went wrong comes back with a single Ctrl+Z rather than twenty.

What it changed is written into the transcript as it goes, so the conversation doubles as the record of what happened to your project.

Two guards are worth setting before you turn it on: a locked document refuses to change however it is asked, and anything marked Exclude from AI is never sent.

If nothing happens

The panel does nothing until a provider is configured, and says so rather than failing quietly — it offers to open AI ▸ AI Settings. An empty reply is the model's, not a fault: rephrase, or check the model name.

See also: Let the assistant do a job for you · Give the assistant a persona · Set up the AI features · Does the AI see my writing?

The built-in MCP server is now called ordfoss instead of easywriter. If your Claude Desktop configuration still names the old one, the tools stop appearing.

Open your Claude Desktop configuration and change that one word.

Help ▸ Connect Claude Desktop… shows the exact snippet to paste if you would rather replace the block outright.

See also: Can I use my Claude subscription? · Why did Easy Writer become Ordfoss?

Only what you send, only when you ask it to.

Ordfoss has no AI service of its own. You supply an endpoint, a key and a model, and the AI features talk to that provider directly from your machine. We are not in the middle and we never see the request.

Nothing is sent in the background. If you never open an AI feature, nothing about your writing leaves the machine. What each request contains is what that feature says it contains — the selection, the document, or the world index you built.

If there is material you never want included, mark it Exclude from AI.

See also: Set up the AI features · What do the AI features cost? · Does it work offline? · Keep something away from the AI

The MCP server advertises 127 tools, in ten families:

• Documents — writing, restructuring, versions and variants.
• Codex — entities, categories, properties, merging and splitting.
• Timeline — events, calendar, eras, continuity rules and conflicts.
• Planning — tasks, plot threads, beats and analytics.
• Research — sources, citations, footnotes, comments and media.
• Data — spreadsheets, charts and maps.
• Game material — stat blocks, random tables, dice, encounters and names.
• Languages — sounds, words, grammar, translation and writing systems.
• Export and import — manuscript, codex, website, screenplay, data, content packs.
• The project — overview, search, save, backup, undo, visibility and AI exclusion.

The full reference, one page per tool with its arguments, is in the developer wiki at <https://ordfoss.com/docs/api/mcp/>.

Your MCP client also lists them: ask the assistant what tools it has and it will tell you what it can actually see, which is the answer that matters if something is not working.

See also: Let Claude work on your project directly · What the assistant can do with your documents · What the assistant can do with your codex · What the assistant can do with constructed languages

AI ▸ Find Similar Entities… lists the codex entries closest in meaning to the one you chose.

It needs the world index.

It is useful for finding the two entries you made for the same thing months apart, and for noticing that three minor characters have become interchangeable.

It is reached as Find Similar on a selected entity as well as from the AI menu. With no world index built, it offers to build one rather than answering from nothing — which takes a while on a large project, so it asks first.

See also: Search by meaning rather than words · Build the world index · Add a character or place

AI ▸ Generate Image… produces an image through the provider you configured and stores it in the project's media.

It needs a provider that offers image generation, which is not the same as one that offers chat — check what your endpoint supports.

Generated images live in the project's assets folder like any other media, so they travel with the project.

See also: Set up the AI features · What do the AI features cost? · Keep images and audio in your project

AI ▸ Generate Speech… produces spoken audio through your configured provider and stores it with the project's media.

That is different from Read Aloud, which speaks text immediately using the voices Windows already has and produces no file.

Use Read Aloud to hear a paragraph while editing; use this when you want an audio file to keep.

See also: Have your prose read back to you · Voice-over scripts and takes · Set up the AI features

AI ▸ Manage Personas… holds standing instructions the assistant works under — the voice to write in, the conventions your world uses, what never to do.

A persona saves repeating the same paragraph of context in every request.

It shapes how the assistant writes; it does not give it new abilities.

See also: Run an AI command on your text · Set up the AI features

This answer has not yet been checked against the application.

Check Consistency in the editor reviews the text against what your project says elsewhere, and Check Voice Consistency looks at whether a character sounds like themselves.

These are opinions, not the timeline validator. The Conflicts panel reports what provably breaks a rule you set; this reports what reads oddly to a model.

Treat the output as a reading, not a verdict.

Show Unsupported Claims…

On a document, this lists the statements in it that nothing in your project supports — a rank, a date, a relationship the prose asserts and the codex and timeline do not carry.

It is the useful half of a consistency check, because it points at a specific sentence rather than saying the chapter feels off. Some of what it finds will be deliberate: prose is allowed to know things the codex does not. Treat each one as a question about whether the world should say it too.

See also: Find everything wrong with your project · Does the AI see my writing? · Run an AI command on your text

Right-click the document or entity and choose Exclude from AI.

An excluded item is left out of what the AI features send — including the world index and the assistant's own reads — so it stays on your machine whatever you ask for elsewhere.

It is a per-item mark, and you can turn it off again the same way.

See also: Does the AI see my writing? · Lock a document so it cannot change

Ordfoss ships an MCP server, so Claude can read and change your project directly rather than you pasting text back and forth.

Help ▸ Connect Claude Desktop… shows the configuration to paste. Copy Snippet puts it on the clipboard so you can drop it straight into Claude Desktop's config file without retyping it. Once connected, Claude can search the project, read documents, create entities, add timeline events and more.

Everything it writes goes through the same undo as your own edits, so one Ctrl+Z takes back a whole assistant request. Locked documents refuse to change, however it is asked.

If the server will not start, the path in the configuration is what to check first — the snippet fills it in for you, so this comes up when a project has been moved or renamed since, or when the config was edited by hand. The server refuses a path that is not a project and says so, rather than starting up on an empty one: a server that came up regardless would have Claude reporting an empty project, and its first edit would write a new project into whatever folder that was. The path must be the project folder itself — the one holding project.json — or the .ordfoss file.

See also: Can I use my Claude subscription? · Claude stopped seeing Ordfoss after the rename · Does the AI see my writing?

AI ▸ Ask an Agent… gives the assistant a job rather than a question, and it makes the changes itself.

Everything it does lands as one undoable step, so a whole request comes back with a single Ctrl+Z rather than twenty.

A locked document refuses to change however it is asked, and anything marked Exclude from AI is not sent. Those are the two guards worth setting before you let it work unattended.

See also: Let Claude work on your project directly · Does the AI see my writing? · Lock a document so it cannot change

AI ▸ Apply AI Command… runs one of your saved prompts against the text you are working on.

AI ▸ Manage AI Commands… is where you write them. A command is a prompt you use often enough to name — "tighten this paragraph", "list the sensory details I missed".

Everything a command produces arrives as an ordinary edit, so Undo takes it back.

See also: Run an AI command over many documents · Set up the AI features · Does the AI see my writing?

AI ▸ Batch AI Command… runs one saved command across a set of documents rather than one.

Two things are worth knowing before you start. It costs whatever your provider charges, multiplied by the number of documents — check AI ▸ Token Usage… afterwards. And a batch arrives as one undoable step, so if the result is wrong across the board, one Undo takes all of it back.

Try the command on a single document first.

Running several in order

Tick the commands you want and use Move &Up and Move &Down to put them in the order they should run. Order matters when one command works on what the last one produced — a rewrite after a summary is a different thing from a summary after a rewrite.

See also: Run an AI command on your text · What do the AI features cost? · Does the AI see my writing?

AI ▸ Semantic Search… finds codex entries whose meaning matches what you typed, rather than entries containing those exact words.

It needs the world index built first.

Ordinary text search is still the better tool when you know the word you are looking for — this one is for when you do not.

See also: Build the world index · Search and replace across the whole project · Find entities like this one

AI ▸ Token Usage… reports what this project has used.

It is worth checking after a batch command, which multiplies one request by the number of documents you pointed it at.

The number is what Ordfoss counted sending and receiving. Your provider's own dashboard is the authority on what you are actually billed.

See also: What do the AI features cost? · Run an AI command over many documents · Set up the AI features

This answer has not yet been checked against the application.

Open AI ▸ AI Settings… and fill in the endpoint, your API key and the model name.

Ordfoss is bring-your-own-provider: there is no built-in service and no account with us. The features are absent until you configure one, rather than broken — nothing else in the app depends on it.

Where the key is kept. With your settings on this computer, never in the project — so a project folder you commit, zip or share carries no key. It is encrypted with your Windows user account, so a copy of your settings taken to another account or another machine cannot be read: if you move to a new machine, expect to paste the key in again rather than find it waiting.

Your key is stored locally in your own settings. It is sent only to the endpoint you entered.

The rest of the form

Four kinds of AI, four endpoints, because a provider that does one well may not do the others at all:

• Endpoint URL, API key, Model and Temperature for text.
• Embeddings URL and Embeddings model for semantic search and the world index.
• Image URL and Image model for generated pictures.
• Speech URL, Speech model and Speech voice for read-aloud.

Each is independent: filling in text alone leaves the other three features absent rather than broken, and you can point embeddings at a local model while text goes to a hosted one.

Session token budget caps what a session may spend. It is the guard against an agent run costing more than you meant it to, and it is worth setting before the first long job rather than after.

The same form is also a tab

Preferences ▸ AI holds the identical provider form. It is the one page in Preferences with an explicit Save AI settings button: everything else there is a toggle that applies as you flip it, while an endpoint and a key are a form you fill in and then commit.

See also: Does the AI see my writing? · What do the AI features cost? · Can I use my Claude subscription?

File ▸ Import ▸ Convert a Folder with AI…

It reads a folder of assorted files and proposes what each should become — a chapter, a codex entry, a note — rather than importing everything as undifferentiated documents.

1. Point it at the folder.
2. It scans and counts before it can say how much work there is, so the progress shows a busy indicator during that phase.
3. Review what it proposes. This is the step that matters: it is guessing, from your files, and the review is where you correct it.
4. Accept, and the whole conversion arrives as one undoable step.

It costs whatever your provider charges for the files it reads — check AI ▸ Token Usage… afterwards. For a folder of Markdown with a clear structure, the plain Obsidian Vault or Plain Text importers are free and may be enough.

Reviewing what it proposes

Nothing is written until you say so. The review dialog sorts the proposal into tabs -- Entities, Details, Documents, Timeline, Spreadsheets, Media, Research & Planning and Game Tools -- and every item has a tick. Select All and Select None work on the tab you are looking at, so the ordinary way through is to take everything on the tabs you trust and go through the doubtful one item by item.

Only ticked items are created, and the whole conversion lands as ONE undo step -- so an import you change your mind about is a single Ctrl+Z rather than an afternoon of deleting.

See also: Bring in work from another app · Does the AI see my writing? · What do the AI features cost? · Move a project in from another app and tidy it

Whatever your provider charges for the model you chose. Ordfoss adds nothing on top and takes no cut; the requests go from your machine to your account.

AI ▸ Token Usage… shows what this project has spent, so the bill is not a surprise at the end of the month.

If you never configure a provider, the AI features cost nothing because they never run.

See also: Set up the AI features · Can I use my Claude subscription? · How much does it cost?

This is the largest family, because a language has the most parts.

The language — create_language, update_language, get_language.

Sounds and spelling — set_phonotactics for which sound sequences are allowed, set_orthography for how it is written in the Latin alphabet, set_sound_changes for the changes that produce a daughter language, and derive_daughter_language to produce one.

Words — generate_words and generate_vocabulary to coin them, then add_lexicon_words, update_lexicon_word and remove_lexicon_word to keep the dictionary.

Grammar and use — set_grammar, gloss_text to break a passage down word by word, translate in either direction, and export_reference_grammar for the document about the language.

The writing system — get_writing_system and set_writing_system, upsert_glyph and remove_glyph for individual letters, set_script_metrics and set_script_primitives for the guide lines and the shapes symbols are built from, render_text to set a passage in the script, and export_script.

See also: Let Claude work on your project directly · Build a constructed language · Draw your language's alphabet

Stat blocks — create_statblock, update_statblock, get_statblock.

Random tables — create_random_table, update_random_table, get_random_table.

At the table — roll for dice in standard notation, assess_encounter to weigh an encounter against the party, check_name to ask whether a name is already used in the project, and spell_number to write a number in words.

check_name is worth using before you name anything: it is the difference between two characters called Maren and noticing before the players do.

Note that assess_encounter, check_name and spell_number are assistant tools rather than buttons in the app — the Genre Tools panel has dice, a name generator and a word generator.

See also: Let Claude work on your project directly · Stat blocks for creatures and NPCs · Random tables · Dice, names and quick words

Sources and citations — add_source, update_source, list_sources, and cite to place a citation in the text.

Footnotes — add_footnote, update_footnote, remove_footnote, list_footnotes.

Comments — add_comment, reply_comment, resolve_comment, list_comments. This is the one worth knowing about for a review pass: the assistant can leave its observations as comments attached to the text rather than as a wall of chat you have to transcribe yourself.

Media — add_media, list_media, set_media_caption.

See also: Let Claude work on your project directly · Keep your research and cite it · Add a footnote · Leave a comment on the text

Spreadsheets — create_spreadsheet, update_spreadsheet, get_spreadsheet.

Charts — create_chart, update_chart, get_chart. A chart holds its own categories and series, so the assistant sets those directly.

Maps — create_map, update_map, get_map, covering the pins, regions and routes a map carries.

Filling a sheet is a good use of it: describe the columns and the rows you want and let it write them, rather than typing forty cells.

See also: Let Claude work on your project directly · Keep a spreadsheet in your project · Chart your data · Draw a map of your world

Tasks — create_task, update_task, list_tasks.

Plot threads — create_plot_thread, update_plot_thread, delete_plot_thread, list_plot_threads.

Structure — get_beat_sheet, apply_beat_template to start from a known structure, and assign_beat to attach a scene to a beat.

Reading the project — get_analytics for the statistics, and get_recent_changes for what has moved lately.

get_recent_changes is the one to reach for at the start of a session: asking what changed since last time is faster than remembering.

See also: Let Claude work on your project directly · Keep a to-do list · Track a plot thread through the book · Word counts and writing statistics

Orientation — get_project_overview is usually the assistant's first call: it is how it learns what your project contains before doing anything.

Finding things — search across the project.

Safety — save_project, backup_project, and undo_last to take back the most recent step.

Control — set_visibility scopes an object to audiences; set_ai_exclusion marks something the AI features must not send.

Asking for a backup before a large change is a reasonable habit, and it costs nothing.

See also: Let Claude work on your project directly · Where are my backups? · Audiences: who is allowed to see what · Keep something away from the AI

Entities — create_entity, update_entity, get_entity, and list_category to see what a category holds.

Categories — create_category, update_category, get_category.

Properties — entity_property reads or sets one value. add_field, remove_field, move_field and convert_field change the schema itself, and property_migration handles the larger reshaping of an older project's properties.

Reorganising — merge_entities when the same thing has two entries, split_entity when one entry turned out to be two.

Connections — get_relationships reads the graph; set_entity_threads attaches an entity to plot threads.

The schema tools change what every entity in a category carries, so they are the ones to be deliberate about. Ask to see the effect on one entity before applying a change across a category.

See also: Let Claude work on your project directly · What the assistant can do with your documents · Properties, and who they belong to

Connected over MCP, the assistant can work on the manuscript directly.

Reading — get_manuscript_tree for the structure, get_document for one document, extract_document_text for its prose without markup.

Writing — create_document, update_document to replace a body, append_to_document to add to the end without resending the whole thing.

Restructuring — rename_object, delete_object, and find_replace across the project.

Versions and variants — snapshot_document_version before a big change, get_document_versions to see what exists, manage_variants for alternative takes on one scene.

Plot threads — set_document_threads attaches a document to the threads it belongs to.

Everything it writes goes through the same undo as your own edits, so one Ctrl+Z takes back a whole request. A locked document refuses to change, however it is asked — that is the guard worth setting before letting it work unattended.

See also: Let Claude work on your project directly · What the assistant can do with your codex · Lock a document so it cannot change

Events — create_timeline_event, update_timeline_event, and get_timeline to read what is there.

The calendar — get_calendar and update_calendar for your world's months and lengths; manage_eras for named stretches of history.

Validation — get_conflicts reads the contradictions the timeline found. create_continuity_rule, list_continuity_rules and delete_continuity_rule manage the rules it checks against.

Threads — set_event_threads attaches an event to plot threads.

Asking the assistant to read get_conflicts and explain a contradiction is one of the better uses of it — the validator says what is wrong, and it can work out why.

See also: Let Claude work on your project directly · What the timeline is for · Find everything wrong with your project

Exporting — export_manuscript, export_codex, export_website, export_screenplay, and export_data for the structured slices.

Importing — import_file reads a file into the project.

Content packs — save_content_pack writes a shareable piece of the project, and apply_content_pack brings one in.

An export driven by the assistant produces the same files as the menu does. It is useful when the export is one step of a longer job you have asked for, rather than the thing you sat down to do.

See also: Let Claude work on your project directly · Export your manuscript · Bring in work from another app · Reuse a project setup elsewhere

Open the Script Console panel from the Windows menu.

Scripts reach the project through a world bridge — a documented set of calls for reading and changing what is in the project. The scripting reference in the developer wiki lists every one.

It is the right tool for a repetitive job: renaming a hundred entities to a pattern, or checking something across every document.

Keeping a script

Save As… stores a script so it can be run again, and saved scripts appear as commands. Until there is one the list says No commands yet rather than showing an empty box, so a first visit tells you what is missing instead of looking broken.

A script runs against the live project through the world bridge, and its whole run is one undo step -- so trying one is cheap even when it turns out to do the wrong thing.

The macro library

The row above the editor is a library of saved scripts. The picker loads a saved macro into the editor; Save writes the editor's script back over the macro you have selected; Save As… saves it as a new named one; Delete removes the selected macro. With nothing selected, Save behaves as Save As…, because there is nothing to save over.

Run — or Ctrl+Return — runs whatever is in the editor, saved or not.

See also: Extend Ordfoss with a plugin · Let Claude work on your project directly

Ordfoss loads first-party and third-party plugins built against a C++ API.

The developer wiki at <https://ordfoss.com/docs/api/> documents every public class in the plugin headers, and an example plugin ships in the repository.

If what you want is to automate something rather than add a feature, scripting is usually the shorter road.

See also: Automate something with a script · Let Claude work on your project directly

Edit ▸ Preferences… holds the theme — including dark and sepia — the interface font, and the font your prose is shown in.

The editor font is a display choice: it changes what you look at, not what is stored or exported.

For a quick change of size rather than a permanent one, use zoom.

Making your own theme

Edit Theme opens the colour editor. Each row is one role rather than one widget, which is why a handful of choices restyles everything: Window background and Window text for the frame, Editor background and Editor text for the page you write on, Button background and Button text for the controls, Selection and Selected text for highlighted text, and Links. Dark theme (light text on a dark window) tells the rest of the interface which way round your colours run.

It checks itself as you go: the dialog reports whether every text pair meets the WCAG AA contrast minimum of 4.5:1, and names the pairs that fall short with their actual ratio. A theme that looks striking and cannot be read is the usual outcome of picking colours by eye, and this is the guard against it.

Interface size

Separately from the fonts, the interface scale offers Small, Normal, Large and Extra large — that is chrome, menus and panel text, not your prose. The interface language has a System default setting that follows the operating system, so it only needs changing if you want Ordfoss in a different language from everything else.

See also: Where the settings are, and what is on each tab · Make the text bigger or smaller · Find a panel you cannot see · Is Ordfoss usable with a screen reader?

Every panel lives in the Windows menu — but not as one long list. Forty-odd panels in alphabetical order put Agenda beside AI Chat and Board, so they are grouped by what each one is for, one submenu each:

• Writing — Editor, Documents, Document Info, Outline, Corkboard, Comments, Footnotes, Markdown Preview, Screenplay.
• World — Codex, Inspector, Relationships, Timeline, Conflicts, Maps, Languages.
• Planning — Board, Tasks, Agenda, Plot Threads, Beat Sheet, Submissions, Pinned.
• Research — Sources, PDF, Media, Gallery, Canvas.
• Progress — Statistics, Goals, Sprint, Pacing, POV Balance, Tension, Style.
• Data — Spreadsheet, Charts.
• Tabletop — Genre Tools, Stat Blocks, Random Tables.
• Assistant — AI Chat, Script Console.

Anything not in one of those appears under a trailing Other heading rather than going missing. The Windows menu is the only way back to a closed panel, so nothing is allowed to fall out of it.

Bringing several back

The layout commands are in the View menu, not in Windows. View ▸ Show All Panels reopens every panel that is currently closed, and View ▸ Reset Layout returns the whole arrangement to how it ships.

Panels are docks: you can drag one into a different position, tab them together, or float one as its own window.

See also: Put the window arrangement back · Keep more than one window arrangement

Partly, and it is better to be exact than encouraging.

Every icon-only control carries an accessible name and description, the main window's focus order has been checked so a Tab-pressing user can reach what is on it, and the shipped themes have been measured against the WCAG contrast ratios.

What has not been done is a pass with an actual screen reader, and non-text contrast has not been measured. If you rely on assistive technology, please write to <[email protected]> and say what does not work — that is worth more than another internal audit.

What the Accessibility tab holds

Edit ▸ Preferences ▸ Accessibility has three settings. Interface font size — Small, Normal, Large, Extra large — sizes the menus and panel text rather than your prose. Use a high-contrast colour theme swaps the palette. Reduce motion (disable panel animations) turns off the animated transitions as docks open, close and move, for anyone who finds movement distracting or nauseating.

See also: Where the settings are, and what is on each tab · See and change the keyboard shortcuts · Change the theme, fonts and colours · Have your prose read back to you

View ▸ Perspectives ▸ Save Current Layout As… names the arrangement you have now, and it joins the top of that same Perspectives submenu, so you can switch back to it in one click. A saved arrangement is called a perspective.

That is how you keep one arrangement for drafting, another for revising with the analysis panels open, and a third for map work.

View ▸ Perspectives ▸ Delete Perspective… removes one you no longer use. It is greyed out until you have saved at least one.

The layout commands all live in View; the Windows menu holds the panel toggles.

See also: Put the window arrangement back · Find a panel you cannot see

View ▸ Zoom In and Zoom Out scale the text in the editor, and Reset Zoom puts it back.

Zoom affects the view only. Nothing about the document changes, and an export is unaffected.

For a change that persists across sessions and covers the whole interface rather than the editor, set the fonts in Preferences instead.

See also: Change the theme, fonts and colours · Is Ordfoss usable with a screen reader?

View ▸ Reset Layout puts every panel back where it started. It is in the View menu with the other layout commands — the Windows menu holds the panel toggles only.

It changes only the arrangement. Nothing in your project is touched, and no settings are cleared.

If one panel is missing rather than the whole layout, you do not need this: open it from the Windows menu, or use View ▸ Show All Panels to reopen every closed panel at once.

If you had an arrangement you liked, save it first — see the layout-saving entry — because reset does not ask.

See also: Find a panel you cannot see · Keep more than one window arrangement

Help ▸ Keyboard Shortcuts lists every shortcut the app has, in one window you can read rather than hunting through menus.

The usual editing keys are what you expect. The ones worth learning are Quick Open for jumping to anything by name, and the panel toggles for the panels you use constantly.

See also: Is Ordfoss usable with a screen reader? · Change the theme, fonts and colours

Ordfoss can post to a chat channel you already own — a gaming group's Discord, a writing group's Slack, a team's Teams channel.

1. Create an incoming webhook in that service and copy its URL. Ordfoss does not create it and has no account with any of them.
2. Edit ▸ Notifications…
3. Add a destination: paste the URL and say which service it is, because the three expect different message shapes.
4. Send a test message and check it arrives before relying on it.
5. Enable or disable a destination without deleting it.

The feature is absent rather than broken when nothing is configured — the same shape as the bring-your-own AI provider. Nothing in the app needs it, and nothing degrades without it.

The URL is stored in your own settings and is sent nowhere but the service it belongs to.

See also: Roll dice · Does it work offline? · Is it useful for TTRPG campaigns?

Edit ▸ Preferences… — there is no separate Settings menu, and most pages take effect the moment you change them rather than on an OK button.

Nine tabs, and knowing which one holds what is most of the problem:

• Appearance — the colour theme, and making, importing or exporting your own.
• Editor — the prose font and size, spell check, autocorrect and smart punctuation, the live word count, and autosave with its interval.
• Accessibility — interface font size, a high-contrast theme, and reduced motion.
• Keyboard — every command's shortcut, rebindable, with a reset per command.
• Toolbars — which buttons each toolbar shows.
• AI — your provider's endpoint, key and model.
• Language — the language Ordfoss's own interface is in.
• Plugins — what loaded at startup and what failed, with the reason.
• General — what happens when Ordfoss starts.

Starting up — the General tab

Reopen the last project when Ordfoss starts is on by default. Turning it off is also the first thing to try when one particular project stops the app from starting: it separates a bad project from a bad install in a single launch.

Check for updates when Ordfoss starts asks the update server for the newest version number, once per launch. The request carries no personal data and nothing is ever installed without your say-so; untick it and Ordfoss stops asking.

Update channel chooses which releases you are offered: Stable, the released version, or Beta, early builds. Beta needs an access key and cannot be selected without one — paste the key into Beta access key and click Verify first. See the beta channel.

Show the welcome screen on the next launch brings the first-run screen back.

The interface language — the Language tab

Interface language is what Ordfoss's own menus, buttons and dialogs are written in. System default follows the operating system, so it only needs changing if you want Ordfoss in a different language from everything else; English and Español are what ships. It takes effect the next time Ordfoss starts.

That is the interface, not your writing. Translating a project's own content is a separate job: export the strings for a translator and import what comes back.

See also: Change the theme, fonts and colours · Is Ordfoss usable with a screen reader? · See and change the keyboard shortcuts · Keep more than one window arrangement

Ordfoss refuses to open a project that a newer version saved, and that refusal is protecting the project.

A newer version can store things this one has never heard of. If this version opened the project and you saved it, everything it did not recognise would be dropped — silently, with no error and nothing to undo. Refusing is what keeps the file whole.

Two ways on

Update Ordfoss and open it normally. This is the one that loses nothing, and it is the right answer whenever you can take it. Help ▸ Check for Updates…

Create Working Copy, offered as a button in the message itself. Your project stays exactly as it is, under its own name. A separate copy appears beside it named YourProject-WorkingCopy, and that copy opens here.

Be clear about what the copy is: it holds only the parts this version understands. The rest is not in it, and saving it will not bring them back. It is somewhere to keep writing, not a replacement.

Keep the original. A later version of Ordfoss opens it in full, and the writing you did in the working copy can be brought back into it then.

Making a second working copy never overwrites the first — it is numbered instead — so nothing you have already written in one is lost to the other.

How this happens

Usually two computers, or two installs, on different versions: a laptop on the newer one, a desktop that has not updated yet. It also happens after using a beta and going back to the stable release.

Projects saved by older versions open normally and are stamped with the current version the next time you save, so this only ever points one way.

See also: Ordfoss won't start, or a project won't open · Check for a new version · Where are my backups? · Moving a project, cloud folders, and what happens if you uninstall · What happens to .ewriter files?

If it crashed

Autosave runs while you work — it is on by default, and its interval is in Edit ▸ Preferences ▸ Editor. Whatever it last wrote is on disk, so a crash costs you the time since the last autosave rather than the session.

Reopen the project and check the end of what you were writing. If something is missing, the backup folder is the next place to look.

Undo

Edit ▸ Undo goes back as far as the session does. There is no fixed depth — the history is not trimmed at fifty steps or a hundred — but it belongs to the open project and does not survive closing it. Undo is for the mistake you just made, not for last week.

Every change goes through it, including ones made from panels and by the AI assistant, and an AI edit undoes as one step rather than as forty.

Something deleted by accident

Undo, if you are still in the session. Otherwise, the backup you took, or your version control history if the project is in Git or Perforce.

Back Up Project Now (File menu) writes a timestamped copy of the whole project to your backups folder. It takes a second and it is the only one of these that helps a week later, so it is worth doing before anything large — a big import, a bulk AI operation, a restructure.

Seeing what changed

Edit ▸ Activity… lists what has been changed in the project and when, including changes made in earlier sessions, so you can see the history of an object even after undo can no longer reach it. Its columns are When the change happened, Who made it, What it was, and the state it left things in, which reads Done, Undone or Redone — so a change you took back is still in the history, marked as taken back, rather than vanishing from it.

A row in italics has not been written to the journal file yet; it is saved with the project, so saving is what makes it permanent.

Document variants keep alternative drafts side by side, with a diff between them.

See also: Where are my backups? · Get an earlier draft back · Moving a project, cloud folders, and what happens if you uninstall · Keep two versions of the same scene

There are no imposed limits. No cap on entities, documents, timeline events or words, no tier that unlocks more, and nothing counts your usage. A project is files on your own disk, so what it can hold is what your disk can hold.

What actually costs time

• Opening a project reads its files, so a very large project takes longer to open than a small one. It is a one-off at open, not a cost you pay while writing.
• Whole-project operations — a validation run, a manuscript export, a health report, building the AI world index — scale with the project. They are the operations that show a progress bar, which is why they have one.
• Typing does not. The editor works on the open document, and the panels that watch it are debounced so analysis runs when typing settles rather than on each keystroke.

A long manuscript

Prose is split into documents — chapters, scenes — and only the open one is being edited. A several-hundred-thousand-word manuscript is a few hundred modest files rather than one enormous one, which is the usual reason a word processor struggles and this does not.

If something feels slow

Close panels you are not using; each one watches the project and updates when it changes. And check whether the project sits in a cloud sync folder, since a sync client scanning the folder while you work is a common cause of pauses that look like the application.

Not yet benchmarked. This describes how the program is built rather than measured thresholds: there is no published figure for where a project becomes slow, because none has been measured. If you hit a size where it degrades, that is worth reporting — it would be the first data point.

See also: Moving a project, cloud folders, and what happens if you uninstall · Word counts and writing statistics · Does it work offline?

This answer has not yet been checked against the application.

Email <[email protected]> — a human reads it.

Include the version number from Help ▸ About, and if it's about a specific project, whatever you can share about it. If the app crashed, say what you were doing immediately before.

Feature requests go to the same address. There is no tracker to sign up for.

See also: Where are my backups? · Windows warned me about the installer

If the application will not start

1. Check it is not already running — look in Task Manager for Ordfoss.exe. A previous instance that has not fully exited will make a new launch appear to do nothing, because the app hands the file to the running copy instead of opening a second window.
2. Start it without reopening the last project. If a specific project is what breaks it, launching clean tells you that immediately. The setting is Reopen the last project when Ordfoss starts, in Edit ▸ Preferences ▸ General.
3. Reinstall over the top. It keeps your projects and settings, and replaces anything in the installation that went missing.

If a project will not open

Your prose is Markdown and your structure is JSON, in an ordinary folder — so a project that will not open is still readable, and usually still repairable.

1. Open the folder and confirm the files are there. A project on a cloud drive that has not finished syncing looks damaged and is not.
2. Try a backup. Back Up Project Now writes timestamped copies, and restoring one is copying the folder back.
3. If it is in version control, the previous revision is the fastest fix — and the diff will show you what changed.
4. Open the file the error names. A JSON file that has been edited outside the app and left invalid is the usual cause, and a text editor will show you where.

If it says "That is not an Ordfoss project"

You pointed it at something that is not one, and it says so rather than opening an empty window over it. A project is one of exactly two shapes, and there is a menu item for each:

• a single file ending .ordfoss (or .ewriter, which older projects use and which always keeps working) — File ▸ Open…
• a folder that holds a project.json — File ▸ Open Project Folder…

Two things account for nearly every occurrence. The first is picking the folder that contains the project folder rather than the project folder itself: open it and look for project.json, and if it is one level down, that level down is what to choose. The second is a project whose files have moved or been renamed, leaving the recent-projects entry pointing at what is left.

If it says the project was saved by a newer version of Ordfoss, that is a refusal on purpose and the project is fine — see project-from-a-newer-version.

Nothing is lost while you work this out. Every document is a separate file, so a problem in one does not make the others unreadable, and the worst case is opening the prose directly in a text editor.

If none of that helps, report it — include what the error said and what you had just done. That last part is what makes it reproducible, and a bug nobody can reproduce is one nobody can fix.

See also: Crashes, undo, and getting something back · Where are my backups? · Moving a project, cloud folders, and what happens if you uninstall · How do I report a bug? · Windows warned me about the installer · A project saved by a newer version of Ordfoss

A project is a folder of files, so other things can change them — a version-control update, a text editor, the MCP server working while the app is open.

File ▸ Check for External Changes… looks at what moved on disk and reconciles it.

If you have unsaved work, that is taken into account rather than overwritten. Save first if the change is large — it costs nothing and removes the question entirely.

Deciding in bulk

Each file can be resolved on its own, and when the whole set goes one way there are two buttons for it: Keep All Mine takes your in-memory version for every file, and Take All On-Disk takes what the other writer wrote. They set every row at once, and you can still change individual rows afterwards before applying.

When it is one file and you are still in it

If a document you have unsaved edits in changes on disk, the reload asks rather than picking: Take On-Disk Version discards your in-memory edits for it and loads what the other writer wrote, Keep My Version keeps yours and overwrites the on-disk change when you next save, and Cancel does neither and leaves everything as it is. Cancel is the default, because the safe answer to a question you did not expect is to not answer it yet.

That is the same decision as the two bulk buttons above, asked about a single file.

See also: Where does my writing live? · Where are my backups? · Let Claude work on your project directly

Two counts differ for one of a few ordinary reasons.

The scope may not match: the status bar counts the document you are in, the Statistics panel counts what you have selected in the tree, and an export counts what you exported — which may exclude an audience's material.

Word processors also disagree with each other about hyphenated words, numbers and headings, so an exported file will rarely match another program to the exact word.

If a count moved without you writing, check whether something is excluded from AI, hidden from the current audience, or in a variant you are not looking at.

See also: Word counts and writing statistics · Set a writing target

Windows SmartScreen warns about installers it hasn't seen many times before. It is a reputation check, not a scan — a new installer from a small publisher trips it until enough people have run it.

If you want to go ahead, choose More info and then Run anyway.

If you would rather not, that is a reasonable position, and waiting costs you nothing.

See also: What platforms does it run on? · How do I report a bug?