From first launch to a reusable terminal workflow

1. Get access. Choose a paid plan on the pricing page, then sign in with Google, GitHub, or an email magic link before checkout. If the developer sent you a private evaluation or complimentary-access link, open it before signing in and accept it with the intended verified account.
2. Open your account. Choose the download that matches your operating system and processor. If an administrator granted access while the page was open, select Refresh status first. Copy the license key only if you need the headless/fallback activation path, and keep it private.
3. Run the recommended installer. Use the macOS .pkg, Windows Quill Terminal Setup, Ubuntu/Debian .deb, or Fedora/RHEL .rpm. Portable archives remain under Advanced on the download page.
4. Open a new terminal and verify the binary.

   quill --version
   quill

5. Activate this computer. Press B on the activation screen, sign in with the same Google, GitHub, or email account used on the website, and approve the computer shown. A headless machine can instead paste the license key and press Enter. Either path produces the same signed, device-bound lease in the operating system's credential vault.

Browser approval is short-lived and explicit. If the tab is closed, press B again to reopen the same request while it is valid; start a new request after it expires. Quill never receives the website cookie, OAuth token, or identity-provider password. Failed authentication, cancellation, inactive access, a revoked device, or a full device limit leaves the app locked.

A requested file, one-run target, or incoming pipe waits behind this gate and resumes only after approval. Quill does not open the document workspace, provider process, or API key before entitlement is established.

On a headless Linux machine, install a downloaded package with sudo apt install ./quill-<version>-<target>.deb or sudo dnf install ./quill-<version>-<target>.rpm. Native installers place quill on PATH. Windows Setup also adds a Start Menu shortcut and can create a desktop shortcut.

brew install arafayrs95/tap/quill

curl -fsSL https://quillterminal.app/install.sh | sh

irm https://quillterminal.app/install.ps1 | iex

The command-line installers detect the platform and architecture, verify the release checksum from Quill Terminal's independently validated release manifest, and refuse a mismatched download. Homebrew verifies its pinned archive checksum too. These are alternative installation methods—choose one; you do not run them after the native installer. The Download page always shows the current macOS and Windows signing state and any required one-time Gatekeeper or SmartScreen approval.

shasum -a 256 <downloaded-file> # macOS
sha256sum <downloaded-file> # Linux

Get-FileHash .\<downloaded-file> -Algorithm SHA256

Quill Terminal supports terminal profiles, not a fixed logo list. Its release gates cover POSIX PTYs, the enhanced keyboard protocol used by modern terminals, and Windows Console/ConPTY. The clients below are representative of those contracts; they are not a claim that every historical release of every terminal emulator has been run by hand.

The on-screen ◉ Send button is the universal send fallback. On macOS and Linux, use Alt+Enter when a terminal cannot distinguish Ctrl+Enter. On Windows, useCtrl+Enter or the button; many Windows terminals reserve Alt+Enter for full screen. F6 and Shift+F6 remain portable pane-navigation fallbacks everywhere.

Minimum platforms are macOS 12 on arm64 or x86_64; Linux x86_64 or arm64 with glibc 2.34 or newer; Windows x64 build 17763 (Windows 10 1809) or newer; and Windows ARM64 build 22000 (Windows 11) or newer. Windows 10 on ARM and all 32-bit builds are unsupported. Windows Terminal is recommended for the best Windows experience.

1. Write Markdown in COMPOSE. The PREVIEW pane renders its structure live.
2. Open F2 → Target, or use Ctrl+R to cycle targets.
3. For a direct API, add and verify its key under F2 → Setup → Providers. For Claude Code or Codex, install and authenticate that CLI outside Quill first, then launch it with F4. Shell needs no provider account.
4. Send with Ctrl+Enter, the platform fallback described above, or the ◉ Send button.
5. API replies stream into PROVIDER. CLI and Shell targets receive the prompt inside their real terminal session.

Preview follows CommonMark rather than duplicating Compose character for character. One source newline inside a paragraph is a soft break and renders as a space. Use a blank line for a new paragraph, or two trailing spaces, a trailing backslash, or <br> for a visible hard break. Valid pipe tables render as aligned tables; put spacing-sensitive ASCII tables, logs, and diagrams in fenced code blocks so every space and newline remains literal.

Quill accepts a file, a one-run target, or both when it starts:

quill                                  # open the workspace
quill login                            # browser sign-in / verified Account status
quill prompt.md                        # open a file on startup
quill --target claude-cli              # open with a one-run target
quill prompt.md -t codex-cli           # open a file and target together
git diff | quill                       # insert at cursor, or open a new unsaved draft
git diff | quill --new-instance -t shell
git diff | quill --append
quill --stdout compose > draft.md
quill --help                           # full CLI, Legend, setup, paths, and diagnostics reference
quill --version

The optional positional argument is always an existing Markdown or plain-text file path; quote it when it contains spaces (for example, quill "release notes.md"). The dedicated quill login command starts browser approval when the app is locked, or opens the verified Account panel when this installation is already active; it deliberately does not accept a file, target, pipe, or stdout mode. Missing files and misspelled targets fail before the workspace opens. Use -t or --target with anthropic-api (alias claude-api), openai-api (alias codex-api), claude-cli, codex-cli, or shell. CLI/Shell targets use the saved ask-before-launch policy; missing installs, logins, or API keys preserve the draft and never reroute it. A targeted pipe requires --new-instance, so another open editor is never retargeted. Choose again later with F2 → Target or Ctrl+R, or save a future startup target under Setup → User Config.

Run quill --help outside the TUI for the same fully expanded Legend plus every option and target alias, activation and provider-key setup, the resolved local config, template, history, and recovery paths, installer links, and the privacy contract for diagnostics. Printing help is read-only and does not create Quill's data directory, read the credential vault, or start licensing or provider work.

Quill does not model-rewrite your Markdown or instruction text. Before handoff, it resolves Quill-managed chips: collapsed pastes become their complete text, CLI and Shell image chips become local file paths, and API images travel separately while the prompt keeps a neutral marker so your local directory is not disclosed. Guarded terminal handoff also rejects or neutralizes unsafe control content.

CLI targets use the CLI's existing authentication and do not need Quill's provider API-key field. Managed Claude Code and Codex sessions are resumable. A program launched manually inside Shell belongs to that ephemeral Shell tab and is not added to Quill's resume registry.

A managed CLI remains fully interactive: focus PROVIDER and type, run slash commands, change the CLI's own model or reasoning mode, interrupt work, and scroll or copy its output exactly as you would in a normal terminal. Quill's model and tuning controls apply only to direct Anthropic and OpenAI API targets. Sending from Compose hands the reviewed prompt to the same live CLI session; it does not disable direct terminal input.

Direct API targets use the provider's metered API billing, which is separate from a Claude or ChatGPT subscription. Create a key on the provider's official platform:

1. Anthropic: platform.claude.com/settings/keys.
2. OpenAI: platform.openai.com/api-keys.
3. In Quill, open F2 → Setup → Providers, paste the key, and choose Verify. Quill checks the key with the provider before saving it and discovers the models that account can use.

Verified keys live in macOS Keychain, Windows Credential Manager, or the Linux Secret Service—not in config.toml, logs, prompts, or history. Managed CLI and Shell processes launch with provider API-key variables removed. When Quill performs an actual provider-key secure-store read, it makes a best-effort, secret-free audit entry in keychain.log. Cached keys do not trigger another vault read. Deleting a stored key in Setup removes the credential-vault entry.

Selecting a direct API target, including restoring it at startup, does not read or verify its credential. The first Send or an explicit Verify action reads the saved key when it is actually needed. This keeps target navigation credential-free.

For direct APIs, Setup → Providers also selects the model and the tuning that model actually supports. Quill offers Anthropic effort or thinking controls where available, OpenAI reasoning effort for reasoning families, and temperature for compatible non-reasoning models. Model discovery refreshes the choices for the verified account; unsupported combinations are not sent.

export ANTHROPIC_API_KEY=sk-ant-...
# or
export OPENAI_API_KEY=sk-...

There is no required template. Use only the sections the task needs; the point is to make different kinds of information easy to inspect before they guide an agent run.

# Outcome

## Context

## Requirements
- One checkable item per line

## Constraints
- What must not change

## Inputs
```
code, logs, or source text
```

## Done when
- The result you can verify

Structure is most useful once a prompt mixes natural language, code, logs, assumptions, constraints, or several steps. It is not ceremony for a one-line question; it is a way to expose ambiguity while you can still fix it.

Menu → Target picks directly; Ctrl+R cycles. With a live CLI or Shell pane, either route asks before replacing the terminal session so the visible pane and active send target cannot diverge.

• Managed CLI → another target: Quill asks first. The session ends like closing a terminal tab and remains resumable from Provider CLI → Resume session, including after restarting Quill.
• Shell → another target: Quill asks first and then closes the ephemeral Shell tab. Manually launched nested tools are not resumable through Quill.
• API → API: an idle switch needs no confirmation. While an API reply is active, finish it or press Esc to cancel before switching to any target. The transcript adds a provider seam so interleaved comparisons stay readable.

If a CLI or Shell process exits, Quill keeps its final output visible and preserves any unsent Compose draft. Press F4 to restart the selected pane or F5 to stop a live CLI or Shell.

Shell runs your configured operating-system shell in PROVIDER and hands it the resolved compose text without model-assisted rewriting—no model is involved in that route. Use it to move around a repository, run builds or git, execute a script you composed, or start any installed tool. If you run claude or codex there, that tool uses its own existing login. Quill recognizes nested Claude/Codex so Compose exposes the matching slash commands and Codex skills, and nested Codex gets the same visible input-row surface as the direct Codex target. When the nested program exits, Quill restores the live shell view. The Shell tab remains ephemeral and is not added to managed resumable sessions.

Quill already follows the external-editor contract: opening a file keeps the process in the foreground, Ctrl+S writes back to that file, and Ctrl+Q returns control to the caller. Set both standard editor variables so Claude Code and other terminal tools can find it.

export VISUAL=quill
export EDITOR=quill

$env:VISUAL = "quill"
$env:EDITOR = "quill"

Add the Unix exports to your shell profile to keep them. In Windows PowerShell, persist them for future terminals with:

[Environment]::SetEnvironmentVariable("VISUAL", "quill", "User")
[Environment]::SetEnvironmentVariable("EDITOR", "quill", "User")

1. Open Claude Code normally with claude.
2. Press Ctrl+G, or press Ctrl+X then Ctrl+E. Claude opens its draft file in Quill.
3. Compose and preview the prompt, save with Ctrl+S, then quit Quill with Ctrl+Q.
4. Claude Code restores its prompt input with the saved text. Review it there and send when ready.

Merely opening the external draft does not send it through Quill or add it to Quill's sent-prompt history. The file remains the source of truth for this workflow. See Anthropic's interactive-mode reference for the current Claude Code shortcuts.

When standard input is redirected, Quill reads the UTF-8 text to completion. If an editor is already running, the text is inserted at its Compose cursor through the normal paste-chip, undo, and autosave path. If no editor is running, Quill reconnects the keyboard to that terminal and opens a local unsaved, crash-recoverable draft. Nothing is sent to a provider automatically. Whether it reaches a live editor or opens that new draft, the complete pipe is one Undo/Redo operation.

git diff | quill
npm test 2>&1 | quill
cat app.log | quill --append

git diff | quill
Get-Content .\build.log | quill --append
npm test 2>&1 | quill

git diff | quill
type build.log | quill --replace
quill --new-instance < build.log

The default inserts at the current Compose cursor. Add --append to move to the true document end and add a newline only when neither side already supplies one. Add --replace to replace the complete active Compose document. Both remain local, enforce the normal document limits, and never submit the result.

With several open instances, Quill prefers the one in the sender's working directory; otherwise the most recently interacted-with live editor receives the text. Use command | quill --new-instance to bypass every running editor and always open a separate draft. An explicit file argument wins over redirected input.

Quill can also expose a read-only pane to another command. Use quill --stdout compose, quill --stdout preview, or quill --stdout provider, then redirect the result or pipe it onward. Compose expands collapsed text while retaining image chips; Preview emits its current rendered plain text, including visible collapsed-paste chips; Provider emits the full retained native CLI or shell transcript with terminal padding and transient overlay chrome removed. Quill adds no trailing newline. Provider output is rejected when no native CLI or shell is running; API transcripts are not substituted. Read-only snapshots use the same matching-working-directory, then most-recently-used fallback rule as incoming pipes.

A complete collapsed text chip resolves to its full hidden content when copied, when the whole Compose pane is copied, or when Compose is written to stdout. Preview stdout deliberately mirrors what is visibly rendered, so an unexpanded chip remains its one-line label there; expand it first when you want rendered Preview text instead.

The producing command must finish before delivery; do not use an endless stream such as tail -f. Piped input is local-only and uses the same safety limits as an opened prompt file: UTF-8, at most 16 MiB and 100,000 lines. Endpoint records are private to the operating-system user, each live instance uses a random authenticated secret, and prompt bytes are sent only after the receiver proves it knows that secret.

Delivery to a running editor does not need a TTY. Starting a new interactive Quill does need a controlling terminal so the application can restore keyboard input after consuming the pipe. If a menu, confirmation, or input dialog covers Compose, the live editor rejects the handoff and the sending command reports the reason—nothing is inserted later or routed into that field.

Starting a CLI or Shell session with F4opens a two-step launch bar: first the working directory, then extra arguments. ~ expands to your home directory. Press Enter twice to keep the defaults or Esc to cancel. Set per-CLI defaults under Setup → Providers; Shell defaults and the launch-bar toggle live under Setup → User configuration. Press F5 to stop the live pane from any workspace focus.

The arguments belong to the provider CLI itself. Run claude --help or codex --help, or use the Claude Code CLI reference and Codex CLI reference.

With a Claude Code or Codex target active—or with either provider launched manually inside Quill's Shell pane—type / at a word boundary to complete that CLI's available commands and prompts. With Codex active, type $ for discovered skills. The popup reads the real built-in, user, and project entries and narrows as you type. Enter or Tab completes; Esc dismisses. Valid mentions highlight in Preview, but Quill sends the underlying text unchanged and lets the CLI decide what the invocation means.

Ctrl+S saves. Open and first Save always show an editable path bar. When the desktop supports it, Quill also opens the native file picker. On headless Linux, SSH, or systems without zenity or kdialog, type the path and press Enter. Later saves write to the same file. Ctrl+O opens Markdown or text the same way. Unsaved work is guarded, and drafts recover across restarts.

Saved prompts are ordinary files, including agent instructions such as AGENTS.md, CLAUDE.md, and SKILL.md. When a document contains image chips, Quill copies their pixels to a sibling asset folder and writes relative Markdown image links so the document stays portable with its assets.

Ctrl+T opens built-in and custom templates. Custom templates are Markdown files under ~/.quill/templates, so they can be inspected, versioned, copied, and shared. Sent prompts are recorded in searchable local History by default. Menu → History can reload, export, or securely clear them; recording and retention are configurable locally.

Select ↑ Last in the top bar or press Ctrl+↑. With Compose empty, Quill loads the last sent prompt immediately. With an existing draft, Quill asks whether to Replace draft, Keep both, or cancel. Keep both places the recalled prompt first and preserves the current draft below a blank line.

Recall reads the local prompt history and never contacts a provider. It is unavailable when history recording is disabled or no sent prompt exists; use Menu → History when you need an older entry, search, export, or secure clear.

Compose supports mouse and keyboard selection, select all, cut, copy, paste, undo, redo, find and find-next, indentation, and normal cursor movement. Soft wrapping keeps a word together when it fits on the next displayed row, while an over-wide URL or token still wraps safely at the pane edge. Up and Down move one displayed row, not an entire logical bullet or numbered item. Preview and Provider support selection and copy, including terminal scrollback. A copy bubble appears beside mouse selections.

Paste as-is, as plain text to remove formatting and ANSI codes, or as Markdown-smart text to normalize common rendered bullets and checkboxes. Long pastes collapse into an expandable chip so the instructions around them remain easy to read. Each clipboard paste and incoming pipe is one Undo/Redo operation. Copy a complete collapsed chip—or copy the whole Compose pane—and Quill places the chip's full hidden text on the clipboard rather than its label.

Inside Quill panes, use Quill's Ctrl shortcuts (⌃ in the macOS in-app legend) for pane-aware Select All, Copy, Cut, and Paste. Native shortcuts owned by the terminal application—such as ⌘A/⌘C on macOS, Ctrl+Shift+A in Windows Terminal, or Ctrl+Shift+C in common Linux terminals—operate on the terminal viewport, not a logical Quill pane. On macOS, ⌘V is host paste; prefer ⌃A/⌃C/⌃V for Quill's pane-aware actions. Quill leaves those global terminal preferences untouched. If a host such as Windows Terminal reserves Ctrl+C or Ctrl+V, use F2 → Edit for the pane-aware action. If a host-native Paste is forwarded as terminal text, a clipboard-matching long or multiline burst still follows Quill's paste-chip, provider-safety, and single Undo/Redo path.

The status bar keeps the cursor line, total lines, words, characters, selected characters, and a rough token estimate visible. Word, character, and token totals use the resolved prompt, so a collapsed paste is counted at its full size even while Compose shows one chip. The token figure is an estimate, not a provider tokenizer or billing total.

Paste a long log, stack trace, query, or source file and Quill collapses it into a chip. Click the chip to expand it; once expanded, it becomes ordinary editor text. Extremely large pastes remain collapsed for responsiveness, but their complete content is still restored for Save and Send.

Clipboard images and screenshots become recoverable image chips. Anthropic and OpenAI API targets receive structured image bytes: up to 20 PNG attachments, 5 MiB per image, and 20 MiB combined. CLI and Shell targets receive the images' local paths in the handed-off prompt so their own tools can open them. Quill blocks the send when a referenced attachment is missing, invalid, or outside the target's limits instead of silently dropping context.

Menu → Layout offers six side-by-side and stacked combinations of Compose, Preview, and Provider. Drag dividers to resize, use the 50/50/50 action to rebalance, and toggle the Markdown legend with Ctrl+L. In layout labels, | means side by side and — means stacked. Dark and light themes use the same palettes as this website. In Legend, Up/Down chooses a section, Left/Right collapses or expands it, Enter or Space toggles it, Page Up/Page Down scrolls, and Esc returns to Compose. Collapse all and Expand all are available by keyboard or mouse.

In Compose, Tab nests a Markdown list item at its parent's actual content column, or indents ordinary text; Shift+Tab outdents. On an empty continued list item, type a different marker such as 1. or - to switch between numbered and bulleted children. Use Ctrl+Tab and Ctrl+Shift+Tab to move forward and backward through visible panes in terminals that report those chords. F6 and Shift+F6 are the portable fallbacks. From read-only Preview or Legend, Tab and Shift+Tab also cycle panes. Legend keeps its own section navigation: Up/Down moves between headers and controls, Left/Right closes or opens a section, Enter or Space toggles it, and Esc returns directly to Compose.

A live CLI keeps ordinary keys—including Tab, arrows, Enter, and Ctrl+C—because they belong to the child terminal. Use Ctrl+Tab or F6 to leave PROVIDER. This lets you type directly into Claude Code, Codex, or Shell without sacrificing a keyboard path back to Compose.

Press F7 to focus the complete top action bar without using a mouse. Left/Right or Tab/Shift+Tab moves through Quill Terminal, Menu, Send, Last, Legend, and Layout; Enter or Down activates the focused item. Inside the Quill information and App menus, arrows or Tab/Shift+Tab move through rows; Up or Shift+Tab from the first row returns to its top-bar button so you can continue across the bar. Esc closes the menu, and Esc or Up from the focused top bar returns to the workspace. F2 remains the direct App Menu shortcut.

In F1 and F2 menus, Up/Down or Tab/Shift+Tab chooses an item, Right or Enter opens a submenu or section, Left returns one level, Enter activates, and Esc closes or returns. Help and Why use Right/Enter to move from the section list into the document; then arrows, Page Up/Page Down, and the mouse wheel scroll while Left or Esc returns to the section list. Feedback uses Tab/Shift+Tab through Name, Email, and Message and back to the section list.

History and Resume keep the selected row visible while the terminal resizes: use Up/Down to choose, Page Up/Page Down to move by a page, Home/End for first or last, Enter to load, and Esc to cancel. Templates use Up/Down and Home/End in the list, Right or Tab to enter Preview, arrows or Page Up/Page Down to scroll it, and Left or Shift+Tab to return. Settings similarly keeps the focused control visible on compact terminals: enter from the section list with Tab or Right, use Left/Right on the provider-tab strip, Tab into its fields, and continue with Tab/Shift+Tab through every control and back out to the sections.

Quill displays native control-key glyphs on macOS. If a POSIX terminal reports Ctrl+Enter as plain Enter, use Alt+Enter or the Send button. On Windows, avoid Alt+Enter and use Ctrl+Enter or the button. When a live provider CLI has focus, use Ctrl+Tab or the portable F6 fallback to return to Compose. Ctrl+C without a provider selection remains the CLI interrupt; F2 → Edit → Copy copies the whole transcript by keyboard.

The Ctrl rows above are Quill's pane-aware controls. A terminal emulator can reserve its own native selection/copy shortcuts before a TUI receives input; those remain viewport operations. Terminal- native paste content is normalized into Quill's paste flow when the host forwards it.

Public access is purchase-only, with monthly and yearly subscriptions through Paddle. The developer may send selected reviewers, testers, friends, or partners a secure one-time private evaluation link. It can be locked to a specific email; if no email is specified, it binds to the first verified SSO account that accepts it. The invitation shows exactly how long remains to claim it, and the 14-day evaluation clock starts only on acceptance.

Moving between pages, refreshing, or completing email-link/OAuth sign-in does not lose a valid invitation. Once accepted, the entitlement, license, devices, and evaluation end stay attached to the verified account. The original link is no longer needed, and its later expiry does not shorten the evaluation. If the link expires before acceptance, it creates no access; request a replacement or purchase normally.

One active license covers up to 3 of your own computers across the supported operating systems. The account page lists activated devices and lets you revoke an old computer before activating its replacement. Quill reports the OS, architecture, and installed app version for licensing and update visibility; prompt content is never included.

Inside the app, open the menu and choose Account to see the verified email, access type, subscription cycle, start/end dates, and renewal state returned by the license service. The display refreshes at startup and at least daily while Quill remains open. Access is checked independently and more frequently against the signed lease and its exact deadline.

The Account panel also provides a guarded local sign-out. Quill asks you to save or retain dirty work and requires an active API reply to finish or be cancelled. After sign-out, every launch form—including a file, target, file-plus-target, or pipe—returns to browser/key activation and resumes only after valid access is restored. Local sign-out does not cancel Paddle billing, revoke the registered device, or free its seat; use this website's Account page for those actions. Revoke a lost or compromised computer remotely rather than relying on local sign-out.

The signed lease, anonymous device ID, clock-rollback checkpoint, and last reported app version, signed-out marker, and verified account summary are kept together in one OS credential-vault record. On macOS, the first licensed launch may ask whetherquillcan use that confidential Keychain item. Enter the Mac login-keychain password and choose Always Allow. Normal startup does not request separate approvals for each licensing field. While the public binary remains unsigned, macOS can ask again after a Quill binary update because its executable identity changed. Choosing only Allow approves one vault operation; macOS may ask once more when Quill persists the consolidated refreshed state. Use Always Allow to persist trust for that exact binary. The local keychain.logrecords only operation names and public credential references for support; it never records a license key or signed token.

Revoking a device frees its seat but permanently blocks that device ID from using the same license key again. Contact support if a device is removed by mistake.

Treat the license key like a password: it is the credential the app presents during activation, and anyone who has it can occupy an available device seat. A private evaluation is limited to one device; paid and complimentary access covers up to 3. Sharing an installer does not share access. If a device is unfamiliar, revoke it from the account page and contact support to rotate the key. Rotation prevents the old key from activating or refreshing; a previously issued signed lease can remain valid only until its existing deadline—at most 24 hours for an evaluation or 3 days for paid and complimentary access, and never beyond the entitlement end.

Plan changes show Paddle's prorated amount and next recurring charge before confirmation. The hosted billing portal manages invoices, payment methods, and cancellation. Canceled access remains usable through the paid period.

Paid and complimentary access receives a signed offline lease for no more than 3 days. Evaluation devices check in at least every 24 hours. A token never runs past its paid-through, grant, or evaluation end. The app also monitors the signed deadline while it is open: at expiry the editor closes into the activation screen. The user does not need to uninstall it; local data remains in place, and purchasing or receiving new access unlocks the same installation. Refunds, chargebacks, access revocations, and device revocations are enforced no later than the end of the current verified lease.

Quill checks for releases in the background at startup when update checks are enabled. Open the menu and choose Check for updates for an immediate result. A manual check opens one update panel showing the installed version, latest release, and check status. When a newer release is available, the same panel shows its Download button, then becomes a safe Restart action after the verified download page opens.

1. Choose the Download button in the update panel or open your account download page.
2. Recommended: save your work and close Quill before installing. You can instead keep working and install later; the current process remains on its current version.
3. Use the same installation method as before. Rerun the matching native installer or command-line script, update the same .deb/.rpm package through its package manager, or run brew upgrade arafayrs95/tap/quill for Homebrew. Mixing Windows Setup and the PowerShell installer can leave two binaries in different locations.
4. Reopen Quill after installation. If macOS/Linux replaced the binary while Quill stayed open, return to the update panel and choose Restart Quill Terminal safely. Save an unsaved draft or keep it in durable recovery.

Activation, settings, drafts, templates, saved files, session records, and history stay in place during a normal update.

Quill does not mutate its already-running process. macOS/Linux can install the replacement while Quill stays open; Windows Setup may require closing Quill because its executable is in use. The account and Admin version views update after the installed app next completes a licensed online activation or refresh, rather than at download time.

Windows Setup adds an uninstaller to the Start Menu and Windows Settings → Apps. Linux package installs can be removed with the package manager. These verified uninstallers cover native packages, Homebrew, and command-line installations:

curl -fsSL https://quillterminal.app/uninstall.sh | sh

irm https://quillterminal.app/uninstall.ps1 | iex

powershell -NoProfile -ExecutionPolicy Bypass -Command "irm https://quillterminal.app/uninstall.ps1 | iex"

A normal uninstall preserves activation, settings, drafts, templates, and history for an easy reinstall. Before permanent cleanup, remove this computer under Account → Activated devices to revoke it and free the license seat. The following commands then delete Quill's local data and attempt to remove its credential-vault entries where operating-system tools are available. That cleanup cannot be undone. On Linux without secret-tool, remove Quill entries manually through the Secret Service or keyring UI.

curl -fsSL https://quillterminal.app/uninstall.sh | QUILL_REMOVE_DATA=1 QUILL_REMOVE_CREDENTIALS=1 sh

$env:QUILL_REMOVE_DATA="1"; $env:QUILL_REMOVE_CREDENTIALS="1"; irm https://quillterminal.app/uninstall.ps1 | iex

The default data root is ~/.quill on macOS and Linux, and %USERPROFILE%\.quill on Windows, with %APPDATA%\quill as its fallback. QUILL_HOME overrides the root on every platform. The paths below are relative to that root.

History is enabled by default, retained locally in plaintext, and capped at 1,000 entries unless you change the retention limit. Menu → History can export it to Markdown or clear it using SQLite secure deletion and database compaction. Set enabled = false under [history] to stop recording.

Provider API keys stay in the OS credential vault. Prompt files, drafts, templates, history, and session records remain local. Network access is used for licensing; enabled release and model-metadata checks; key verification; and the provider API or CLI actions you initiate. Quill does not upload local prompt history as product analytics.

• Command not found: open a new terminal after installation. If you used a portable archive, place its directory on your user PATH, then run quill --version.
• Wrong processor build: run uname -m on macOS/Linux or open Windows Settings → System → About. Use arm64 for Apple Silicon, Linux arm64, or Windows 11 ARM; use x86_64/x64 for Intel or AMD.
• Linux will not start: the current Linux builds require glibc 2.34 or newer. The .deb and .rpm packages declare that minimum; the shell installer checks it before downloading.
• Ctrl+Enter inserts a newline: the terminal cannot distinguish that chord. On macOS/Linux use Alt+Enter; on Windows use Ctrl+Enter in Windows Terminal or select the Send button.
• A key or license cannot be stored on Linux: unlock or install a Secret Service provider such as GNOME Keyring or KWallet. For provider API keys in a headless environment, use the documented environment fallback.
• Activation is rejected: confirm access is active, copy the complete key, check the internet connection and system clock, and retry. Never send a license or API key in a public issue.
• Device limit reached: revoke a computer you no longer use under Account → Activated devices, then retry.
• Update says Quill is running: Windows may lock the executable; save or keep recovery, close every Quill Terminal window, and rerun Setup. macOS/Linux users can normally install first and use the update panel's safe Restart action.
• Checksum mismatch: delete the download and fetch it again. Do not install a file whose SHA-256 differs from the account download page.

Still stuck? Use the feedback page or email support@quillterminal.app. Include the operating system, processor, Quill version, terminal, and exact error text—but never a secret.