QUILL 0.6.0 is a community release in the truest sense of the word.
Yes, it is a major step forward for screen-reader-first writing, editing, AI-assisted authorship, automation, braille, code review, and extension-powered workflows. But the bigger story is not only what changed. The bigger story is who is helping QUILL become what it is becoming.
Kelly Ford, Taylor Arndt, Shane Popplestone, Michael Babcock, and so many others are helping lift this project into a new place. Some people are testing. Some are contributing code. Some are filing issues, describing real-world workflows, stress-testing accessibility, challenging assumptions, improving design direction, or simply cheering the project on when the work gets hard. All of that matters. All of it counts.
Whether you are writing code, testing with JAWS or NVDA, trying a build and telling us where it hurts, sharing ideas, building Quillins, improving prompts, creating documentation, or encouraging the team from the sidelines: thank you.
“I started QUILL, but the community is lifting it to levels I could never reach alone. This release is about meeting people where they are, then giving them a path to grow.”
— Jeff Bishop
QUILL is being built around a simple promise: a free, cross-platform editor that is usable by all assistive technology, shaped by the people who depend on it, and driven by community need rather than by assumptions about what blind and screen-reader users should want.
The core principle of this release is Meet You Where You Are.
That means QUILL should not force every user into the same cockpit. A first-time writer should be able to open a quiet editor and start typing. A braille professional should be able to inspect page, line, and cell position with confidence. A developer should be able to move through code by tokens. A reviewer should be able to compare files without visually scanning a diff. A writer should be able to ask AI for help without leaving the keyboard. A power user should be able to extend the editor through Quillins. Everyone should be able to start at the right level and grow from there.
This release is about speed, confidence, control, and delight. You can type a short trigger and get a full template. You can open a braille file and know exactly where you are by page, line, cell, and progress. You can compare two files without visually scanning a diff. You can move through code by tokens instead of guessing where words begin and end. You can export to Word, inspect encoding problems, generate citations, and shape the sound layer so QUILL confirms what happened without talking over your screen reader. And now you can ask the AI to rewrite a paragraph, surface a better word in context, check your grammar, translate a document, or put a question directly to your own text — all from the keyboard, without leaving the editor.
Under the surface, QUILL 0.6.0 introduces two major architectural expansions. The first is the AI writing layer: a complete, provider-agnostic toolkit covering twelve tasks from spell check to table-of-contents generation, with per-task custom instructions, prompt caching across every supported provider, and support for Anthropic Claude, OpenAI, Google Gemini, OpenRouter, and Ollama. The second is the Quillin extension platform: extensions can now own settings, contribute live preference dialogs, subscribe to document lifecycle events, contribute status-bar cells, declare dependencies, restrict network access, schedule background timers, respond to file-type opens, and initialize or shut down cleanly. Both are designed so you stay in charge and nothing runs silently without your knowledge.
Everything remains keyboard-first and screen-reader-first. Every new view is a real navigable control. Every action is announced, undoable where appropriate, and discoverable. No mouse is required. No visual-only flourish is required. No silent full-file scanning happens behind your back.
If you are upgrading from QUILL 0.5.0, read What works differently now near the end. It lists the few places where menus, habits, or installer choices changed.
QUILL 0.6.0 is organized around real user experiences instead of technical checklists. Each major area answers a practical question:
.LOG compatibility, append anchors, snippets, citations,
and export tools.“A feature is not finished when it exists. It is finished when the person using it feels confident, respected, and in control.”
— Jeff Bishop
This is the fast tour. The detailed notes below keep every important implementation detail, but these are the moments users will feel first.
.LOG files, document directives, and append
anchors into one safe automation system..docx or rich text through Pandoc, preserving real Word
heading structure when the source contains structure.This is the heart of the release. QUILL now begins with the person, not the feature list. It asks what kind of work you do, explains what you will get in plain language, and keeps the rest out of your way until you are ready.
“Meeting people where they are means respecting beginners, professionals, power users, and explorers equally. QUILL should feel welcoming on day one and powerful on day one hundred.”
— Jeff Bishop
QUILL has grown into a serious piece of software. That is a good thing. But first-time users who want a reliable plain-text editor should not have to wade through braille menus, AI panels, regex options, a developer console, and a Snippet Gallery before they type a single word.
This release changes that completely. QUILL now starts you at the right level and grows with you.
When you run QUILL for the first time, a short wizard opens. It has five pages and takes about two minutes.
The most important page asks one question: What kind of writing do you do? A list of seven starting points is shown. Arrow up and down through the list. As you move, a large read-only text area below the list updates live to tell you, in plain spoken English, exactly what you will have if you choose that option. There are no feature IDs, no jargon about flags, and no list of what you will not get. Just what you get.
After you choose, a second page offers a few optional extras: AI writing assistance, Braille Mode, and typing automation. Only the extras that are not already part of your base choice are shown. Each extra is a single checkbox. Checking one adds a sentence to the preview so you always know what you are committing to.
If you enable AI, a dedicated page collects your provider and your API key. Supported providers are Anthropic (Claude), OpenAI (GPT), Google Gemini, OpenRouter (many models), and Ollama - which runs models on your own device or connects to an Ollama-compatible cloud host. The key is stored securely in the Windows Credential Manager, not in a settings file. You can skip this and set the key up later.
The final page is a summary in plain text: your profile name, what features are active, which Quillins are enabled, your keyboard pack, and your sound setting. Read it, then press Finish.
If you press Cancel or close the wizard on first run, QUILL starts you in the simplest possible editor - Just a Text Editor - rather than leaving you with an overwhelming set of defaults. You can always run the wizard again from Help > Personalise QUILL.
Alt+Shift+P opens the quick profile switcher at any time. It shows the same list of profiles with the same rich description pane so you can switch, read what you are switching to, and confirm - all by keyboard.
Open, type, and save. Plain text editing, auto-recovery, find and replace, and recent files. Nothing else runs. No Quillins, no AI, no automation, no abbreviation shortcuts, no snippet packs, no sticky notes. The Search menu has no cross-file options. The system tray has only Show Quill and Exit Quill. Preferences shows only the four settings areas that apply. The command palette shows only the commands you have. This is QUILL at its quietest.
Adds document-writing tools: RTF and Word formatting, Compare Mode for reviewing drafts, abbreviation shortcuts (type a short phrase and expand it automatically), spell check, starter snippet packs for common phrases and templates, sticky notes attached to any document position, Copy Tray with 12 clipboard slots, the Journal Stamp Quillin for date headers and post-save word count announcements, the Document Guardian Quillin that warns you before closing a short or unfinished document, and the Date and Time insert menu. The system tray gains Copy Tray and Sticky Notes. AI and braille are not enabled but can be added any time.
Adds everything in Writer plus Markdown syntax helpers, the HTML encoding and decoding tools, the Insert Character picker for Unicode symbols, Text Tools for case transforms and whitespace cleanup, Line Tools for joining and filtering, and regular expression search. The menus expand to include Format > HTML and Encoding and additional text transformation items.
Adds everything in Writer plus Read Aloud at full prominence, Compare Mode, Document Trust and intake workflow, OCR image-to-text, the character inspector, and the Keymap Editor for remapping shortcuts. Designed for document reviewers, accessibility testers, and anyone who needs to read and check content carefully.
Adds everything in Accessibility Professional plus the full Braille Mode: BRF and BRL file support, a braille status bar cell showing your position, Grade 1 and Grade 2 translation via the Braille menu, the BRF Tools Quillin for translation preferences and page handling, and Smart Insert BRF test content. The Braille menu appears in the menu bar.
Adds everything in Writer plus Ask Quill (Alt+Q), AI grammar check and rewrite, AI writing prompts, AI writing skills for multi-step tasks, AI image description, the Prompt Library, and Smart Insert typing templates. The AI menu items and the Ask Quill panel are visible. You will be asked to set up a provider and API key during the wizard.
Turns on everything: regular expression search, macro recorder and playback, shell integration, all text and line transformation tools, Smart Insert, BRF Tools, Markdown Helpers, the Character Picker, GitHub remote file access, the Developer Console, Watch Folder automation, and all other Quillins. The full menu structure is visible.
When you choose a profile, every surface adjusts immediately. The menus show only items that belong to features you have enabled. The Command Palette and Go to Anything (Ctrl+Shift+`, G) list only commands that are active in your current profile. The system tray right-click menu shows only the tools that apply. There is no visual noise from features you have not asked for, anywhere.
Specific examples of what changes by profile:
Just a Text Editor: the Insert menu has no abbreviation shortcuts. The Search menu has no Search in Files or Replace Across Files. The system tray shows only Show Quill and Exit Quill. Preferences shows only General, Profiles, Status Bar, and Keymap. Install Starter Snippet Packs does not appear because snippets are a writer-level feature.
Writer and above: abbreviation expansion and Manage Abbreviations appear in the Insert menu. The Search menu gains Search in Files and Replace Across Files. The system tray gains Copy Tray and Sticky Notes. Preferences gains AI Connection (when AI is on), Watch Folder, and any other active feature areas.
Developer and Power User: Search in Files and Replace Across Files are always visible. All Insert menu tools are present. The system tray shows all available tools.
As you grow into QUILL and add features from Help > Personalise QUILL, every surface grows with you. Switching from Just a Text Editor to Writer adds abbreviation tools, snippet packs, sticky notes, the Insert menu tools, and the word-count status cell. Switching to Braille Professional adds the Braille menu. Switching to Developer adds everything else.
This is what “meeting people where they are” means in practice: start with what you need, discover the rest when you are ready, and never feel lost in a cockpit before you learn to fly.
Press Alt+Shift+P at any time to open the quick profile switcher. A list of all profiles is shown on the left. As you arrow through them, a large read-only description pane on the right shows the same plain-English “what you get” text as the wizard. Choose a profile and press Enter to switch. The menus, palette, and status bar update immediately.
Custom profiles you create in Help > Preferences > Profiles and Features also appear in the switcher with the description you wrote when you created them.
The Profiles and Features dialog (reachable from the Help menu and from Preferences) lets you create custom profiles based on any built-in starting point. The description field is now a full multi-line editor. Write the same kind of plain-English “what you get” summary that the built-in profiles show - it will appear in the Alt+Shift+P switcher description pane so you and others can read it before switching.
The Preferences hub shows only the settings areas that matter for your current profile. If AI is not enabled, the AI Connection category does not appear. If Watch Folder Automation is off, that category is gone. If GLOW is off, GLOW Accessibility is not listed. Open Preferences and you see only what applies to the way you have chosen to use QUILL.
As you enable more features - by switching profiles or turning features on individually in Profiles and Features - those areas appear in Preferences automatically. Nothing is permanently hidden; it simply waits until it is relevant.
Help > Feature Profiles > Manage Individual Features lets you turn individual capabilities on or off on top of your chosen profile without changing the profile itself. Enabling a feature also enables what it depends on; disabling one turns off the features that depend on it.
The dialog now has a Show radio button at the top with two choices: All features and Disabled features only. Arrow to “Disabled features only” and the list immediately filters down to just the features that are not currently on. You can then tab through that shorter list and turn on exactly what you want, one checkbox at a time, without scrolling past everything that is already running.
When you enable a feature in the filtered view, it disappears from the list immediately because it is no longer disabled, and focus moves to the next disabled item so you can keep going without losing your place.
Below the list, a read-only description area explains the focused feature before you touch its checkbox.
Community testers have been clear: speed matters, but surprises are not acceptable. Insert Automation is built for both. It gives you templates, log entries, abbreviations, and smart triggers while keeping every action explicit, announced, and undoable.
“Delight is not about fireworks. Delight is when the editor does the small helpful thing at exactly the right moment and then gets out of your way.”
— Jeff Bishop
Insert Automation is the daily-workflow feature that changes how QUILL feels in practice. It combines typed shortcuts, templates, log files, smart text generation, document directives, and append anchors into one coherent keyboard-first system.
Everything is safe by design. Nothing scans your whole file silently. Nothing runs on a partial match. Nothing changes a read-only file. Every insertion is announced, discoverable, and one undo step.
Type a short abbreviation, press a delimiter such as space, comma, or period, and QUILL replaces the abbreviation with the full text.
The bundled Smart Insert Quillin ships with five abbreviations:
Your own abbreviations always win when there is a conflict. Quillin-provided abbreviations appear in the Insert Automation Reference and can be disabled individually.
Type a command alone on a line and press Enter. QUILL replaces the
whole line with the generated result. Smart triggers begin with
= so they do not collide with ordinary sentences.
=bug() -> bug report template
=meeting() -> meeting notes template
=journal() -> journal entry with today's date
=todo(5) -> five-item to-do checklist
=logentry() -> timestamp at the cursor, formatted your way
=rand(3,4) -> three paragraphs of four readable sentences each
=brftest() -> a complete, predictable BRF test documentThe parser is intentionally strict. A trigger activates only when it
is alone on the current line, only accepts the allowed number and type
of arguments, and rejects anything it does not recognize. Typing
=bug() in the middle of a sentence is always safe. If a
trigger would create a very large insertion, QUILL asks for confirmation
before writing anything.
.LOG file
compatibilityOpen a file whose first line is .LOG and QUILL behaves
like Notepad: it finds the correct spot and inserts a fresh
timestamp.
If the file contains a QUILL-LOG-APPEND-HERE anchor near
the bottom, the timestamp lands just before the anchor and the anchor
remains in place for the next entry. If the file is read-only, QUILL
tells you rather than failing silently.
The timestamp format is configurable in Preferences ->
Smart Insert -> Log Mode. Available formats include Long
date and time, Short, ISO 8601, Date only, Time only, and custom
strftime patterns.
Any file can include a QUILL-APPEND-HERE marker near the
bottom. Generated content lands before that marker instead of being
shoved after footer notes, metadata, or other closing content. A stable
anchor means generated text always goes exactly where you want it.
Insert Automation follows clear safety boundaries:
This is where the community story gets especially exciting. QUILL is no longer only an editor with built-in features. It is becoming a platform where contributors can build thoughtful, accessible extensions without sacrificing safety, privacy, or screen-reader quality.
“The future of QUILL is not one person deciding every feature. It is a community of people building the tools they wish existed, with accessibility baked into the foundation.”
— Jeff Bishop
QUILL 0.6.0 upgrades Quillins from a command-and-snippet mechanism into a full extension platform.
Quillins can now subscribe to events, own settings, add searchable preference pages, display live status-bar data, declare dependencies, restrict network access, log to a developer console, and initialize or shut down cleanly. The manifest, validator, JSON schema, API surface, and developer tooling have all been expanded so accessibility and safety are enforced at install and load time.
Quillins can contribute their own settings pages. A Quillin declares its preferences as structured manifest data: control type, label, description, default value, validation rules, and related metadata. QUILL renders those settings using accessible, keyboard-navigable stock controls.
The Quillin never touches wxPython directly. QUILL handles layout, tab order, focus, keyboard navigation, and accessibility. StaticText labels are always created before their associated controls in Windows child order so JAWS and other screen readers find the correct label buddy for every field.
Quillins with several groups of settings can declare
tabs inside their preference page. Tabs are a standard
wx.Notebook so arrow keys navigate between tabs and the
active tab is clearly announced.
All five bundled Quillins ship live preference dialogs in 0.6.0. Open Preferences (Ctrl+Comma) and navigate to the Quillin by name:
Quillin settings are stored per Quillin in
%APPDATA%\Quill\quillin_settings\<quillin-id>.json,
written atomically. They survive restarts and are retained when a
Quillin is disabled.
Individual settings may include
search_keywords: extra synonyms and
technical terms that help users find settings by the words they know.
For example, a Date format setting can include timestamp,
iso, and strftime.
Quillins can subscribe to document lifecycle events and run automatically when important moments occur.
QUILL 0.6.0 supports fourteen events:
| Event | When it fires |
|---|---|
document.opened |
A file was opened from disk |
document.activated |
The user switched to this document tab |
document.before_save |
Right before saving; a Quillin can validate or transform |
document.after_save |
After a successful save; safe to log, sync, or confirm |
document.before_close |
Before a tab closes; safe to warn |
document.after_close |
After a tab closes; safe to clean up |
document.created |
A new blank document was created |
document.loaded_from_session |
A document was restored from a crash or session file |
smart_trigger.entered |
Any smart trigger was activated |
abbreviation.expanded |
Any abbreviation was expanded |
quillin.enabled |
This Quillin was enabled or QUILL started with it active |
quillin.disabled |
This Quillin was disabled in Quillin Manager |
quill.shutdown |
QUILL is about to exit |
settings.changed |
A setting owned by this Quillin was changed by the user |
High-frequency events such as text changed, cursor moved, and key pressed are deliberately not available. They would allow a Quillin to observe keystrokes, which creates both privacy and performance problems.
Lifecycle events give Quillins a clean way to manage themselves.
quillin.enabled is for initialization, activation
announcements, cache building, or registration that requires the API to
be live. quillin.disabled allows graceful cleanup.
quill.shutdown allows state flushing before QUILL exits.
settings.changed fires immediately when a user saves a
preference change so the Quillin can hot-reload internal configuration
without restarting.
Subscriptions can include conditions so they fire only
for certain file types, path patterns, or content signatures. A template
inserter can limit itself to files under \journal\. A
.LOG handler can require *.log files. These
filters are pure data, not code.
The capability gate is enforced. A Quillin must declare
document.events in its capabilities to subscribe to events.
Missing that capability, or missing the main module
required to handle the event, fails validation at install time rather
than failing later at runtime.
Quillins can add live cells to the QUILL status bar. A cell has a handler that QUILL calls on demand, such as after save, on tab switch, or on a timer. The handler’s return value becomes the cell text.
Example manifest contribution:
"status_bar": [
{
"id": "wordcount",
"label": "Words: --",
"handler": "get_word_count",
"tooltip": "Current document word count",
"width": 12
}
]To contribute a status cell, a Quillin declares
ui.status in its capabilities, provides a main
module, and describes the cell. The tooltip is read to
screen-reader users when the cell receives focus, so the status bar
remains navigable and informative rather than visual-only.
Quillins can declare one or more category labels for filtering in Quillins Manager.
Available category labels include:
writingaccessibilitybrailleproductivitydeveloperformattingnavigationaiintegrationeducationutilitiesExample:
"categories": ["writing", "productivity"]A Quillin can declare that it requires another Quillin to be installed and enabled.
"requires": [{ "id": "com.quill.journalstamp", "min_version": "1.0.0" }]QUILL verifies dependencies at load time. If a dependency is missing or too old, the dependent Quillin is blocked with a clear message.
Quillins with the net capability can restrict which
servers they are allowed to contact.
"net_allowed_hosts": ["api.openweathermap.org", "*.example.com"]When the list is non-empty, QUILL blocks connections to any host that
is not on the list, even after the user has granted blanket
net consent. Wildcard patterns such as
*.example.com are supported.
Commands can now include a description field. This
description appears in the keyboard reference and command palette as a
one-line explanation that is separate from the menu title.
"description": "Inserts a bug report skeleton with title, steps, expected, and actual fields."api.log()Quillins with the ui.log capability can call
api.log(message) to write structured log lines to the QUILL
Developer Console.
The Developer Console opens from Tools -> Developer
Console in development builds and can be toggled with
QUILL_DEV_BUILD=1.
In production, with the console closed, api.log() is a
no-op. It adds zero normal-use overhead and never writes to files or
speaks to the screen reader.
api.announce() now accepts a priority
keyword argument.
api.announce("Saved.", priority="quiet")
api.announce("File not writable.", priority="urgent")Valid values are quiet, normal, and
urgent. The host maps those values to the screen reader’s
urgency channel. Use quiet for informational messages and
urgent only for errors that need immediate attention.
A new command-line scaffold tool creates a ready-to-edit Quillin directory:
python -m quill.tools.quillin_new com.example.myquillin "My Quillin"Options include:
--layer1 for snippet-only Quillins with no Python.--categories to add category metadata.--doc-events to include sample lifecycle handlers.--status-bar to include a sample status cell.The tool writes manifest.json,
extension.py, README.md, and
LICENSE, then tells the author the next three steps.
Authors should run quillin_lint on the output before
publishing.
The Quillin platform is built around user control.
Open Tools -> Quillins Manager to enable or disable any Quillin. Select a Quillin and press Enable or Disable. The change takes effect immediately; no restart is required. Disabling a Quillin stops all of its commands, event handlers, and status-bar cells. Its preferences are preserved so it picks up where it left off if re-enabled.
Four sensitive capabilities require a confirmation dialog every time a Quillin tries to use them:
| Capability | What it does |
|---|---|
fs.read |
Read a file from disk |
fs.write |
Write a file to disk |
net |
Make a network request |
settings.core.write |
Change a QUILL-wide setting |
When a Quillin requests one of these actions, QUILL pauses and shows a dialog like this:
A Quillin is requesting the 'fs.read' capability for: read_file(path). Allow this action?Choosing no raises a ConsentDeniedError that the Quillin
must handle gracefully. This confirmation appears for every individual
action, not once at install time. A Quillin that reads files can never
read one you have not explicitly approved.
The remaining capabilities are granted once at install time, or
pre-granted for bundled Quillins. These include editor access, UI
announcements, clipboard, storage, settings.own.*, document
events, status bar, and developer log.
Each document event subscription includes an
enabled_by_default field. If it is false, the event starts
inactive. Users can change this any time from Quillins Manager: select
the Quillin and choose Configure Events… to see each
event subscription with a checkbox. Turning an event off stops the
handler from firing; turning it back on resumes it. Per-event state is
persisted in state.json alongside enable/disable and
capability grants.
Capability declarations are enforced, not advisory. If a Quillin
calls an API it did not declare in capabilities, QUILL
blocks the call with a CapabilityError and notifies the
Quillin instead of crashing. Declarations are validated by
quillin_lint at install time and re-validated by the
manifest parser at load time.
Third-party Quillins remain locked off for QUILL 1.0. The SEC-8 gate,
core.third_party_plugins, is locked_off. A
shipping build never discovers, loads, or executes third-party Quillin
code. Quillins Manager still opens and remains fully navigable; it
simply reports that third-party Quillins are disabled. This gate will
lift when the publishing and review process is ready.
min_quill_version is enforced at load time. If a Quillin
declares "min_quill_version": "0.6.0" and the running QUILL
is older, the Quillin is rejected during discovery and listed in the
Manager with an explanatory error such as
requires QUILL 0.6.0 (running 0.5.x).
requires is also enforced at load time. If a Quillin
depends on another Quillin that is not installed, or is installed at a
version too old to satisfy min_version, the dependent
Quillin is blocked. The Manager shows the specific dependency error.
Circular dependencies are caught during validation.
net_allowed_hosts is enforced at every fetch call. If a
Quillin declares "net_allowed_hosts": ["api.example.com"]
and tries to fetch from another host, QUILL blocks the call before it
reaches the network, even if the user has granted the net
capability. Wildcard patterns such as *.example.com allow
subdomains but not the bare domain. An empty
net_allowed_hosts list with the net capability
preserves the current behavior: any host is reachable with user
consent.
QUILL 0.6.0 ships five bundled Quillins. Each is both a useful extension and a reference implementation for the framework.
com.quill.smartinsert)
provides typed abbreviations and smart triggers for bug reports, meeting
notes, log entries, to-do lists, and BRF test documents. It includes
five tabs of configurable preferences, categories writing,
productivity, and formatting, plus command
description fields on every command.com.quill.brftools)
provides preferences for braille translation, page handling, and
status-bar display. Its categories are braille and
accessibility.com.quill.journalstamp)
subscribes to document.created,
document.after_save,
document.loaded_from_session, quillin.enabled,
and settings.changed. It can insert a date header, announce
word count and daily-goal progress after save, announce restored
documents, log activation, and hot-reload preferences. Its date-format
and daily-goal controls include search_keywords. Its
categories are writing and productivity.com.quill.docguardian) subscribes to
document.before_close, document.before_save,
document.after_save, quillin.enabled,
quillin.disabled, and quill.shutdown. It can
warn on unfinished documents, stamp an Updated: line,
confirm saves with file size, announce and log activation, announce
deactivation, and clean up on shutdown. Its categories are
writing and productivity.com.quill.statusscribe)
adds a live word, character, and sentence count to the status bar. It
updates after every save and on tab switch. It demonstrates
status_bar contribution, ui.log developer
logging, quillin.enabled, quillin.disabled,
settings.changed, lifecycle events, and announcement
priority. Its categories are writing,
productivity, and accessibility.In previous releases, parts of the Quillin platform existed as declarations: events were defined, schedules were documented, preferences were validated — but the runtime never dispatched them. QUILL 0.6.0 makes the whole surface live. Five capabilities that Quillins could not use before can now be used in production, each demonstrated by at least one bundled extension.
.brf or .brl file
opens.document.opened, document.after_save,
quill.shutdown, and the rest) now actually dispatch at
runtime. Journal Stamp and Status Scribe are both live.contributes.preferences declarations now have working
settings dialogs in the Preferences hub. The renderer handles boolean,
integer, string, and choice controls; conditional
visible_when and enabled_when expressions
update controls live; and label-first Z-order throughout means JAWS and
NVDA announce the right label for every field.Braille support is not treated as an add-on or a novelty. It is designed around the way braille professionals actually work: page, line, cell, progress, translation choices, preservation of layout, and confidence that the file will not be silently changed.
“Braille users deserve tools that understand braille workflows, not tools that merely tolerate braille files.”
— Jeff Bishop
Braille Mode is not enabled by default. To turn it on:
When Braille Mode is enabled and the QUILL Braille Pack is not yet installed, a prompt appears explaining what the pack adds (translation engine, BRF export, braille display support). You can install it, skip it, or choose Disable Braille Mode if you do not need braille tools. Choosing Disable Braille Mode turns the feature off and removes the prompt permanently; you can re-enable at any time using Help > Enable Braille Mode.
QUILL can now open and edit formatted braille text files. The goal is to let a braille proofreader move through a transcription the way it is actually laid out: by braille pages, lines, cells, hard page breaks, and progress through the document.
Open a braille file the same way you open any other file. QUILL reads it as braille text and scans it for any character that is not braille ASCII. Nothing is transformed on the way in; the document reflects the file’s bytes.
Saving is byte-for-byte. QUILL does not trim trailing spaces, normalize line endings, or remove form feeds. Hard page breaks are preserved. If the text contains characters outside the braille-ASCII range, QUILL still saves them as-is and gives one non-blocking spoken warning so nothing is silently changed. A round trip of open and save returns an identical file.
While a braille file is active, the status bar includes a braille cell that updates as you move:
BRF Pg 12/87 | Ln 14/25 | Cell 31/40 | Print 7That status gives the braille page, line within the page, cell within
the line, and print page. Print-page detection arrives in a later phase;
until then the print segment reads Print ?.
Braille commands now live under Tools -> Braille. Key bindings are intentionally left unset so QUILL does not collide with screen-reader keys or existing editor shortcuts. You can assign your own bindings in the keyboard customizer or run the commands from the Command Palette.
The Braille menu is organized into three groups.
Status includes:
Navigation includes:
Moving past the first or last page tells you there is no more.
Page Tools includes:
Every braille status and navigation command is safe to run on a
non-braille document. QUILL simply says,
This is not a braille document, and does nothing else.
Forward and back translation between print text and braille require the optional QUILL Braille Pack, which can be selected during installation.
The pack uses a three-layer architecture:
When the pack is installed, the Translation submenu is organized into three sections.
UEB (Unified English Braille) includes:
Standard American English (Legacy) includes:
These use the traditional North American English tables.
More Languages is populated automatically from the pack’s profile catalog. It includes German, French, Spanish, Russian, Korean, and dozens more. Languages with both contracted and uncontracted variants appear as their own sub-group.
When the pack is absent, the Translation submenu is hidden entirely; you do not see disabled items. The Translation submenu is also hidden in Safe Mode.
Forward translation opens the BRF result in a new document and tells you how many braille pages it produced. Back-translation always opens its result as a clearly labelled draft because automatic back-translation is not authoritative. Translation runs entirely out of process, so a liblouis failure cannot take QUILL down.
Reviewing changes should not require visual scanning. Compare Mode turns file comparison into a spoken, keyboard-driven workflow with optional sound cues for fast orientation.
File comparison is now a first-class keyboard-driven workflow.
Open a comparison and move through it with:
Differences are presented as a real list, so you can review them one at a time with your screen reader.
If you use a sound pack, Compare Mode also provides distinct cues for opening a comparison, closing a comparison, stepping between differences, and bumping against the first or last difference. The result is a faster review loop: speech tells you what changed, and optional sound tells you where you are in the comparison.
When you open a source file, QUILL loads a language profile from the file extension. Recognized profiles include:
Files with unrecognized extensions use a sensible plain-text fallback.
Next Token and Previous Token, both in the Navigate menu, move the caret to the next identifier, keyword, operator, or literal. This is more predictable than ordinary word movement when reading code by ear.
Navigate -> Set Document Language lets you override the automatic choice. This is useful for unsaved buffers, unusual extensions, or snippets pasted into plain files.
Paired with indentation tones, code-aware editing lets structure come through as pitch while token movement lets you move through meaning.
QUILL can now play short non-speech audio cues, called earcons, at meaningful moments such as a file save, a successful search, or opening a comparison. The goal is to let your screen reader remain focused on text while a quick sound confirms that something happened.
Sounds come from a sound pack: either a folder or a
single .qsp file containing audio clips and a small
manifest that maps events to sounds. QUILL ships with a bundled pack
called Ink, and you can add your own.
When you press the QUILL key, Ctrl+Shift+Grave, to
arm the prefix, QUILL now plays a short two-tone ping named
quill_key_pressed. It is distinct from every other earcon,
so you receive instant audio confirmation that the prefix is live
without waiting for speech.
This earcon is included in all bundled sound packs and can be toggled individually in Tools -> Reading & Dictation -> Sound Events….
Open Tools -> Reading & Dictation -> Sound Events… to switch individual sound events on or off. Events are grouped into Earcons, Compare, and Indentation tones, so you can keep the cues you like and silence the rest.
Toggle Sound Notifications turns all sound notifications on or off at once and plays a short on or off cue so you know where you landed.
Sound is opt-in. Most earcons remain off until you choose a sound pack and enable events, so upgrading does not make your current setup noisier.
Indentation tones are also opt-in. Pick a musical scale under the Indentation tones setting, or leave it Off.
When enabled, QUILL plays a pitch that rises as your caret moves deeper into indented code and falls as you move back out. Blank lines stay silent and hold the last level, so moving through gaps does not chirp. It is a quiet ambient way to feel the shape of code without counting spaces.
New commands under Format -> HTML & Encoding make character and encoding cleanup accessible from inside QUILL.
Show Non-ASCII Characters opens a read-only report of every character beyond plain ASCII. Each entry includes:
This replaces the old command-line ritual of running a file through
tools such as iconv, inserting a sentinel string, and
hunting for what failed.
While the report is open, move to any character entry row and choose Format -> HTML & Encoding -> Jump to Source Line. QUILL switches to the source document and lands on the reported line.
Assign this command a key in the Keymap Editor for faster character-by-character review.
Jump Back to Non-ASCII Report returns focus to the report tab so you can continue reviewing the list without using the mouse.
Convert Non-ASCII to HTML Entities rewrites accented
letters and symbols as HTML entities, such as é,
or numeric entities such as é when no named entity
exists. Ordinary text and existing markup are left alone.
This is the reliable command when you need to feed text to a tool, such as Pandoc, that refuses high characters.
Re-encode As… saves a copy in the encoding you choose:
Anything that does not fit a narrow target is written as a numeric HTML entity instead of being silently replaced by a question mark. Nothing is quietly lost.
QUILL can now hand your work over as a Word document or rich text file.
Choose File -> Save As…, then select Word
Document (*.docx) or Rich Text
from the type list. QUILL converts the document on the way out, avoiding
the copy-paste-into-Word routine.
The conversion is handled through Pandoc with real Word styles. If your source has headings, those become actual Word headings, not bold text that merely looks like a heading. That keeps the exported file navigable for the next person’s screen reader.
The result reflects the structure of the source. A richly formatted Markdown or HTML document exports with that structure. A plain-text file exports as a tidy but unadorned document because there was no structure to carry. QUILL tells you that instead of quietly flattening your work.
Insert -> Insert Citation… opens a plain labelled form for creating citations.
You choose:
Then you fill in the facts you know, such as author, title, year, and related fields. QUILL handles the punctuation, ordering, formatting details, and insertion at the cursor.
The point is simple: screen-reader users should not be at a disadvantage because citation formatting is visual, finicky, and easy to get wrong.
The Snippet Gallery collects reusable, fill-in-the-blank templates contributed by Quillins into a single browseable picker. Open it from Insert > Snippet Gallery… or press QUILL key, Shift+G.
A gallery dialog opens showing every available snippet, grouped by Quillin. Select one, read the preview, and press Insert. If the snippet has parameters — a title, a date, a subject line — QUILL prompts you for each one in sequence, then inserts the completed text at your cursor.
Smart Insert ships three built-in entries:
Any Quillin can contribute gallery entries by adding a
snippet_gallery block to its manifest. No extra capability
is required.
Some contributions change a feature. Some contributions change expectations. Kelly Ford’s work on image description prompts does both by making AI image description more intentional, more flexible, and more useful to blind users.
QUILL 0.6.0 includes a Vision Prompt Library for Describe Image with AI, contributed by Kelly Ford.
Kelly independently built and evaluated twelve prompt styles drawn from his Image Description Toolkit, an experimental toolkit for accessible image interaction.
Instead of one hardcoded image-description prompt, QUILL now lets you choose from twelve IDT-evaluated styles. Each style targets a specific use case, such as:
These styles are evaluated and curated, not randomly generated.
Kelly’s Image Description Toolkit is worth bookmarking: https://github.com/kellylford/Image-Description-Toolkit.
Kelly also maintains several screen-reader-friendly applications:
Thank you, Kelly, for work that consistently puts screen-reader users first. This is exactly the kind of community contribution QUILL is built to welcome: practical, thoughtful, evaluated, and rooted in the lived experience of screen-reader users.
AI in QUILL is not meant to replace the writer. It is meant to support the writer, explain itself, respect provider choice, and keep the keyboard-first workflow intact.
“AI should help people express what they mean, not flatten their voice. The goal is confidence, clarity, and control.”
— Jeff Bishop
QUILL 0.6.0 ships a full AI writing-assistant layer. Every feature in this layer is optional, works with multiple providers, runs entirely on your terms, and is designed so screen-reader users can operate it without a mouse.
Tools > AI Hub (or AI > AI Hub…) opens a five-tab settings dialog that replaces the old single-screen AI Connection dialog.
Tools > Check Grammar with AI sends the document or selection to your configured AI and returns a structured list of grammar issues, each with the original phrasing, a suggested fix, and an explanation. A result dialog presents them as a navigable list. Apply a fix to jump to the location and insert the correction; skip any item you want to keep.
Tools > Check Spelling with AI works the same way for spelling. The AI model returns suggestions with context, making it useful for technical documents where a traditional word-list checker produces false positives.
Both checkers fall back gracefully: if AI is not configured, QUILL uses the built-in lexical spell checker.
Four agentic writing tasks operate on your document text and return results through a shared result dialog.
All four commands open a two-part result dialog: a step log at the top (showing what the agent did and any intermediate output) and the final output in a large read-only text area below. From the dialog you can insert the output at the cursor, replace the selection, copy to the clipboard, or re-run the task. Every agent run starts on a background thread; a stop event lets you cancel between steps.
Shift+F8 opens the AI Thesaurus. Type a word or use the word already under your cursor; the dialog sends the word and its surrounding sentence to your AI provider and returns a list of synonyms, each with a usage note explaining the register, connotation, or context. Arrow through the list, press Enter or the Replace Word button to substitute the word in your document, or copy a synonym to the clipboard. Double-clicking a synonym replaces it immediately and closes the dialog.
The context sentence is extracted automatically from the line where your cursor rests, giving the AI enough context to distinguish between, for example, “bank” (financial) and “bank” (river).
AI > Document Q&A opens a multi-turn question-and-answer session grounded in your open document. Ask questions; QUILL sends the document text and your question to the AI and streams an answer into the conversation pane. The pane is a screen-reader-navigable document: each question and answer is a separate section you can jump to by heading. Continue asking follow-up questions; the session retains context for the duration of the dialog.
Document Q&A works on any document up to approximately 80,000 tokens. For longer documents, QUILL trims from the middle to keep the beginning and end within the model’s context window.
AI > Translate Document or AI > Translate Selection sends the text to your configured AI and returns a translation into a language you choose. A picker shows the available target languages; the list adjusts based on your provider. The translated text arrives in a result dialog from which you can insert it, replace the selection, or copy it. On-device translation through LibreTranslate is also available when no cloud AI is configured.
Tools > Read Aloud > Read with AI Voice sends the selected text to the OpenAI TTS API and plays the audio through the system audio output. Choose from six voices in AI > AI Hub > Audio Services. The playback can be stopped at any time. You can also export to an MP3 file from the Read Aloud menu for offline listening.
The Instructions tab of AI Hub has two sub-tabs: Writing Tasks and Image Styles.
Writing Tasks lets you replace or supplement the built-in system prompt for any of QUILL’s twelve AI writing tasks. Every task ships with a carefully written default; you can edit the user prompt to change tone, language, output format, or any other behaviour. The twelve tasks are: Chat, Spell Check, Grammar Check, Rewrite, Summarize, Expand, Table of Contents, Translate, Thesaurus, Document Q&A, Research, and Accessibility Agent.
Image Styles lets you edit the prompt text for any of Kelly Ford’s twelve built-in image description styles. The original shipped prompt is shown read-only below the editor so you always have a reference. Enable or disable individual styles from this same tab.
Your customisations are stored in
%APPDATA%\Quill\ai_custom_instructions.json. The file
stores only the fields you have changed; the built-in defaults always
live in the application code. This means that when QUILL updates a
default in a future release, you automatically pick up the improved
version unless you have already customised that task.
To share a custom instruction set, copy the JSON file to another machine or user account.
To reset a single writing task or image style to its default, select it and press Reset to Default. Your override is cleared; the shipped default takes effect immediately.
Custom instructions are sent as a separate system message, not merged into the document text. This lets AI providers cache the stable instruction prefix across requests so you are not billed for re-sending the same text on every call.
cache_control: ephemeral and sends the
anthropic-beta: prompt-caching-2024-07-31 header. Claude
caches the prefix for five minutes at approximately 10% of the normal
input token rate.systemInstruction field.No configuration is needed. The caching path is active whenever at least one custom instruction is enabled.
| Command | Shortcut |
|---|---|
| Ask Quill chat | Alt+Q |
| AI Thesaurus | Shift+F8 |
| Check Grammar with AI | Tools > Check Grammar with AI |
| Check Spelling with AI | Tools > Check Spelling with AI |
| Rewrite Selection | AI > Rewrite Selection |
| Summarize Selection | AI > Summarize Selection |
| Expand Selection | AI > Expand Selection |
| Generate Table of Contents | AI > Generate Table of Contents |
| Document Q&A | AI > Document Q&A |
| Translate | AI > Translate |
| Read with AI Voice | Tools > Read Aloud > Read with AI Voice |
| AI Hub | AI > AI Hub… |
Every AI feature that sends text to a cloud provider shows this in the consent text you agreed to at setup. The full table is in the user guide under AI Privacy Reference. In summary:
If you prefer not to send document content to a cloud provider, use Ollama on-device and a local Deepgram alternative for transcription.
The keyboard reference is no longer a static document. It is generated live from the active command registry and your current feature profile.
The reference now:
Not every contribution becomes a giant headline. Some become the small improvements that make the editor feel more thoughtful every day. This section collects those practical additions.
QUILL 0.6.0 also includes these practical additions:
From the QUILL key, press F to speak the window title, P to speak the full file path, or Q to speak a short status summary without leaving the editor.
Ctrl+Tab switches to the next document, and Ctrl+Shift+Tab switches back. Ctrl+Shift+F4 closes all other open documents and keeps just the current one. The Window menu lists every open document by number directly on the menu - no submenu. Press Alt+W then a number key to jump straight to that document. The active document is marked. The list updates when files open or close, and renames itself immediately when you save an untitled document.
Open and Save As now start in your Documents folder.
You can set your own default startup folder in Preferences, so QUILL no longer drops you into the install directory.
--goto FILE:LINE:COL opens a file at a specific
position from one argument, which is useful when a linter or search
result provides a file:line:column string.
--diff LEFT RIGHT opens two files directly into
Compare Mode.
Help -> Report a Bug… now opens focused on the Summary field, remembers your name and email after the first entry, and asks which screen reader you use. QUILL preselects the screen reader it detects so the team can reproduce reader-specific issues.
Feature search now finds copy tray, macros, and abbreviations.
The Open dialog includes more file types, including common developer extensions such as Kotlin, TypeScript, Go, Rust, and more.
HEIC and HEIF images are now supported for AI image description.
The About screen now credits every GitHub contributor, including new project owner Kelly Ford and design contributor Ken Perry.
A community project gets stronger when people report the rough edges and the team treats those reports as product-shaping feedback. These fixes matter because they remove friction from real daily use.
This release fixes a group of problems that directly affected accessibility, startup reliability, image description, reporting, and platform setup.
Under NVDA, the bug-report fields were refusing keyboard input. The dialog has been rebuilt so every field is editable. It also moved to the Help menu, where users expect support-related commands.
Submitting a report no longer freezes the app while contacting the server. That work now happens in the background with a timeout. The impact is simple: reporting a problem is no longer itself a problem.
In previous builds, tabbing through General Preferences with JAWS
announced combo box and spin field values but not their labels. The
cause was Z-order: on Windows, JAWS finds the accessible name for a
combo box or text field by looking backward through the parent window’s
child list for the nearest StaticText. Child windows are
ordered by creation time, and the code was creating controls before
calling a helper that internally creates the StaticText
label — so the label ended up after the control in Z-order and JAWS
could not find it.
The fix is applied throughout General Preferences, the Profiles and
Features dialog, the AI Model dialog, and the new Quillin preferences
renderer. Every labeled control is now created inside a factory function
that runs after the label is created. wx.CheckBox and
wx.Button are exempt because they carry their own label
text. Six gating tests in
tests/unit/ui/test_dialog_label_ordering.py lock in the
correct creation order so this class of regression cannot reappear
silently.
JAWS no longer says stray phrases such as
splitter window and panel when menus close or
the app receives focus. The invisible layout container is no longer
exposed to the screen reader, so focus changes are cleaner and
quieter.
A small internal error was silently stopping Describe Image with AI from running. The feature now completes as intended, restoring an accessibility feature blind users rely on.
Screen-reader detection now runs in the background instead of
stalling the first window. A preview warm-up crash is fixed. The title
bar no longer flashes untitled Quill unavailable before the
app is ready. The preview pane no longer hangs for minutes with no way
to close it.
The first window now comes to the foreground so the trust and privacy dialog is reachable. If you skipped the personalization wizard, you can re-open it later. The wizard’s startup beep and Cancel-button focus are fixed.
Two setup wizard issues are fixed:
The user guide now opens as a read-only page in your browser instead
of as an editable Markdown document you could accidentally change. A
stray edit can no longer trigger a 0x8007139f browser
error. A glossary of QUILL terms has also been added to the guide.
The QUILL Braille Pack, which provides braille translation, BRF and BRL export, and liblouis integration, is an optional installer component. Some 0.5.0 users may miss it during upgrade.
On first launch of 0.6.0, QUILL now detects when the pack is absent and offers to run the installer again so you can add it without re-downloading. It uses the copy already in your updates folder. Choose Not Now and the prompt goes away permanently. You can still add the pack later by re-running the installer and checking the Braille Pack component.
If you previously used Skip this update,
Notification Center was silently reporting no newer version
instead of reminding you that a skipped update was still waiting. That
is fixed.
Saving an Ask Quill API key on macOS used to crash. Keys and tokens are now stored in the login Keychain, so you set them up once and on-device or cloud AI continues to work.
The notarized macOS build now signs its bundled image libraries and uses hardened-runtime entitlements, so the app installs without security warnings.
Most habits carry forward, but a few items moved or changed so QUILL can stay cleaner, more discoverable, and easier to grow.
The top-level Braille menu is gone. All braille commands now live under Tools -> Braille, including status, navigation, page tools, and translation. The commands are still present; they simply live alongside the other authoring tools.
The old flat list of UEB items has been replaced with a structured menu:
If you used to reach a translation item by position, check the new structure the first time you open it.
The Braille menu no longer includes Install Braille Pack. The pack is now selected during the QUILL installer. Check the Braille Pack component in the installer if you want translation. Once installed, the Translation submenu appears automatically.
Report a Bug now sits immediately before Check for Updates in the Help menu, matching where most people look for support and maintenance items.
The older Encode HTML Entities command still escapes
only the five markup characters: <, >,
&, ", and '.
The new Convert Non-ASCII to HTML Entities command handles accents and symbols. If you previously reached for the old command expecting it to fix accented text for Pandoc, use the new command instead.
The old flat Date and Time and Calculated Date… items have been replaced by one Insert -> Date and Time submenu.
That submenu includes:
The bundled com.quill.bundled.insert-tools Quillin owns
this submenu. It is now the canonical home for date and time snippets
and is the model for migrating other built-in conveniences into
Quillins.
Most earcons are off until you choose a sound pack and enable events. Existing setups should not get noisier on upgrade. Turn sound on from Preferences -> Sound and Tools -> Reading & Dictation -> Sound Events….
Indentation tones do not play until you pick a scale. Code files remain silent unless you ask QUILL for tone feedback.
QUILL 0.6.0 is more than a list of features. It is proof that accessible software can be joyful, powerful, careful, and community-shaped at the same time.
“We are building something free, cross-platform, assistive-technology friendly, and community-driven. Wait until you see what contributions are coming next.”
— Jeff Bishop
QUILL 0.6.0 is more than a feature release. It is a statement about what an accessible editor can be when screen-reader users are treated as the primary audience, not an afterthought.
This release brings practical power to everyday writing through Insert Automation, typed abbreviations, smart triggers, log mode, citations, Word and RTF export, and better encoding tools. It brings confidence to specialized work through Braille Mode, the optional QUILL Braille Pack, professional translation workflows, page-aware BRF navigation, and status information that speaks the way braille readers actually work. It brings speed to review and development through compare mode, code-aware navigation, indentation tones, dynamic keyboard documentation, and command-line launch options for precise workflows.
Underneath those visible improvements, the new Quillin platform gives QUILL a foundation for growth: accessible preferences, document lifecycle events, status bar contributions, settings search, dependency checks, network safeguards, developer logging, bundled reference Quillins, and strict user control over what extensions can do.
Just as important, 0.6.0 fixes the kinds of issues that matter deeply in daily use: bug reporting now accepts typing, JAWS announcements are quieter, Describe Image works again, startup is faster, first-run dialogs are reachable, the user guide opens safely, update notifications are more reliable, and macOS builds install and store keys correctly.
The result is a release that feels faster, quieter, more predictable, and more empowering. QUILL 0.6.0 gives writers, braille users, developers, students, accessibility professionals, and screen-reader users of every kind a stronger place to work — one built around keyboard control, spoken feedback, user choice, and the belief that accessible software can also be powerful, elegant, and joyful to use.
And this is only the beginning. To everyone testing, contributing code, suggesting workflows, challenging the design, sharing feedback, building community, and cheering QUILL on: thank you. The product is better because of you. The next contributions are already raising the bar.