Frequently asked questions

QUILL is a screen-reader-first writing studio for Windows and macOS. It is designed so that people who use assistive technology are first-class users, not an afterthought: every action announces a clear outcome, everything works from the keyboard, and nothing reaches the network without your explicit say-so.

QUILL is Quality, Usable, Inclusive, Lightweight, Literate - the values the whole project is built around.

Anyone who writes, with a particular focus on blind users, screen-reader and keyboard-only users, accessibility professionals, researchers, developers, and students. If you have found mainstream editors noisy, inconsistent, or hard to navigate with assistive technology, QUILL is built for you.

Windows 10 or later (64-bit), integrating with NVDA, JAWS, and Narrator, and macOS 12 or later. Both builds include the Python runtime; the heavy optional pieces - speech engines, document converters, braille tables - download on demand so the base install stays small.

Yes. QUILL is open source under the MIT license, and every feature is free for everyone, always. Supporters who choose to donate are thanked by name as Golden Quills in the About dialog - donating is entirely optional and never required.

A small team and a large community. Testers' reports are the roadmap, contributed fixes ship with credit in the release notes, and more than one feature on this very site began as a mailing-list suggestion. QUILL is built with the people who depend on it, not just for them.

Pick the way you like to learn. By listening: the QUILL Cast is a free 36-episode audio course that goes from the installer to every feature, with homework after each episode. By doing: the hands-on tutorials start with "your first hour in QUILL." By reading: the user guide is the complete reference. Inside the app, a short setup wizard runs on first launch, and F1 explains any command.

A short, screen-reader-first setup wizard walks through the essentials - and if you cancel it, QUILL still starts with sensible defaults. Windows' built-in voices work immediately; anything heavier is offered as a download exactly when you first reach for it.

The basics are a familiar editor: File, Edit, menus where you expect them, Ctrl+S saves. Feature profiles keep the interface as small as you like (Essential or Writer) and grow it when you are ready (Developer, Accessibility Professional, Full QUILL). The command palette (Ctrl+Shift+P) finds any command by typing part of its name, and every command has an F1 help topic.

Both. Verbosity settings shape how much QUILL says; sound events can replace or silence spoken cues; dialog enter/exit announcements are off by default because your screen reader already announces dialogs. The goal is your mix, not ours.

The current published release is 0.9.0 Beta 2. All Windows options include an embedded Python runtime. Online installers download optional components (speech engines, converters, language packs) on first use. Offline installers bundle everything.

• Windows system installer (online) - installs to Program Files and adds QUILL to your Start menu. Downloads optional components on first use.
• Windows system installer (offline) - includes all optional components bundled. For restricted networks or offline use.
• Windows portable ZIP (online) - extract and run from any folder, no installation required. Downloads optional components on first use.
• Windows portable ZIP (offline) - includes all optional components bundled. For restricted networks or offline use.
• macOS disk image - drag QUILL to Applications.

0.9.0 is the final feature beta before QUILL 1.0. Everything the project set out to build is in the product - the complete optional AI suite, the Accessible Vault, Story Studio, GLOW, Hey QUILL voice control, document rescue with on-device OCR, restore points, multilingual Read Aloud, Table Studio, and the Quillin Hub. Read the full story in the 1.0.0 release notes.

From 0.9.0 to 1.0, no new features are added - every change is a bug fix, a polish pass, or a performance win, driven by community reports. Your bug reports are literally the roadmap now. 1.0 will have the same features as 0.9.0, with fewer surprises.

The product is feature-complete and heavily tested (over 7,000 automated tests run on every change), but rough edges remain and your reports smooth them. Layered safety nets - autosave, backups, restore points, crash recovery - are designed so a beta bug should never cost you words.

If the community reports a shipped feature misbehaving badly, a signed advisory can temporarily switch off that one feature - announced out loud with its reason - until the fix ships. Advisories only ever turn things off, persist offline, are lifted by the same signed feed, and are used only in response to real user reports. A local override (QUILL_IGNORE_FEATURE_LOCKS=1) always leaves you the last word.

Yes, at startup by default - the check fetches QUILL's own signed feed and sends nothing about you or your documents. It also delivers safety advisories, which is why it defaults on. Turn it off in Preferences and that choice is honored; Safe Mode always skips it. Downloads are checksum-verified against a signed manifest.

Report a Bug inside QUILL (Help menu) prepares an issue for you, or open one directly on GitHub. Accessibility problems are treated as bugs, not enhancement requests. During the road to 1.0, feedback is the whole game.

NVDA, JAWS, and Narrator on Windows, with parity as a design requirement - a feature that only works well in one screen reader is not done. QUILL detects your screen reader and routes announcements accordingly, with selectable backends.

Every command announces a clear outcome: "Wrapped 3 words in bold", "Nothing selected", "Saved." A command that succeeds silently is treated as a bug. Even the nightly automated tests read QUILL's spoken output - the same channel you hear - and fail when it goes quiet.

The last twenty announcements, kept in a dialog you can arrow through, re-read, and copy (Alt+Shift+E). Missed what QUILL said? Get it back. Double-pressing an informational command opens the Echo instead of re-speaking.

Yes - keyboard-completeness is a hard requirement. Every feature is reachable and operable without a mouse, dialogs have predictable focus and no traps, and the Keymap Editor lets you rebind anything, tells you which command owns a key before you take it, and heals broken bindings with one press.

Yes. Structured selection tools start, extend, complete, and reselect by word, sentence, line, paragraph, or block - deliberate, reviewable selection that never depends on visual feedback.

Yes - your screen reader drives the display, and QUILL keeps status strings short and meaning-first for braille reading. Beyond display use, QUILL is a braille production tool: translation and embossing through liblouis, byte-exact BRF editing, and page-layout proofreading against your embosser's limits.

Yes. Themes follow system, light, or dark with real contrast in each, color never carries meaning alone, and motion is minimal by design.

The interface is translatable with a display-language switcher, and the first community translation already ships: Italian, contributed by Elena Brescacin — switch under Tools > Writing and Language > Change Display Language. The speech suite reads documents in many languages (see the speech section below), and spell-check dictionaries for additional languages download on demand. Want yours next? The user guide's translation chapter walks the whole contribution flow.

File it like any bug - accessibility issues are first-class defects here. Include your screen reader and what you heard versus what you expected to hear. The fix often ships with your name on it.

Yes. Formatting rides along as invisible codes while your editor stays clean plain text. Apply bold, italic, underline, fonts, sizes, colors, highlights, alignment, spacing, and named styles from the Format menu, and ask "Describe formatting at cursor" to hear exactly what is in effect: "Arial, 14 point, centered, bold."

Yes - reimagined screen-reader-first. Alt+F3 opens a pane showing your document as a stream of codes and text: [Bold On], [Font: Arial], [Center], [Hard Return]. Every code is an individually announced, navigable item; jump from a [Bold On] to its matching [Bold Off] and hear its reach.

A plain .txt cannot hold fonts or colors, so QUILL can save an Illumination - a small companion file that carries the formatting beside the genuinely plain text. Reopen the .txt in QUILL and everything returns exactly; open it anywhere else and it is just clean text. If another program edits the text, QUILL notices and opens it plain rather than mis-applying stale formatting.

Yes - restore points. Every save quietly keeps a content-based snapshot, and File > Restore Previous Version lists them in plain language ("Today at 4:12 PM - 2,341 words"). Restore replaces your text after snapshotting the current version first - so restoring is itself reversible - or open the old version as a copy in a new tab. History thins politely with age and never prunes your newest five saves.

Abbreviations expand short triggers into longer text as you type. Snippets add placeholders, choices, dates, prompts, and cursor placement. Smart triggers like =todo(10) generate content when you press Enter on the line. Macros record and replay whole command sequences. All of it is announced and undoable.

Twelve persistent clipboard slots with labels and pinning. Paste any slot with a chord, double-press to hear a slot's contents before pasting, and let Copy to Next Empty Slot route around your pinned favorites. Slots survive restarts - a standing library of the fragments you use daily, also reachable from the system tray.

Find, replace, wildcard, and regular-expression search with history and find-all reporting. Big Replace All operations show a preview of every change first. The Regex Helper explains patterns in plain language, and Compare Mode reviews your document against another file or the clipboard in a keyboard-first diff.

Table Studio gives you a real keyboard grid: crossing a row speaks the column heading, F2 edits a cell, Alt+arrows move rows and columns. Build a table from scratch or open a CSV/TSV straight into the grid, then insert it as a properly-headed Markdown or HTML table or save it back as CSV.

Notebooks organize a folder of files into one working environment with entries, bookmarks, snapshots, and optional writing goals. Sticky Notes capture passing thoughts without leaving your document, and inline notes anchor comments to the exact text they are about, following it through edits.

In the WordPerfect Editor tradition: Repeat Next Command runs anything N times in one gesture; Restore Deleted Text re-inserts any of the last three structured deletions (distinct from Undo); Describe Character at Cursor names the exact character under the caret, invisibles included. A read-only guard protects reference documents from stray keystrokes.

Plain text, Markdown, HTML, Word (.docx and legacy .doc), RTF, EPUB, PDF, PowerPoint, Excel, Apple Pages, OpenDocument, CSV/TSV, Jupyter notebooks, JSON, YAML, TOML, XML, SQLite, and the braille family (.brf, .brl, .pef). Complex extractions come with an honest intake report about confidence and quality, and Open from URL pulls a web document straight into a tab.

It really converts. Save as Word and headings become Word heading styles, each editor line becomes one paragraph, and your formatting lands on real Word runs - then QUILL announces it: "Saved as report.docx, Word format. You are still editing QUILL text; each save converts it to Word." Opened PDFs, EPUBs, and spreadsheets can never be overwritten with plain text - QUILL explains and routes you safely.

That is exactly what document rescue is for. QUILL detects that a PDF looks scanned, asks (never assumes), and runs free on-device OCR - the Tesseract engine, CPU-only, offline, a one-time verified download. It flags low-confidence lines for review, and only for documents nothing local can rescue does it offer an optional bring-your-own-key cloud service, consent-gated on every single upload.

Yes. Braille translation and embossing run through liblouis (the table pack is a small on-demand download), BRF files keep a byte-exact contract, and Braille Repair proofreads layout against your embosser's limits. One export writes a DAISY 2.02 talking book - the folder a Victor Reader Stream or Plextalk plays with its own voice, your headings as navigation points.

The batch conversion wizard converts whole folders through Pandoc in the background: curated profiles (Clean Word Document, Accessible HTML Page, EPUB Book, Print PDF, Plain Text for Screen Readers), sensible overwrite policies, live progress in the Status Page, and one spoken completion line. Pandoc itself is an on-demand, checksum-verified download.

Optional open and save over FTP, SFTP, WebDAV, S3, and HTTPS; a full GitHub repository browser; and edit-over-SSH where a remote file uploads back on save with a tilde backup. All off by default, never silent, enable only what you need.

Post to Mastodon with an optional per-account pre-post spelling review. An experimental read-only WordPress connection browses your site's content - sending stays locked until it earns trust, and we say that plainly. And your work exports as Word, EPUB, DAISY, audiobooks, or an accessible website built from a vault.

In your user profile's application-data folder (or beside the app in portable mode - you can choose). All writes are atomic - a temporary file replaced in one step - so a crash mid-write never corrupts what was there. Secrets live in the OS credential vault, never in files.

Layered nets: autosave at your chosen interval with crash-safe snapshots, recovery offered on the next launch, a backup kept around every save, persistent undo across sessions, and restore points for the long memory. A power cut mid-save leaves your existing file untouched.

Every Windows voice you have installed, in any language; the on-device Kokoro neural voices (English, Spanish, French, Hindi, Italian, Brazilian Portuguese); Piper voices as one-click downloads; eSpeak NG's world of languages; the classic DECtalk; optional cloud voices including ElevenLabs with your own key; and, through an experimental browser reader, your browser's premium voices. Read Aloud, audiobook export, and batch speech all honor the voice's language.

Voice control, entirely on-device, in four levels: push-to-talk commands ("save file", "next heading"), conversation mode that ends your turn when you stop speaking, the always-listening wake word (with a status-bar presence so a live mic is never a surprise), and spoken questions handed to Ask Quill with you pressing Send. Warm musical cues mark every state, and prompts can even use your name.

No - that is the design law. Voice only runs a curated, non-destructive allowlist: closing without saving, sending, publishing, and deleting are simply not in its vocabulary. Everything is off by default, off in Safe Mode, and "cancel" always works.

Yes - on-device dictation through whisper.cpp for accuracy or Vosk for a fast, light engine that suits older machines, both downloaded on demand, both offline. Nothing you say leaves your computer.

Recordings become finished documents: transcribe audio or video (optionally translating or identifying speakers), then apply one action - Meeting Minutes, Action Items, Executive Summary, Study Notes, Q&A, a Follow-Up Email, Key Quotes, a Decisions Log, or a clean draft. Build your own actions without syntax, or let a watch folder process recordings as they arrive.

Yes - the Audio Studio (Tools > Speech > Audio Studio) is a guided wizard with three journeys: narrate a folder of documents into a chaptered audiobook (M4B or MP3, with page-turn cues, spoken credits, and ACX loudness mastering), combine a folder of recordings into one chaptered book (each file a chapter, reviewed before the merge), or open any existing audiobook in the Chapter Workbench. Translated editions export in any of ~37 languages with language-matched voices, and incremental rebuilds mean editing one chapter re-synthesizes only that chapter, not the whole book.

The Chapter Workbench opens any chaptered MP3 or M4B (or a chapterless recording) with a chapter-aware player: play to where a boundary belongs and press Split at playhead; retime, merge, rename, or restore the original. Chapters import and export in five formats, silences can propose boundaries, and Propose AI titles names track-file chapters by transcribing each opening minute locally and asking your configured AI for a short title - always proposed for review, never applied blind.

End to end. The Workbench's Publish paths write a complete RSS feed (iTunes + Podcasting 2.0 tags, offline), run a whole show from one folder - every master an episode with its own description, plus an accessible show-notes page - upload over SFTP through QUILL's own SSH machinery with spoken, cancelable progress, or send the book to your own Auphonic account for mastering. Every network path asks first, and secrets live in the Windows Credential Manager.

That is a design goal. Models load on demand and unload when idle; low-resource mode keeps one model in memory and prefers the smallest that fits, turning itself on for very low-memory machines and telling you once, out loud. CPU-only is a first-class citizen.

Linked notes without the visual graph. A vault is a folder of Markdown notes; type [[Note Title]] and follow it by ear, hear "what links here?" as a spoken backlinks list with each mention read in its sentence, gather notes by tags, search everything with regex if you like, and jump anywhere with a type-to-filter switcher. Plain text you own forever - delete QUILL's small cache and you lose nothing.

Yes: templates with {{date}}, {{title}}, spoken {{prompt}} questions and {{cursor}} placement; Open Today's Note with previous/next walking for a journal; Export Vault as Website for a small accessible site with your links resolved; and Git-based Sync Vault over your own remote that lists conflicts rather than overwriting a word.

A keyboard-navigable binder for a whole book: manuscript parts, chapters, and scenes drawn from your own Markdown headings, plus Characters, Places, Plot threads, Research, and Brainstorm groups. Character sheets are small accessible forms saved as plain front matter in the files themselves, and Compile Manuscript stitches everything into one document ready for any export. A project is a folder of plain text plus one companion file - nothing locked in.

Guided accessibility review and repair inside your editor. Audit a document or a whole Word, PowerPoint, Excel, PDF, or EPUB file; every finding names its rule, severity, and a plain-language suggestion; fixes are deterministic and reviewable in a compare session - never a silent rewrite - and file repairs always write a copy beside the untouched original. Runs on your machine; optional networked helpers stay off unless you consent per action.

No telemetry, no analytics, no tracking. The only routine network call is the startup update check against QUILL's own signed feed (which also delivers safety advisories); it sends nothing about you or your documents, and you can turn it off.

Only when you explicitly send it: a cloud AI action you approved, a cloud OCR upload you consented to (asked every single time), a cloud voice you chose, or a publish action you triggered. Every outbound call site in the codebase is registered in a network egress audit that the build enforces - "no silent network" is a test gate, not a slogan.

In the operating system's credential vault (Windows Credential Manager / macOS Keychain), never in settings files. Sensitive settings are encrypted at rest, and crash reports pass a redaction scrubber so tokens and personal paths never leave your machine.

Yes. The core writing experience, on-device speech, dictation, OCR, braille, and local AI models all work with no network at all. Networked features are opt-in extras, not requirements.

AI features are optional and explicitly opt-in. Turn AI off and AI features are hidden entirely - nothing AI-related runs silently. Turn it on and every networked AI action is a deliberate, per-action choice with visible progress. See responsible AI use.

No. The setup wizard leads with the free options: most private, a model running on your own computer (no account, offline, nothing leaves your device); best quality, your own free OpenRouter key with a strong free model preselected. Models that cost nothing say "Free" out loud in the list, and QUILL is honest that free hosted models can be slower and that confidential writing belongs on-device.

One conversation that knows your document. Ask for help writing, editing, summarizing, or restructuring - and when an action would change your document, QUILL shows the proposal as an accessible accept/reject preview applied as a single undo step. There are no silent edits.

On-device models (Ollama), OpenAI, Claude, Google Gemini, OpenRouter, and custom OpenAI-compatible endpoints. Every provider with a key has a Get API Key button that opens the right signup page, and real model dropdowns replace typing ids from memory.

For GitHub Copilot, yes: pick the Copilot engine and a short spoken device code in your browser signs you in - no API key at all, running on your plan's models. The Claude Agent and OpenAI Agents engines connect with the Anthropic or OpenAI API keys you already have; ChatGPT and Claude chat subscriptions do not include API access, so they cannot power those engines. Whichever engine runs, QUILL owns every edit and you approve every change.

Prompts, Skills, and Agents in one tabbed manager with a real promotion path: a Prompt graduates into a multi-step Skill, a Skill into a first-class Agent - all reviewable, all running through the connection you set up once, and shareable as packs on the Quillin Hub.

No. The same "no silent network" rule applies: an AI action that needs to send your text asks first, shows what is happening, and announces the result. Use a local model and nothing reaches the network at all.

A Quillin is a small, sandboxed extension that adds commands, snippets, menus, and hotkeys to QUILL. It is described by a manifest.json and comes in two layers: declarative snippets (no code) and Python or Node.js handlers (real logic, isolated in a subprocess).

Quillins run under a default-deny capability model: a Quillin can only do what it declares, and sensitive capabilities (filesystem and network) additionally pass a per-action consent gate at runtime. Python and Node.js handlers run out-of-process in a sandbox. A crash in a Quillin cannot affect your editor or your document.

The community store at hub.quillforall.org for every shareable QUILL artifact: Quillins, AI agents and skill packs, sound packs, keyboard packs, verbosity packs, and pronunciation dictionaries. Every submission is validated and every published artifact is cryptographically signed - the storefront and your Quillin Manager both speak the signature state.

Bundled Quillins ship with QUILL as trusted, reviewed first-party features and are enabled by default. Third-party Quillins run through the same sandbox but are disabled by default. You review, enable, disable, reload, or remove them through the Quillins Manager, which also shows each one's signature state.

Only if it declares the matching capability and you approve each use at runtime. There is no way for a Quillin to silently read files or reach the network.

Start with the tutorial, which builds one from scratch. The authoring reference covers the manifest schema, capability catalogue, and the Python and Node.js APIs in full. For a snippet-only Quillin, the Snippet Wizard builds the manifest interactively without any coding.

Not necessarily. Layer 1 Quillins are pure declarative snippets - text with placeholders like ${selection}, ${date}, ${word_at_cursor}, and ${uuid} - with no code and no capabilities. That covers many common needs.

Yes. Layer 2 Quillins support both Python and Node.js handlers. Your handler runs out-of-process in a sandboxed subprocess under the same capability and consent model as Python handlers.

Run the submission linter: python -m quill.tools.quillin_lint <dir> --strict - or simply use Tools > Quillins > Submit to Quillin Hub, which runs the same validation locally and reads you the verdict in an accessible dialog before anything touches the network.

From inside QUILL: Tools > Quillins > Submit to Quillin Hub. Pick your manifest, pass local validation, and the Hub's Submission Forge reviews it; published artifacts are signed and appear with a spoken "Signed by" badge.

The Quillin Author Covenant: announce every outcome, be keyboard-complete, declare the minimum capabilities, no silent network or telemetry, readable source (no obfuscation or sandbox-escape), and clear licensing. Every submission attests to it.

Do not open a public issue. Follow the private reporting process in the security policy.

Capabilities are default-deny, filesystem and network access are consent-gated per action, Python and Node.js handlers run out-of-process in a sandbox with import allowlists and resource caps, Hub artifacts are signed and verified, and every dialog and network egress point is reviewed by automated gates in CI.

Launch with --safe-mode and QUILL starts with optional state off: no AI, no watch folders, no Quillin contributions, no update check. It is the good first step when troubleshooting a strange session - and the guarantee that nothing optional can stand between you and your document.

Yes. Update checks verify a signed manifest; installers, optional components, and the GLOW engine are checksum-verified; failed installs roll back. Safety advisories ride the same signed chain, so nobody can disable your features by spoofing a feed.

Code, documentation, accessibility testing, Quillins, sound packs, keyboard packs, and plain honest bug reports are all contributions - and during the road to 1.0, testing and reporting is the most valuable one. Start with the contribution guidelines.

They are the product. One tester's eight-line save bug rebuilt the entire save pipeline. A mailing-list suggestion reshaped this website's front page. Contributed fixes ship with the contributor's name in the release notes. If something creaks, say so.

The core and I/O layers never import the UI toolkit, persistence is atomic and schema-validated, the UI thread owns all widgets, and there are no silent network calls. The contribution guidelines and the product requirements document spell these out.

See the governance document for how decisions are made and the maintainers list for who stewards the project.

Use GitHub Discussions for Q&A and early design exploration, and the issue templates for specific bugs or proposals. The community mailing lists are read too - more than one feature began there.