This build is unsigned. On first launch macOS may say "Parlance is damaged and can't be opened." — it isn't. That's just Gatekeeper's warning for any unsigned app downloaded from the internet.

Drag Parlance to /Applications, then run once:

xattr -cr /Applications/Parlance.app

After that it opens normally.

Installing on Windows

This build is unsigned, so SmartScreen may show "Windows protected your PC." Click More info → Run anyway.

Installing on Linux

.deb (Debian, Ubuntu): sudo apt install ./parlance-desktop_*.deb. On Ubuntu 23.10 and later the package installs a small AppArmor profile so Chromium's sandbox can start; nothing else is needed.

AppImage: chmod +x Parlance-*.AppImage and run it. On Ubuntu 23.10 and later an AppImage cannot use the sandbox (AppArmor blocks it and an AppImage cannot carry a profile), so if it exits at once with "The SUID sandbox helper binary was found, but is not configured correctly", start it with --no-sandbox, or use the .deb instead. The AppImage also needs FUSE 2, which Ubuntu 22.04 and later no longer install by default: if it fails with "dlopen(): error loading libfuse.so.2", run sudo apt install libfuse2 (libfuse2t64 on 24.04).

Something not right?

Parlance sends no telemetry and files no crash reports, so a problem with this build is invisible until someone says so — report a bug or send feedback.

What's new

Parlance 0.16.0 — Edit while you play, a demo in the box, and a runtime you can ship

Nothing in your project needs converting, and the file format is unchanged. A project that passed the validator on 0.15.0 still passes, with one thing to check: the editor now flags unknown or misspelled keys (isend, showif) that it used to ignore. CI already rejected these, so you will only see them if you never ran the validator outside the editor. There is also one new warning, described below.

Editor

• Edit while Play runs. While a Play session is open, the right-hand column has two tabs, Play and Edit, over one session. Click a node (or just switch to Edit) to fix the line you're standing on. The session keeps your state and picks up the change, and it now survives a switch to the Text view.
• Validation jumps to the exact spot. Clicking a problem lands on the node, the choice, the quest stage or objective, the exit, the form field or the grid row, not just the file. Flag, reputation and relationship warnings can now be clicked too, and the Flow panel appears on factions, characters and items.
• Quest editing without JSON. Journal name and tags sit in the quest inspector. Stages move earlier or later in play order. If a move changes what an existing condition means, you get a warning first.
• Rename stage and outcome ids. Every reference is rewritten: conditions, quest effects, routes, snapshots, localization keys, review threads and the canvas layout. Same-named stages in other quests are left alone. The same rename works from parlance rename and the MCP rename_entity tool.
• Outdated translations. Change an English line and its translations are marked outdated on the coverage bar instead of passing as done. The locale template lists what changed for the translator, and Mark current accepts a typo-level edit. Existing catalogs report nothing new until a line changes.
• Explore models return visits. A scene you can go back to (an object you examine again, an arrival scene, an exit's denial dialogue) is now revisited with the state you built up elsewhere. Nodes that need that state no longer show as unreached. Find a path here gets a budget control.
• Passive checks in Play. Play applies the passive-check reveal the way your game would: an unrevealed passive choice is hidden, or greyed if it is set to show when locked. An optional toggle lists what a higher skill would reveal. The Starting State panel adds reputation, relationships and quest stages.
• New warning (FLOW): a node whose only choices are passive checks. A game that hides unrevealed passive choices could show nothing clickable there, and the runtime still holds back any fallback choice. Give the node one ordinary choice.
• Reorder choices with ↑/↓ in the node inspector (or Alt+↑/↓). + Add condition / effect / modifier no longer saves a blank entry and flashes an error while you fill it in.
• Your typing is safe when a file changes underneath. If git, the MCP server or a second window changes a file while you are mid-edit, the inspector fields and the Text view keep your text and offer the file's version instead of replacing what you typed. Two quick saves to one entity no longer produce a false "changed on disk".
• The check odds bar now accounts for penalties and critical rolls, and shows the range across modifiers.
• Drafts: Get review notes pulls the reviewer's comments into the draft you're in. The verdict bar matches the verdict given and shows the writer's note. A re-sent draft moves to "Waiting for you".
• Stricter, sturdier validation. A file that is valid JSON but the wrong shape is reported by name instead of emptying the sidebar or stopping the editor. Unknown keys are flagged in the editor as they already were in CI. Dice past 100 dice or 1000 sides are refused instead of freezing the inspector. A character with many equally ranked offers gets ten tie warnings and a summary, not hundreds of thousands.

Desktop app

• The demo is in the box. File → Open the Demo (or the welcome screen) copies The Mistfall Inn to Documents/Parlance the first time and opens your copy after that. It never overwrites your edits.
• The MCP server ships with the app. Help → Connect an AI Agent… gives ready-to-copy setup for Claude Code and other MCP clients, pointed at the open project. No separate install is needed.
• A hardening pass over saving, file locking, the file watcher, git and sign-in. Network git operations time out instead of hanging, review sync no longer lets an older verdict overwrite a newer one, and publishing always targets the repository's default branch.

CLI & CI

• Pull-request annotations. parlance ci-check, parlance route and tooling/validate.py take --annotations github|none|auto. Under GitHub Actions (the default) each problem shows on the changed file and line of the PR. Exit codes do not change.
• parlance init never overwrites. It refuses an existing project or a non-empty folder (exit 1) before writing anything; a usage mistake exits 2. --force allows a non-empty folder but still keeps every existing file. The first-conversation template now works from the npm package.
• parlance explore --json and parlance witness --json print only JSON on stdout.
• A route's advance step is capped at 10,000 and stops as soon as it loops.
• The MCP server refuses to write an entity that fails its own schema (written: false, nothing on disk).

Runtime & spec

• @orbitope/parlance-runtime, MIT, on npm. It is the same playback code the editor's Play panel runs (conditions, effects, dialogue stepping, checks, offers, quests, dice), with a loader and zero dependencies, and it passes every conformance vector. A JavaScript or TypeScript game can install it instead of writing a port.
• The schema and the runtime conformance vectors are unchanged, so a 0.15 runtime plays every 0.16 project the same way. The reference runtime now reads state by own keys only, so a flag named constructor behaves like any other. It lists codex entries in plain id order.
• Validator ports owe the new passive-only FLOW warning, the dice bounds, the capped OFFER tie report, ECMA-262 pattern anchoring and total reporting over malformed files. Eighteen new validator conformance cases (129 in all) pin them. The Python reference validator now rejects a custom-type row id that isn't lowercase snake_case, and an id ending in a newline.
• Locale files may carry @sourceHashes and @outdated entries. Engines loading translations must skip keys that start with @.

Docs

• INTEGRATION.md: installing and loading with @orbitope/parlance-runtime, skipping locale metadata, and an accurate account of what the Godot and Unity ports load.
• The editor guide, cookbook and tooling READMEs were brought in line with the app, and cover passive checks and fallbacks, the Play/Edit tabs, quest editing and outdated translations.

Migrating a project, or maintaining a port? A project needs nothing beyond fixing any SCHEMA or RULES error the validator now names. Runtime ports can move their pin. Validator ports have a checklist. All three are covered in MIGRATIONS.md and the published spec at github.com/Orbitope/parlance-spec.

This build is unsigned. On first launch macOS may say "Parlance is damaged and can't be opened." — it isn't. That's just Gatekeeper's warning for any unsigned app downloaded from the internet.

Drag Parlance to /Applications, then run once:

xattr -cr /Applications/Parlance.app

After that it opens normally.

Installing on Windows

This build is unsigned, so SmartScreen may show "Windows protected your PC." Click More info → Run anyway.

Installing on Linux

.deb (Debian, Ubuntu): sudo apt install ./parlance-desktop_*.deb. On Ubuntu 23.10 and later the package installs a small AppArmor profile so Chromium's sandbox can start; nothing else is needed.

AppImage: chmod +x Parlance-*.AppImage and run it. On Ubuntu 23.10 and later an AppImage cannot use the sandbox (AppArmor blocks it and an AppImage cannot carry a profile), so if it exits at once with "The SUID sandbox helper binary was found, but is not configured correctly", start it with --no-sandbox, or use the .deb instead. The AppImage also needs FUSE 2, which Ubuntu 22.04 and later no longer install by default: if it fails with "dlopen(): error loading libfuse.so.2", run sudo apt install libfuse2 (libfuse2t64 on 24.04).

Something not right?

Parlance sends no telemetry and files no crash reports, so a problem with this build is invisible until someone says so — report a bug or send feedback.

What's new

Parlance 0.15.0 — Richer choices, story-logic testing, and your own data types

This release changes more than any before it. Nothing in your project needs converting: every project that was valid on 0.14.0 opens, validates and plays exactly as before. The new choice and node shapes are opt-in, and the editor now edits your custom game data too.

New ways to write a choice

• Hide the line, keep the choices. A showIf on a node that has choices, or that ends the dialogue, now hides only its line. The choices are still offered, and the dialogue still ends. The validator used to reject both shapes.
• Nodes with choices and no line. A node can present its options on their own.
• Fallback choices. Mark a choice fallback and it appears only when none of the node's other choices is available, so the player is never stuck. The "may be stuck" warning goes away on nodes that have one.
• Locked choices. A choice whose condition fails can be shown greyed out instead of hidden, with its own lockedText ("Requires Persuasion 4"). Set it per choice, or for the whole project with rules.choices.whenLockedDefault. lockedText is localizable and counted in word counts. It is never voiced.
• Tags on lines and choices. node.tags and choice.tags are passed through to your game untouched, for camera cues, mood, analytics or anything else your engine reads.
• Engine commands. A new engine effect, { "type": "engine", "command": "shake_camera", "args": [0.5] }, hands a command to your game at that point in the effect order without changing story state. Declare your commands in rules.engine.commands and the validator checks names and argument counts (ENGINE).

All of these work in the inspector, the canvas, the Text view (round-trip), Play, and the shareable player.

Story-logic testing

• Explore (Reports → Explore, or parlance explore) plays your story for you: seeded random playthroughs, then an exhaustive pass that takes every choice and both outcomes of every check. It reports unreached nodes and choices and real dead ends, and says when it was cut short, so a node is never called unreachable just because the search stopped.
• Find a path here (node inspector, or parlance witness) finds a way to reach a node. Keep it as a snapshot to start Play from, or as a route, offered once replaying it has proved it reaches the node.
• Route coverage (parlance route --coverage, the Explore tab and the flow map) shows which nodes your saved routes touch.
• Replay a route in Play. Load a saved route and step through it with the canvas following. If a step no longer holds, replay stops and leaves you in a live session: carry on by hand, then Update route or Save as new. Show on map marks the route's scenes on the flow map.

Custom game data

Declare your own entity types (drinks, suppliers, spells, loot tables) in the editor with the sidebar +, and edit them in a spreadsheet-style grid: inline edit, sort, column:value filters, copy and paste to and from Excel or Sheets, a picker for reference fields, problems marked on each cell, and undo. It stays quick at 50,000 rows. A Fields panel adds, retypes, renames and removes fields, carrying values with a renamed field. Custom rows show up in search, review and draft diffs, the prose check's canon names, and export (parlance export --format csv|json --type <id>). Agents get four MCP tools for them. Both validators check the declarations in data/types.json.

Rename an id everywhere

Rename id (entity view, the command palette, parlance rename, or the MCP rename_entity tool) rewrites every reference to an entity's id: other entities, localization and VO keys, bindings, test routes and snapshots, lore links, review threads and canvas layout. You see every file it will change before it runs. If anything changes on disk after the preview it refuses, and it never deletes the original until the new one is written. Nested ids (nodes, choices, quest stages) and custom rows can't be renamed yet.

Lore as linked documents

A new Lore surface in the sidebar edits your lore/ Markdown with live links: [Mara](parlance:character/mara) links show up in find-usages, under "Mentioned in lore" on the entity, and as a warning (never a block) when you delete it. The prose check flags a dangling link and a plain entity name that could be linked. You can open review threads on a lore paragraph. If the paragraph is later edited, the thread is marked moved or stale instead of quietly pointing somewhere else.

Also in this release

• Script export. A .docx screenplay or an .xlsx line sheet (speaker, loc key, VO key, condition, check and effects per line) for one dialogue or the whole project, from the canvas toolbar, Reports, or parlance export --format docx|xlsx.
• Placeholder voice lines. A voice row in the Play panel reads lines aloud through your own text-to-speech provider (an OpenAI-compatible API or a local command), set up under AI settings → Voice. Audio is cached outside data/ and never counts as recorded VO.
• A better Text view. Syntax highlighting, a line gutter, find & replace, and autocomplete for ids.
• Reports. A Speakers tab (lines, words and voiceable lines per speaker, for casting and VO budgets), a Flag flow view (search a flag and see everything that sets it and everything that reads it), and codex-term mentions in the prose report (CODEX_MENTION).
• Asset bindings. An optional data/bindings/*.json maps portraits, VO lines and cutscenes to engine asset paths per profile, and the reference validator warns (BIND) on anything used but unbound, or bound but missing.
• Exclusive flag groups. List flags that must never be true together in rules.flag.exclusiveGroups, and both validators flag an effect that sets two at once.
• Four new importers: SugarCube, ChoiceScript, Arcweave and Ren'Py, joining Yarn, Ink and Twine/Harlowe. The existing importers now use the new choice shapes and lose far less (the Yarn example: 101 declared losses down to 37), and Yarn commands such as <<shakeCamera 0.5>> become engine commands.
• Files from Windows tools load. A JSON file saved with a byte-order mark (PowerShell 5.1, older Notepad) used to drop out of the project silently, and re-creating the "missing" entity then overwrote it. Such files now load, an unparseable file is reported as a problem instead of vanishing, and creating an entity refuses to write over a file that failed to load.
• Accented lore file names match on every OS.

Desktop app fixes

A five-round audit of the packaged app (not the dev build) fixed more than 40 bugs that only showed up there. The ones you are most likely to have hit:

• Share build saved nothing in every desktop release. It works now.
• Quit and closing the window no longer discard unsaved edits, and Quit no longer stops the host in the middle of a save.
• New projects no longer all claim port 8000, so the app can't open another project's window by mistake.
• Review and Drafts now commit only the project's own folders. "Send for review" used to push the whole repository, local files included.
• Explore and Find a path here run with a time limit instead of freezing a large project.
• A right-click menu, links that open in your browser, the system proxy honoured, launch arguments and macOS "Open With" respected, and no downgrade offers from the update check.
• Windows: no console window flashing on every git call, saves retry while antivirus or OneDrive holds a file, and ids like con or aux are refused.
• The "First conversation" template is back in the packaged app.

Writing your own runtime? 0.15.0 is a contract release. A 0.14 runtime can strand a player on a 0.15 project (it skips a gated node that carries choices, and shows a fallback choice beside the choices it was meant to replace), so ports must upgrade: return gated nodes with textHidden, apply the fallback partition, return lockedChoices, throw from chooseChoice on a choice that isn't selectable, pass tags through, and handle the engine effect. The full checklist and the new conformance vectors are in MIGRATIONS.md and the published spec at github.com/Orbitope/parlance-spec.

This build is unsigned. On first launch macOS may say "Parlance is damaged and can't be opened." — it isn't. That's just Gatekeeper's warning for any unsigned app downloaded from the internet.

Drag Parlance to /Applications, then run once:

xattr -cr /Applications/Parlance.app

After that it opens normally.

Installing on Windows

This build is unsigned, so SmartScreen may show "Windows protected your PC." Click More info → Run anyway.

Something not right?

Parlance sends no telemetry and files no crash reports, so a problem with this build is invisible until someone says so — report a bug or send feedback.

What's new

Parlance 0.14.0 — Dialogue offers, and conditional check modifiers

The headline is a better way to decide which dialogue a character plays, with the editor rebuilt around it — plus conditional bonuses on skill checks.

Dialogue offers replace the character ladder

A character no longer owns an ordered dialogues ladder. Instead, each dialogue self-declares when it should play with an offer — { character?, when?, priority? } — and the engine picks the best fit by priority tier, then how specific the condition is, then id. Selection is now order-independent: a dialogue carries its own eligibility the way a node carries its own showIf, so "most specific wins" is the engine's job, not your sort order. The old ladder was first-match-wins, so which scene played depended on list position, and a general rung sitting above a specific one silently shadowed it forever — the most common authoring bug this format had.

This is a breaking change, but migrating an existing project is one click or one command:

• In the editor: the project opens with a banner in the Validation panel — click Convert ladders to offers.
• Terminal: parlance migrate <project> (add --check to preview first).

The converter preserves exactly which dialogue won in every game state; the INVERSION, SHADOWED, and CONFLICT notes it prints are the few spots worth a glance.

Conditional check modifiers

A skill check can now carry modifiers — conditional bonuses that apply only when their condition holds. An item, a relationship, or a completed quest can raise (or lower) the odds on a check without you duplicating the check or faking a flag. A check with no modifiers behaves exactly as before.

Also in this release

The editor was reworked to make offers legible at a glance:

• Dialogue inspector, rebuilt for offers — see an offer's status without deselecting the node, see where it ranks against the character's other offers, and read a live resolution preview that shows which dialogue would win in the current state.
• Clearer dialogue graph — character portraits now show as avatars on nodes, with an always-on speaker chip so you can see who's talking without opening a node.
• An author-facing walkthrough of dialogue offers in the editor guide.

Migrating a project, or writing your own runtime? The full migration recipes, the detection commands, and the runtime port checklist (offers, check modifiers, and the re-vendored conformance vectors) are in MIGRATIONS.md and the published spec at github.com/Orbitope/parlance-spec.

macOS: a downloaded build is unsigned — clear the quarantine attribute with xattr -cr /Applications/Parlance.app after installing if Gatekeeper blocks it.

This build is unsigned. On first launch macOS may say "Parlance is damaged and can't be opened." — it isn't. That's just Gatekeeper's warning for any unsigned app downloaded from the internet.

Drag Parlance to /Applications, then run once:

xattr -cr /Applications/Parlance.app

After that it opens normally.

Installing on Windows

This build is unsigned, so SmartScreen may show "Windows protected your PC." Click More info → Run anyway.

Something not right?

Parlance sends no telemetry and files no crash reports, so a problem with this build is invisible until someone says so — report a bug or send feedback.

What's new

Parlance 0.13.0 — Git-native collaboration (public beta)

Writers and owners can now draft, review, and publish narrative end-to-end inside the Parlance desktop app — against your studio's own GitHub, GitLab, or Bitbucket repository. Parlance hosts nothing; your repo stays the source of truth.

For writers — contribute with no terminal, no git

• Sign in with GitHub (device flow) or paste a GitLab/Bitbucket token — no server, no pull request.
• Open a project straight from a repository (clone-in-app); large media (Git LFS) is skipped so you don't download gigabytes you don't edit.
• Work in Drafts, not branches: start a draft, "Send for review", "Send changes" — you never see or name a branch.
• Plain language throughout: any git error is shown as a sentence, with the raw detail tucked behind "Details".

For owners — review and publish, git-free

• A "Reviews waiting for you" inbox lists drafts by title and author — no branch names.
• One-click Approve & publish lands a review as a merge commit, computed refs-only, so your open files, checkout, and branch are never touched — whatever branch you're on.
• An overlap that can't merge cleanly is refused in plain language, with every ref left intact.

Also in this release

• Faster on big projects: validation runs incrementally on a worker thread so saves stay responsive; the editor patches its cache per-entity instead of refetching the whole project.
• Command line + CI: @orbitope/parlance-cli (ci-check, route, init, save import) and a reusable GitHub Action gate your game's CI on the same validator the editor runs — see the CI-integration guide.
• Starter templates so a new project isn't an empty folder, plus editor polish (dialogue-canvas edge repair, an Items pass, a smoother review surface).

Public beta — what to know

• Each writer needs a host account and collaborator access to the repo; Parlance enforces nothing your host doesn't.
• GitHub sign-in requires the studio owner to have installed the Parlance GitHub App on the repo; GitLab and Bitbucket need no app.
• Import existing stories from Twine, Ink, or Yarn.

No change to the narrative format or the published contract — a project valid on 0.12.0 is valid on 0.13.0.

This build is unsigned. On first launch macOS may say "Parlance is damaged and can't be opened." — it isn't. That's just Gatekeeper's warning for any unsigned app downloaded from the internet.

Drag Parlance to /Applications, then run once:

xattr -cr /Applications/Parlance.app

After that it opens normally.

Installing on Windows

This build is unsigned, so SmartScreen may show "Windows protected your PC." Click More info → Run anyway.

Something not right?

Parlance sends no telemetry and files no crash reports, so a problem with this build is invisible until someone says so — report a bug or send feedback.

What's new

Durability. The ways the editor could lose your work, closed.

If you write a runtime: nothing here is for you. The contract did not move — schema, conformance vectors and runtime semantics are byte-identical to v0.11.0, and a port pinned there needs no action at all. This is an editor release.

What could go wrong before

Four of these were reachable in ordinary use, not in contrived conditions, and each is now defended by a test AND by a mutant in the battery — if the code changes and the battery still passes, the change did not do what it looks like.

Corruption. Every write now goes through one path, with a temp filename unique per write. It used to be a fixed .tmp, which meant two writers shared one buffer and published a blend of both. The editor host and the MCP server are separate processes on one project, so this needed no bad luck — just both of them running, which is the documented setup.

Lost entities. The array registries — skills, variables, items, portraits — rewrite the whole file to change one entry. Two concurrent saves silently dropped whichever entity lost the race. Read-modify-write is now behind a cross-process lock.

A crash that took the host down. validate() is total: malformed data reports as an issue instead of throwing and killing the process the editor talks to.

A lock race. Absent is no longer read as stale, and stealing a lock verifies identity before taking it.

Two smaller ones: the serializer no longer silently drops a proto key, and a websocket broadcast survives one dead socket instead of failing the whole batch.

The desktop app

Quit on close, session restore — reopen and you are where you left off — and real File, Edit, View and Window menus rather than the default Electron ones.

Underneath

The suite is now 1,649 tests, up from roughly 1,050, including a mutation battery that runs in a worktree and in CI. Two CI failures found during this work are worth naming, because both passed locally first: a depth-5000 condition test that exhausted the runner's heap and silently took 29 other tests down with it, and watcher tests that slept on a clock instead of waiting on an event, which held on macOS and failed on a loaded two-core Linux runner.

This build is unsigned. On first launch macOS may say "Parlance is damaged and can't be opened." — it isn't. That's just Gatekeeper's warning for any unsigned app downloaded from the internet.

Drag Parlance to /Applications, then run once:

xattr -cr /Applications/Parlance.app

After that it opens normally.

Installing on Windows

This build is unsigned, so SmartScreen may show "Windows protected your PC." Click More info → Run anyway.

Something not right?

Parlance sends no telemetry and files no crash reports, so a problem with this build is invisible until someone says so — report a bug or send feedback.

What's new

Conditional narration, and the audits and importers go public.

If you write a runtime: read the first section. It is additive to the schema and NOT safe to ignore.

Conditional narration — DialogueNode.showIf

A node can now carry the same condition type a choice already could. When the condition fails the node is skipped: its text is not shown, its onEnter does NOT fire — a skipped node did not happen — and resolution continues at next.

There was no way to write this before. A line of narration that should appear only in some world states could not be a choice without fabricating a decision the player never made, and a node advances by next to one fixed target. So the line either always appeared or was not written.

The hazard runs the opposite way from the usual "additive" reading, and it is worth stating plainly: a runtime pinned below v0.11.0, handed a project that USES the field, will render conditionally-hidden narration unconditionally. No parse error, no warning — silent wrong output. Do not treat this the way you treated snapshot.visitedDialogueIds in 0.10.0.

MIGRATIONS.md carries the exposure check: a script that tells you whether any project you consume actually uses node-level showIf, which a grep for "showIf" cannot answer because it hits every gated choice. No output means no exposure and you can move the pin on your own schedule.

Implement resolveNode from RUNTIME_CONTRACT.md and route every arrival through it: entry, next, a choice's goto, and a check's onSuccess/onFailure. Six new validator conformance cases and the reworked advance/step_dialogue vectors pin the semantics, including the cycle case.

The audits and the importers are now published, MIT

Two bundles that until now existed only inside the private repo:

audits/ five review-only editorial audits — dialogue ladder ordering, character voice, character presence, quest journal, state reachability. They read a project and report on it. importers/ Yarn and Ink importers, with worked fixtures for each.

Both are in the MIT carve-out and both publish to parlance-spec alongside the schema, because forking one for your own project is the entire point and a licence that withholds that makes them useless.

One rule governs both, and it is enforced rather than promised: nothing in either bundle writes prose. The audits report and never draft. The importers convert and never paraphrase — every emitted string is checked against the source byte for byte, and a paraphrase halts the import rather than being retried, because a second pass cannot un-invent a line. Loss is declared, never silent: a migration with three declared losses is a good outcome honestly reported, and one that came out clean because the awkward lines were reworded is a failure wearing a success.

A prose check that knows your own names

Every check in the editor was structural — references, flow, reachability, interpolation. None read the writing. The defect that accumulates in a long project written by more than one person is not a broken goto; it is a proper noun spelled three ways across two years.

The new check derives your project's proper nouns from data/ — characters, factions, items, locations, skills, codex, endings, quest journal names — and matches them case-sensitively. So "Mistfal" reports as a near-miss naming the canonical form, and "calloway" reports as a name written lowercase. Neither is a finding a general-purpose spell checker can produce, and neither needs a list you maintain: rename a character and the check follows.

Three surfaces: a Prose tab in Reports, underlines inline as you type, and npm run prose -- --check for CI. Words you add yourself live in lore/dictionary.md — plain Markdown, so a writer can edit it without touching JSON. English only for now; the locale seam is in place.

An optional AI pass sorts a first run's unknown words into names, jargon, dialect and real typos, on your own API key. It only classifies words the deterministic check already found: it never edits prose, never writes until you accept, and never adds a typo to the dictionary. Everything else works offline and free.

It is deliberately not part of the contract. Spelling is editorial — it says nothing about whether a project conforms to the format — so the reference validator does not implement it, and it emits its own SPELL code that validation never produces.

Smaller things

• The demo now uses node showIf, with routes covering the gate in both directions.
• A pre-tag gate (tooling/scripts/release_check.py) checks that the version, the docs and the published spec agree before a tag is cut. It found a partial version bump on main on its first run.
• Editor guide gains a section on the prose check.

This build is unsigned. On first launch macOS may say "Parlance is damaged and can't be opened." — it isn't. That's just Gatekeeper's warning for any unsigned app downloaded from the internet.

Drag Parlance to /Applications, then run once:

xattr -cr /Applications/Parlance.app

After that it opens normally.

Installing on Windows

This build is unsigned, so SmartScreen may show "Windows protected your PC." Click More info → Run anyway.

What's new

Performance at scale, and a hardened test suite.

Parlance is built for a 500k–1M-word game, but every project that exists is three orders of magnitude smaller — so its behaviour at target size had been reasoned about and never measured. This release measures it, fixes what the measurements exposed, and closes a set of defects found by auditing the tests themselves rather than the code.

Performance

• Validation no longer blocks a save. It ran synchronously on every write, and because the pass covers the whole project its cost grows with the project. A save now returns as soon as the bytes are on disk; fresh issues arrive over the validation websocket a moment later, and rapid saves coalesce into one pass instead of one each.

  Server-side save latency, measured:

  110k words     223 ms  ->  1 ms
  1.02M words   2085 ms  ->  1 ms
  burst of 5 saves at 1M words   10.6 s  ->  9 ms
  

  At today's project sizes this is invisible — the largest real project saves in about 32 ms either way. It matters because the cost is proportional to project size, and the target is 100x larger.

• Measured across eight project sizes from 2.7k to 2M words. Every core operation is linear: validation holds at 1.31–1.44 microseconds per word across a 46x size range, so there is no quadratic path waiting at scale.

• A fixture generator (tooling/scripts/make_scale_fixture.py) inflates a real project to any target word count while preserving its shape, so these numbers can be reproduced and re-checked as the editor changes.

Fixes

Found by auditing the test suite rather than reported — most were invisible in normal use.

• Live reload could stop entirely on a project with no lore/ directory, so validation-on-save quietly stopped with no error shown.
• A save the server rejected could be dropped without surfacing anything, so later edits were silently discarded while the canvas still showed them.
• A reviewer's suggested rewrite could be lost when review threads merged.

Plus smaller fixes to project opening, field editing, and the review panel.

Editor

• Import a save written by the game as a snapshot, keeping its visited set, so a bug a playtester hit can be opened directly instead of reproduced by hand.
• The location map is readable: proper edge routing and arrowheads instead of crossed-over S-curves on every return exit.
• Reviewers can open a dialogue via Play with the diff carried along, on a branch they have not checked out.
• The review branch and scene pickers are searchable, and matching handles terms typed out of order rather than one contiguous string.
• Reopening from the Dock on macOS, and a second launch opening the project it was given.

macOS and Windows builds are unsigned in this release; installation notes below.

This build is unsigned. On first launch macOS may say "Parlance is damaged and can't be opened." — it isn't. That's just Gatekeeper's warning for any unsigned app downloaded from the internet.

Drag Parlance to /Applications, then run once:

xattr -cr /Applications/Parlance.app

After that it opens normally.

Installing on Windows

This build is unsigned, so SmartScreen may show "Windows protected your PC." Click More info → Run anyway.

What's new

The first public release of Parlance.

• A visual editor for the whole narrative layer: dialogue and quest canvases, location maps, playtesting with seeded dice, and validation on every save
• Share builds export any scene as a single self-contained HTML file that plays in a browser, now carrying state across scene boundaries
• The format spec, runtime contract, and conformance vectors are published separately under MIT at github.com/Orbitope/parlance-spec
• Documentation at orbitope.com/parlance-releases/

macOS and Windows builds are unsigned in this release; installation notes below.