Voqora: A Native Mac App for Turning Reading Into Listening
Most information work still assumes that your eyes should do all the work.
That is fine until it is not. You have a long article open between meetings. A dense paper needs one more pass. You are rewriting something important and want to hear whether it actually sounds clear. A PDF needs to come with you when you leave the desk. The text is already there, but the useful moment to read it is not always the moment you can stare at a screen.
Voqora is a native macOS app that turns the text you are already reading into speech. Select text, press a shortcut, and listen. For longer material, add a document and turn it into a resumable audiobook.
It is a focused Mac app built around one transition: from reading to listening, without losing your place or your momentum. No account, no browser tab, no separate service to sign into.
Visit Voqora on GitHub View Voqora releases
Voqora in one minute
There are two core ways to use it.
| If you need to… | Voqora lets you… |
|---|---|
| Get through a paragraph, article, email, brief, or draft | Select it in the app you are already using and have it read aloud. |
| Keep moving through a long document | Add it as an audiobook, listen in pieces, and resume later. |
| Review your own writing | Hear the exact words back before sending them. |
| Keep a useful clip | Export the latest spoken selection as a WAV file. |
The selected-text flow is short by design:
No copying text into another tab. No opening a dashboard. No account required to make the app speak.
Architecture: one Mac, one local speech path
The product has a deliberately small shape. Voqora is a native SwiftUI macOS app. A bundled local speech server does the neural synthesis. Native audio playback receives a WAV stream as it is generated. The app owns the state that matters to a reading workflow: the current playback session, local history, audiobook progress, preferences, and the narrow first-use permission path.
| Layer | Choice | Why it exists |
|---|---|---|
| Desktop UI | SwiftUI with targeted AppKit integration | Native windows, Preferences, menu bar controls, and the macOS Accessibility APIs. |
| Speech engine | Bundled local process on 127.0.0.1 | Selected text is spoken without sending it to a hosted text-to-speech API. |
| Local-service access | Loopback binding plus a check that only accepts requests from Voqora's own app process | The speech service answers Voqora and nothing else — a page open in a browser cannot reach it. |
| Audio | Streaming WAV into native playback | Start listening before an entire passage is rendered. |
| Persistence | Local app-support files and preferences | History, voice settings, audiobook state, and progress survive a restart. |
| Optional external work | Gemini cleanup only when a user supplies a key and chooses it | Keeps the ordinary reading path local and makes the boundary explicit. |
| Product measurement | Small anonymous event outbox plus optional email identity | Understand real use without collecting selected text, document content, audio, filenames, or API keys. |
When the shortcut is pressed, there is one clear route from the selected words to sound, and a clear explanation when macOS has not yet given the app the permission it needs.
Design decisions and tradeoffs
Speech runs on your Mac
A remote text-to-speech API is easy to call. It also turns every highlighted paragraph into a network request and makes reliability depend on a service outside the Mac.
Voqora instead carries a local speech engine in the application bundle. First launch extracts that engine once into Voqora's own application-support folder. Later launches use a version marker to skip that setup. The normal reading action needs no login, no character quota, and no internet connection after installation. The tradeoff is a larger initial download, and a launch focused on Apple silicon.
One voice, one shortcut, one obvious job
The default experience has one voice, Bella; one shortcut, Command + Shift + .; and one obvious job. Voice, speed, volume, theme, and shortcuts remain
available for people who want them, without getting in the way of the first
spoken sentence.
A utility has a small attention budget. The first action needs to be simple enough that a new person can use it without configuring anything first.
Accessibility permission comes first, with a real recovery path
Reading selected text from another application needs macOS Accessibility access. Voqora leads with the permission in onboarding, opens the relevant System Settings pane on request, polls the result when the user returns, and keeps an in-context recovery banner available afterwards. Notification permission and optional identity are not treated as requirements — the core action has one necessary setup step, clearly explained.
When an app does not expose its own text selection through Accessibility — Terminal, VS Code, most Electron apps — Voqora reads the clipboard instead and restores whatever was there immediately afterward. Your last real copy is preserved either way.
Product metrics measure four different things
Download clicks, reported anonymous installations, activity events, and voluntarily provided email contacts are four different quantities. Voqora keeps them separate. A durable anonymous identifier counts an installation without requiring an account. Event IDs make retrying a failed network delivery safe. An optional email helps recognize a returning person across installs, and can be removed from both the Mac and the product backend at any time.
The speech service only answers Voqora
The local speech service binds to 127.0.0.1, and a check on every request accepts only traffic from Voqora's own native networking layer — a webpage open in a browser cannot reach it, even from the same Mac. Binding to loopback keeps other machines out; the Origin check keeps other processes on the same machine out too. Together they mean the speech engine only ever hears from the app that owns it.
The everyday product
Text-to-speech can sound like a niche accessibility feature until you use it as a working habit. Then it becomes a different way to move through information.
Here are the moments Voqora is built for:
- Before a meeting: listen to a briefing document while you get ready instead of trying to skim every line at your desk.
- During research: use your eyes for figures, equations, and citations; use your ears for the surrounding explanation.
- While writing: hear a draft out loud. Repetition, missing words, and clumsy sentences become obvious much faster.
- When your eyes are tired: keep going through an article or note without forcing another hour of screen time.
- When a document is too long for one sitting: make it an audiobook, stop whenever you need to, and continue from the same place later.
Reading and listening serve different moments. Voqora gives you the second mode without asking you to give up the first.
A shortcut that stays out of your way
Voqora lives alongside the apps you already use: your browser, Notes, a PDF reader, a writing app, an IDE, or a document editor.
Select text and use the default shortcut:
| Action | Default shortcut |
|---|---|
| Speak selected text | Command + Shift + . |
| Play / pause | Command + Shift + / |
| Stop | Command + Shift + , |
| Export the latest clip | Command + Shift + M |
All of these can be remapped in Preferences. The initial voice is Bella. The public release includes eight English voices: four American and four British. Set voice, speed, and volume once, and the app stays predictable from there.
Long documents, in manageable pieces
The selected-text shortcut is for the next paragraph. Audiobooks are for the things that keep getting postponed: a research paper, course pack, report, proposal, handbook, or long-form essay.
In Voqora, a PDF, TXT, DOCX, or Markdown file becomes something you can listen to in pieces. The app keeps the audiobook state locally, including your progress, so closing the app does not turn the next session into a search for the last paragraph you heard.
The workflow:
- Add a PDF, TXT, DOCX, or Markdown file to the audiobook library.
- Let Voqora extract the text and prepare narration.
- Listen when it makes sense for you.
- Return later and continue from your saved position.
Most text-based documents are handled locally. For a scanned PDF or a poorly extracted file, Voqora offers an optional Gemini-based cleanup path. You provide your own API key and choose that operation. The relevant document material is sent to Gemini only for that requested cleanup — it is not part of normal selected-text speech, and it is not required to use Voqora.
Local speech is a product choice
The core speech path runs through a bundled local engine on Apple-silicon Macs. Selecting text and asking Voqora to speak it never requires sending that text to a cloud service.
| What stays simple | Why it matters |
|---|---|
| No account needed for the core feature | You can start using the product without creating another identity. |
| No per-character speech bill | Reading a long document does not turn into a metered cloud request. |
| Your selected text stays on the Mac for normal speech | A quick reading action does not require uploading the content. |
Local-first is the default flow people use hundreds of times: select text, press a shortcut, listen.
What fast means in a reading tool
For this kind of product, "fast" means pressing the shortcut feels like a direct action rather than a request you wait around for.
Voqora streams generated audio into native playback, so listening can begin before a full passage has become a finished audio file. Underneath that, the ONNX speech model stays warm ahead of time rather than loading fresh on demand: Voqora watches for the system clipboard changing and for the app coming to the foreground, and pre-loads the model on either signal. Neither signal reads what was copied — only that a change happened, and only when the new item is declared as text. Once the model is warm, further copies are free no-ops until the backend's own idle timeout eventually unloads it.
The path from a shortcut to sound
The product looks simple because the visible action should be simple. Under the hood, Voqora coordinates several parts of macOS and the local speech engine to behave like one interaction.
When the shortcut is used, Voqora asks macOS for the text currently selected in the foreground app. That is why Accessibility access is part of first-use setup — it lets the app work with a selection in a browser, document editor, PDF reader, notes app, or IDE without asking you to paste the text into another interface. For apps that keep their selection outside the standard Accessibility path, a clipboard fallback reads it directly and restores your previous clipboard content immediately after.
The text then moves through a small local pipeline:
Both the selected-text shortcut and the audiobook narration paths read a document's prose, not its markup — headings, emphasis, links, and table syntax in a Markdown file become natural spoken sentences instead of literal punctuation.
Audio is streamed into playback as it is made, so a full paragraph does not need to finish generating before you can start listening. A new selection interrupts the one before it, since the next thing you chose to read should win. Playback controls, the menu bar, the main window, and the global shortcuts all operate on the same audio state.
Building a local engine into an installable Mac app
The speech model is not a hosted API behind a button. Voqora packages a local server with the macOS app, extracts it into its own application-support directory on first use, and keeps a small version marker so a normal reopen skips that setup. The server listens only on the Mac's loopback address, so other devices on the network cannot turn it into an open text-to-speech endpoint.
The installer contains the app, the local engine, fonts, licenses, and a single drag-to-Applications path. The updater is built around a signed update feed, ready for the notarized release channel: an update is only ever offered once its signature and byte length have been checked against the exact DMG being published. Today, Check for Updates checks Voqora's public release feed and opens a verified, signature-checked DMG for you to install — no automatic replacement of the running app.
The failure states are part of the feature
The less visible work in a desktop utility is deciding what happens when the happy path is not yet available. A shortcut may be pressed before a selection exists. macOS may not have granted Accessibility access. The local engine may still be starting up. A PDF may be scanned or simply not contain usable text.
Voqora treats each of these as a named state rather than a blank player or a frozen control: the interface explains when it needs a selection, when it needs a permission, when the engine is starting, and when a document needs a different route. Playback work is tied to the request that created it, so an older result never overrides a newer choice.
Audiobooks, built for long documents
Speaking a paragraph and working through a ninety-page document call for different handling. The audiobook flow has its own library, progress tracking, resume state, and recovery language, built around what a long document actually needs rather than treating a PDF as one large text field.
Before a long document is processed, Voqora shows what it found and what happens next. Text-based documents go through the normal local route; a scanned or poorly extracted document can use the optional Gemini cleanup path instead. The player itself keeps Transcript and Sections as two tabs of a single panel that always fills the available window space, so the layout holds up whether the window is narrow, tall, or wide.
The details that make it usable every day
Good speech is only the first layer. A product you return to needs to preserve context and make routine actions easy.
Voqora includes:
- Local history for passages you have spoken before.
- WAV export for the latest clip when you want to keep or share the audio.
- Play, pause, and stop controls that work without forcing you back into the main window.
- Voice, speed, and volume preferences so the product can sound like yours.
- A document-to-audiobook library with locally saved progress and resume support.
- System notifications for an audiobook finishing processing, speech starting, and an available update — each optional, off by default, and toggled independently in Preferences.
- Plain-language first-use guidance for the macOS permissions that enable global shortcuts and accessibility features.
Why a native Mac app
The harder engineering problem was never making text into audio. It was fitting that action into a real Mac workflow: responding to a global shortcut, working with selected text from another app, keeping playback responsive, remembering local state, and giving the user a normal installer and update path.
Voqora is built as a native macOS application so the experience feels at home on the machine where the reading already happens — native controls, native playback, local files, and a familiar install flow.
The current public release supports Apple-silicon Macs running macOS 14 or later, a focused launch platform for a reliable first release.
A release is part of the product
For a Mac app, a build that runs on one machine is not a release standard. The public product needs a clear installer, first-launch instructions, readable release notes, and a way to receive updates without learning the project's internals.
If macOS shows a security warning on a downloaded build, the release notes explain the normal right-click Open route, with a narrowly scoped command for the installed app when needed — a predictable path from download to first spoken sentence.
Voqora is at v1.1.3, backed by roughly 400 tests across the Swift app and the Python backend combined. The repository keeps release notes, installer guidance, source, and license together in one place.
Who Voqora is for
Voqora is for people who read a lot on a Mac and want listening to be a first-class option. It is a focused desktop tool: turn reading time into listening time, on your own terms, without giving up control of the text, files, or workflow around it.
The direction is straightforward — make the Apple-silicon Mac experience genuinely useful, and improve it in step with how people actually use it.
Voqora links
Voqora is available now for Apple-silicon Macs running macOS 14 or later.
Visit Voqora on GitHub View Voqora releases
The GitHub project contains the source and documentation. The releases page contains the current DMG and install notes.
The source is available under the PolyForm Noncommercial license. You can study, modify, and share it for non-commercial purposes. Commercial use requires a separate agreement.
The most useful feedback is specific: what did you try to listen to, where did the workflow help, where did it break, and what would make you open Voqora again tomorrow?