There's a repo up as of tonight: accessible-user-reading-assistant. It's a screen reader for Windows called AURA — Accessible User Reading Assistant — and it's free, open source, and very much not finished. I want to talk about why I'm building it, what it does, what it absolutely does not do yet, and what this past week actually looked like.

Fair warning up front: this is a project in its infancy. If you go download it expecting to replace what you use every day, you're going to have a bad time. But I think it's worth explaining what I'm aiming at, because I don't think it's a small thing.

Why bother? NVDA exists.

It does, and I want to be careful here, because NVDA deserves better than being used as a punching bag by somebody with a half-built alternative.

NVDA has been the backbone of blind computing for twenty years. It's free. It's open source. It arrived at a time when the alternative was a screen reader that cost more than the computer you ran it on, and it broke that stranglehold more or less single-handedly. There are people with careers — including me, in ways — who have them because NVDA existed and didn't cost a thousand dollars. That's not nothing. That's one of the genuinely great pieces of software of the last two decades, and the people who built it did something that mattered.

And it's tired.

If you use it all day, you know what I mean. It crashes. It gets stuck. You alt-tab between two windows and it tells you about the one you left, or it tells you nothing at all, and you sit there tabbing back and forth trying to jostle it into noticing where you actually are. It freezes when some application decides to stop responding and takes your ears with it. You restart it a few times a day and you've stopped thinking of that as unusual.

None of that is because anybody did a bad job. It's because NVDA was designed in 2006, for a version of Windows that no longer exists, and it has spent twenty years accumulating support for every technology that came and went in between. There's code in there for Flash. For Silverlight. For the ancient accessibility system that Windows used before the current one, and the current one, and the bridges between them. Every one of those was the right call at the time. Together they're a weight, and you can hear it.

You can't refactor your way out of twenty years of foundations. Believe me, I understand why nobody has.

So AURA is the other option: start over, on a modern foundation, and try to be honest about it. It used to be called OpenReader, which was a fine name that told you nothing. AURA is written in C# on .NET 10, and it's built around the one accessibility system Windows actually uses now instead of trying to speak four of them at once. The goal is a screen reader that's fast, lean, doesn't fall over, and — this part matters to me — has room for the community to extend it, the way NVDA's add-on ecosystem lets people build the thing they personally need.

It's free and it's GPL-3.0, same spirit as NVDA. A screen reader that people depend on to use a computer should not be something anyone can take away from them. That was never up for debate.

What it can actually do right now

It talks. That sounds like a low bar but it's most of the job.

It tells you what you've focused — buttons, checkboxes, list items, menu items, tree items, the works, with their state and their position ("3 of 42", which turns out to be harder than it sounds — more on that later). It reads text properly, by line, word, and character, with a review cursor you can move around a document independently of your typing cursor. It'll read a whole document start to finish. It echoes what you type, or what you delete, or completed words, depending on what you find useful.

You get two voices out of the box: the Windows SAPI 5 voices you already have, and eSpeak NG if you install it. You can change synthesizer, voice, rate, pitch, and volume, and — as of this week — you hear the change as you make it, rather than having to commit to a voice by pressing OK and then reopening the dialog to find out you hate it.

Two things I'm genuinely proud of. First, you can rewrite what it says without writing any code. How AURA describes a checkbox, or a menu item, or a slider is defined in a plain text file you can edit. Want it to stop saying "list item" every single time? There's a setting for that now. Want it to describe something in your own words entirely? Edit the file. NVDA users have asked for that for years and can't have it, because it's not something you can bolt on afterwards.

Second, there's a real plugin system already, with a proper versioned contract and a project template, so somebody who wants to write an extension for a specific application can. That exists before version 1.0 on purpose, because an ecosystem you add later is an ecosystem that breaks every time you update.

Beyond that: remap any key to anything, adjust how chatty it is, cycle punctuation levels, an installer, and a portable copy that doesn't need installing.

What it can't do, stated plainly

I'd rather you hear this from me than find out.

  • No web browsing. There's no browse mode, so reading an actual web page is not a thing you can do yet. This is the big one and I know it.
  • The Windows console and PowerShell don't work. Terminal work is out.
  • No braille. Not a single display driver. The design accounts for it and none of it is written.
  • Elevated windows swallow it. Anything running as administrator — including Task Manager — won't get your keystrokes to AURA. Fixing that needs a code-signing certificate from a real certificate authority, which is money and weeks of waiting, and I haven't started it. That's on me and it's next.
  • No OCR, no math, no table navigation, no add-on store.

And the big one: nobody has used this for real work. Not one person, not for one day. If you try it, keep NVDA or Narrator running, and know how to get back to it. If AURA goes quiet you need a way out that doesn't depend on AURA.

What this week actually looked like

Here's the part I found genuinely humbling.

About thirty commits went in over the last ten days or so. Most of them came from one activity: I stopped reading code and started listening to it.

The tests were green. Four hundred and twenty of them, all passing, zero warnings, and I felt pretty good. Then I ran the thing on real hardware and put my headphones on, and inside of a day I'd found thirteen bugs. Every single one was obvious within about five seconds of hearing it. Not one of them had been caught by a test.

Some highlights:

Lists were completely silent. Not wrong — silent. Arrow through a list box, hear nothing. The cause was almost philosophical: when you arrow through a list, the keyboard focus doesn't move. It stays on the list; the selection moves. AURA was checking "is this thing I'm about to announce still the focused item?", the answer was always no, and it threw away every single announcement before speaking it. It was working exactly as designed, and the design was wrong.

Delete did nothing at all. Ever. The key was being caught by the code that announces key names before the code that announces deletions could ever see it. That deletion code had been sitting there, unreachable, for who knows how long.

Backspace only worked on text you'd just typed. Which is not most deleting. Most deleting is arrowing into something you wrote earlier and taking a chunk out.

Fixing those two taught me something I liked. Backspace and Delete want opposite answers, and it's not arbitrary. Backspace moves your cursor away from what it removed, so the only useful thing to say is what you just lost. Delete leaves your cursor exactly where it is and drags the rest of the line back underneath it — so what you need is what's there now. The character that just vanished tells you nothing about where you are. Two keys that look symmetric, aren't, and getting that right is the difference between a reader that's useful when you're editing and one that's noise.

The desktop wouldn't tell you how many icons there were. The settings list would say "2 of 7" and the desktop would say nothing, which reads as arbitrary and broken. It isn't — modern apps publish that number and the desktop is old enough that it doesn't. So AURA counts them itself now.

The volume and pitch sliders announced themselves as "RatePercent", "PitchDelta" and "VolumeDelta" — the internal variable names, read aloud, to a user. That's where the mysterious "delta" was coming from. They say Rate, Pitch and Volume now, like the labels on the screen have always said.

Ctrl+Space did nothing in a multi-select list — the one keystroke whose entire job is to change the selection, silent.

There's a pattern in there that I keep thinking about. Four of the bugs were code that looks live and does nothing — a field with a long comment explaining exactly why it existed, that nothing ever filled in; a safety check protecting against a case that never got passed to it; a setting nobody could reach. That stuff reads as working when you look at it. It only fails when you listen.

Then tonight I put the repo up: cleaned house, wrote the license, brought every document in line with what the code actually does, and fixed a build system that — it turns out — had never once successfully run. It was pointed at a folder that stopped existing months ago, so every automated check silently did nothing. The absence of a red light was jobs that never started.

And the first successful run told me the real story: the entire Windows-facing layer of AURA — the part that talks to applications, the part where every single one of this week's bugs lived — has essentially no automated tests at all. There's one test named for the most important piece of it that has been switched off since the very beginning and stayed switched off while the code underneath it got rewritten twice.

So that's not a mystery anymore. That layer is where the bugs are because it's the layer nothing was checking.

What's next

Short version: a certificate, so elevated windows work. Then the ability to read a web page, which is the single biggest gap. Then object navigation — the ability to poke around a window and inspect things that aren't focused, which is one of the first things anyone switching from NVDA will reach for and not find. Braille, OCR, audio themes, and auto-updates are all on the list behind those.

And more listening sessions, because they have a better track record than anything else I've tried.

If you want to follow along

Everything's at github.com/churst90/accessible-user-reading-assistant, including a genuinely honest scoreboard of what works, what doesn't, and what I've decided to never build.

If you do try it — and please keep another screen reader running — the most useful thing you can send me is what you heard. Not a crash log. "Arrowing across the desktop said the tooltip instead of the icon name" has fixed more bugs in this project than any stack trace ever has. There's a keystroke, Ctrl+Insert+D, that copies a diagnostic snapshot to your clipboard for bug reports, and it deliberately contains nothing about what was on your screen or what was read aloud. A screen reader reads your bank balance and your passwords out loud. None of that belongs in a bug report.

It'll be a while before this is anybody's daily driver. But it speaks, it's getting less wrong every week, and it's being built by someone who has to use the result.

More soon.

The other two things I build

AURA is the newest of three, and they all come from the same place — software I needed and couldn't buy:

  • Accessible Trade Terminal — a full trading and charting platform you run by keyboard and ear, with the chart itself turned into sound. Free browser demo, no install.
  • Accessible Weather Center — The Weather Channel's old local forecast systems, recreated so that every screen, including the radar, is something you can hear.