turnstile

Turnstile has two modes, like a text editor with a command mode.

• You're typing in a message → insert mode
• Press Esc → block mode, where single keys act on whole messages

In block mode: j and k move between messages, 1–5
set the role, x disables one, and Enter drops you back into
the text.

The chords work everywhere: Ctrl+Enter for a new message,
Alt+↑/↓ to move one, Ctrl+D
to duplicate. Forgot one? Ctrl+K opens a searchable list of
every command.

1. Open the Format tab and choose the format you're importing from.
2. Click Import into this conversation and pick your file.
3. Switch the target format to the one you want.
4. Click Export — or Copy to clipboard if it's going straight into code.

The preview at the bottom of the tab always shows exactly what will be written,
so you can check before you commit.

Turnstile handles the awkward differences for you: Anthropic keeps the system
prompt in a separate top-level field, OpenAI puts tool calls in tool_calls
with JSON-encoded arguments, and Anthropic tucks tool results inside a user
turn. You just switch the dropdown.

Write {{like_this}} anywhere in a message. The Vars tab picks it up
automatically and gives you a box to fill in.

• Values are substituted when you export or copy — the editor always shows the
  template, so you never lose it.
• Tick preview substituted content in the Vars tab to see the filled-in version.
• Need literal braces? {{{{not_a_variable}}}} exports as {{not_a_variable}}.
• Forgot to fill one in? It stays as-is in the output and you get a warning.

Open the ⋮ menu on the last message you want to keep and choose
Branch from here.

You get a new conversation containing everything up to that point, and the
library shows ⑂ from … under it so you can see where it came from. The
original is untouched — rewrite the ending in the branch and compare.

Toggle disabled in the ⋮ menu, or x in block mode.

The message stays in the document, dimmed and struck through, but it's left out
of every export and every token count. It's the right tool for "does this
instruction actually matter?"

For a note to yourself that should never leave the editor, use Add note —
notes are attached to a message and are never exported in any format.

Set the target format to JSONL and export. Each export writes your
conversation as one line, in the OpenAI shape.

Importing a JSONL file opens the first conversation and tells you how many
others were in the file. To bring in a whole set, use Import vault in the
library instead.

Press Ctrl+R. The message cards are replaced by the whole
conversation as text, in whatever format you're targeting. Blocks are
color-coded by role so you can tell them apart while editing.

Your edits are read back into the message cards about a second after you stop
typing. A few things worth knowing:

• Your text stays as you typed it. The editor doesn't reformat under you.
• Broken text can't break your conversation. If it doesn't parse, the error
  appears above the editor and the cards stay as they were until you fix it.
• Notes and collapsed state survive for messages you didn't change.
• Text that isn't inside a <|im_start|> … <|im_end|> pair becomes its own
  untagged block — a neutral, dashed card. Nothing gets silently merged into
  the message above it. Give it a role from the dropdown to make it a normal
  message.

While editing raw ChatML, hold Alt:

The cursor lands inside, ready to type.

Your own tags: click block shortcuts in the raw view header. Give a tag a
name and a letter — say im_sep on Alt+C — and pick what
it inserts:

• token — the bare <|im_sep|>, dropped inline wherever your cursor is
• block — a whole <|im_start|>im_sep … <|im_end|> pair, like the built-ins

Already added it and want the other behaviour? Click the little token /
block label on the tag to flip it. Type the name with or without the <|
|>; both work. Your tags are remembered across reloads.

Export vault at the bottom of the library writes every conversation into a
single JSON file. Import vault reads it back on the other machine.

Since there's no server, this is the backup — worth doing before you clear
browser data. A damaged file still imports whatever conversations are readable
and tells you what it skipped.

Open the Issues tab — it lists what's wrong for the format you're targeting,
and clicking a row jumps to the message and flashes it.

Errors block the one-click export because the output would be wrong or would
fail at the API. Common ones:

Warnings never block anything — they're advice.

And if you know better than the checker, Export anyway is always there.

This is off by default, and there's no network code in the app at all until you
turn it on.

cp .env.example .env.local     # set VITE_ENABLE_INFERENCE=true
npm run dev

A Run panel appears. Choose OpenAI or Anthropic, paste your own API key, and
the reply is appended as a new assistant message.

Your key is stored on your machine and the request goes straight from your
browser to the provider — Turnstile has no server to send it through. What gets
sent is exactly what the Format tab preview shows.

Turnstile shows an error panel rather than a blank page if something goes wrong
while rendering, so a truly blank page usually means the dev server isn't
running or the page didn't load. Check the terminal running npm run dev, then
reload.

If you do get the error panel, the message on it is the real cause — reloading
clears most of them, and your conversations are safe either way.

They're stored per-browser and per-site. They won't appear in a different
browser, a different profile, or private-browsing windows, and clearing site
data removes them.

If the library is genuinely empty, click New conversation to start again, and
use Export vault from then on so there's always a copy outside the browser.

There's an error for the format you picked. Open the Issues tab to see which
message, click it to jump there, or use Export anyway if you meant it.

Built from chatml-editor-prd.md; all six phases of
its build plan are implemented. React 18 + TypeScript (strict) + Vite, Zustand
for state, Dexie for storage, CodeMirror for the raw view only.

Where things live

Conventions

• TypeScript strict; no any, no non-null assertions.
• Adapters never import the store or React, and never see disabled messages or variables — the export pipeline handles both before serializing.
• Role colors are Tailwind theme tokens (bg-role-user, …) in src/index.css, never inline hex.
• No dependencies beyond the ones the PRD approves.

Decisions worth knowing

• Message.rawRole and Message.untagged extend the PRD's model so unknown roles and text outside blocks survive a round-trip instead of being coerced or dropped.
• ChatML has no tool-call syntax, so tool blocks ride in fenced JSON (```tool_use) — plain content that any ChatML consumer accepts.
• Message bodies are textareas, not editors: a CodeMirror instance per message gets slow past ~30 messages and steals keybindings.
• Alt shortcuts in the raw view are registered above CodeMirror's own Alt-u/Alt-l/Alt-A case commands, which would otherwise swallow them.
• Token counting allows ChatML special tokens explicitly — gpt-tokenizer throws on them by default, which is fatal in an editor whose content is full of them.
• The bundle is ~4 MB (1.8 MB gzipped), nearly all tokenizer data, in exchange for exact counts from the first paint.
• Vitest runs on the threads pool; the default forks pool can't start workers on this Windows setup.