Dict

The Dict app is a dictionary from English, German, French, Spanish, Italian or Latin into Chinese, Japanese or Korean. A word it has not met is written by a model while you watch, and then kept, so the next time its entry opens at once.

What Dict is for

For you:

• A whole entry for a word or a phrase. Pronunciation, forms, senses, examples, etymology, related words and the word in literature, explained in Chinese, Japanese or Korean.
• It reads past your typing. An inflected form opens the headword's entry, and an obvious typo is read as the word it stands for.
• A dictionary that grows as you use it. Every entry it writes is kept on this node, and a word looked up before opens at once.
• No waiting at the window. A new entry takes a minute or two, in a tab of its own. Read on, look up more words or close the window: the entry is still written and kept.
• On your phone. Dict also opens on its own, outside the desktop, and an iPhone can keep it on its home screen.

For a script or a coding agent that talks to exe over HTTP:

• The same dictionary as JSON. One call reads a kept entry, and another has a missing one written and streams the work as it goes. Look words up over HTTP, further down, has the calls.

A first lookup

1. Pick the two languages in the pop-ups at the top. They begin at English → Chinese.
2. Type a word or a phrase and press Return, or click Look Up. The circled × at the end of the field empties it.
3. Read the entry. A word the dictionary keeps opens at once. One it does not have yet is written while you watch, which takes a minute or two.
4. Go on from there. A related word in the entry looks itself up when clicked.

A lookup is one line of up to 80 characters. Capitals and extra spaces do not matter: Serendipity and serendipity are one entry.

What an entry holds

Under the headword an entry gives, from the top:

A Chinese entry is written in Simplified Chinese.

Inflected forms and typos

Look up an inflected form (ran, ging, amāvī) and you get the headword's entry, with a line saying which form you typed.

An obvious typo (recieve, Weltschmertz) is read as the word it stands for:

• The field takes the word, and the entry opens under a line saying what you typed.
• Look up … as typed, on that line, is for the rare time the check is wrong.
• A typo never gets a page of its own. Dict remembers it, so the next time it goes straight to the word.

When it is not a word

A lookup that is not a word of the source language comes back with suggestions, and nothing is kept. A suggestion looks itself up when clicked.

Watch an entry being written

A word the dictionary does not have yet takes a few seconds for its spelling and a minute or two for the entry. You can watch the work:

• The steps. Under the word, a line for each step as it comes, with the time it began: the session starting, the spelling checked, each pass of reasoning, the entry beginning. A pass of reasoning shows Codex's one-line summary of it once there is one, and how long it took at its end.
• The entry. From then on the entry itself, drawn as it is written. The page follows the writing down while you stay at its foot.
• The status line. It counts the time and the characters written, and at the end the tokens the session spent.

The session belongs to the daemon, not the window. Close the window and the entry is still written and kept. A window that asks for the word meanwhile — this one reopened, or another desk — joins the session, every step so far included, rather than starting another.

Where entries come from

Entries are kept in the node's own dictionary, ~/.exe/dict.db (SQLite), so a word looked up before opens at once.

A word the dictionary does not have yet is written by Codex: an ephemeral session of the Codex CLI on this host, on gpt-6-astra at extra-high reasoning.

• The session is a thread of codex app-server that is never saved and never joins Codex's resume list.
• It runs read-only in an empty folder, with its shell tools, apps, plugins and hooks off.
• First it checks the spelling, which takes a few seconds. A typo of a word the dictionary already keeps opens that word's entry then and there, and a lookup that is no word at all stops with suggestions.
• Then it writes the entry, which takes a minute or two.

A host without the Codex CLI still opens every entry it keeps, and answers the rest with No Usable LLM Backend. Codex must be signed in (codex login) for the rest to be written.

A lookup that goes wrong says why on its page, with Try Again under the reason. A session that has not answered after ten minutes is stopped.

Tabs

Each lookup has a tab, along the top of the page. Where a lookup opens depends on whether its entry has to be written:

• A word the dictionary keeps opens at once in the tab you are on, in place of what was there.
• A word that has to be written opens in a tab of its own beside the entry you were reading, which stays as it was for the minute or two the writing takes. Only a tab with no entry on it (a new one, or one whose lookup came to nothing) is written in.
• A lookup made while the tab you are on is still writing opens beside it too, and the first keeps writing.
• A word that a tab is already writing takes you to that tab.

A tab you are not looking at can wear a mark:

There is no limit on how many words are written at once. Each gets its session straight away, and the window follows all of them over a single connection, so a pile of writing tabs never ties up the browser. Tabs narrow as they crowd, and past that the bar scrolls sideways (a wheel, a trackpad or a finger).

The × on a tab closes it; a lone tab has none. Closing a tab that is writing does not stop its session: the entry is still written and kept.

The window remembers its tabs, the open one and its languages in this browser, and a reload brings back up to twelve tabs. A tab that was writing rejoins its session, and one whose session was lost to a daemon restart starts it again.

Change the languages

Change a pop-up and Dict shows the word's entry for the new pair, if the dictionary has one. If it has none, the page says so and waits for Look Up, so a stray change of pop-up never starts a session.

Changing the languages while the open tab writes opens the word in the new pair in a new tab.

Dict on a phone

Dict also works on its own, outside the desktop:

1. On the phone, open /apps/dict/ on your exe's address. Over Tailscale Serve that is https://<host>.ts.net/apps/dict/.
2. On an iPhone, choose Share → Add to Home Screen.

From the home screen it opens full screen with its own icon, the red dictionary on the desk's lavender. There it:

• keeps clear of the notch, the home indicator and the blur iOS lays under the status bar of a home-screen app;
• fits itself above the keyboard, so the field never slides off the top;
• uses the API token the desktop saved in that browser, if your exe has one.

In a narrow window, a phone's among them, the two languages take a row of their own above the word.

Look words up over HTTP

Two calls answer a lookup. Both name the languages by their codes and the word as q: from is en, de, fr, es, it or la, and to is zh, ja or ko. Like every /v1/ call they take the daemon's API token where one is set.

Read a kept entry. GET /v1/dict?from=en&to=zh&q=word answers a kept entry, and 404 when there is none. For a known typo it answers its word's entry, with corrected saying what was typed; exact=1 reads the text as typed.

$ curl -s '127.0.0.1:7777/v1/dict?from=en&to=zh&q=serendipity'

The answer is one JSON object: from, to, q, the entry itself, the model and effort that wrote it, and created, the time it was written.

Look up, and write if need be. POST /v1/dict with {"from", "to", "q"} answers newline-delimited JSON. A kept entry comes at once, as one {"entry": …} line. Otherwise a session writes it, and these lines follow it as it works:

A step's kind is session, spell, spelled (with its verdict on the typed text), think, summary, thought, answer, usage or retry.

"exact": true in the body skips the spelling check. A word that has to be written on a host without the Codex CLI answers 503.

A lookup that joins a session reads every line from the start, and joins only a session it can trust. A plain lookup never shares an exact one's, whose text may be a typo, and an exact lookup never shares a spelling check still out. Each starts its own.

How the window follows its sessions

The window itself does not hold a request per lookup. It uses two more calls:

• POST /v1/dict/start, with the same body, answers at once: {"entry": …}, or the session as {"flight": id, "key", "q", "model", "effort", "wait"}.
• GET /v1/dict/stream is one connection to every session the daemon is running, and to those finished in the last two minutes.

On the stream each session is announced as {"flight": id, "began": {…}}. Its lines follow as POST /v1/dict sends them, with "flight" added, and then its last line. {"ready": true} ends the first round, and {"ping": …} keeps a quiet stream open.