VoiceInk

VoiceInk is a menu-bar dictation app for macOS. You hold a global shortcut, speak, and the text lands at your cursor a moment after you release it. Transcription runs on the machine by default, through a whisper.cpp framework the build script compiles for Apple silicon, with Parakeet models via FluidAudio and GGUF models via transcribe.cpp as alternatives. If you would rather trade privacy for speed or accuracy on a particular job, the same pipeline will send the audio to Groq, Deepgram, ElevenLabs, AssemblyAI, Mistral, Gemini, Soniox, Speechmatics, Cartesia, xAI or any OpenAI-compatible endpoint using your own API key.

What separates it from a plain speech-to-text utility is the stage after the transcript. VoiceInk runs an optional enhancement pass that rewrites raw ASR output into clean prose: it removes stutters and abandoned false starts, resolves spoken self-corrections, applies dictated punctuation cues, normalises numbers, dates and currencies, and formats spoken enumerations as lists. That pass can go to a cloud model, to a local Ollama server, or to VoiceInk Refine, an MLX language model that runs in a separate XPC process on Apple silicon so the whole round trip stays offline.

Modes tie the two halves together. A mode is a saved profile — transcription model, AI prompt, output behaviour, dictionary scope — that activates when a specific application or website has focus, so dictating into a terminal, a code editor and an email client each produce differently shaped text without touching a settings panel. The app can also capture the focused window with ScreenCaptureKit and run Vision OCR over it, handing the enhancement model the vocabulary that is on screen at that moment.

The project is open source and buildable from an Xcode checkout, while the developer sells one-time lifetime licences for a notarised, auto-updating build. It runs on macOS 15 or later, keeps its transcription history and personal dictionary in local SwiftData stores, and includes retention controls that delete recorded audio and past transcriptions on a schedule.

What You Get

• A menu-bar dictation flow driven by configurable keyboard or mouse shortcuts, including push-to-talk
• Local speech recognition through whisper.cpp, FluidAudio Parakeet models and GGUF models, with model downloads managed in-app
• An AI cleanup stage with a detailed transcript-editing prompt, pointed at a cloud provider, a local Ollama server, or the built-in MLX engine
• Per-application and per-URL modes that swap the transcription model, prompt and output behaviour as you move between apps
• A personal dictionary of vocabulary terms and word replacements that feeds both local prompting and cloud custom-vocabulary fields
• Searchable transcription history with usage statistics, plus scheduled deletion of audio files and past transcriptions
• Audio and video file import for transcribing recordings you already have
• A voice assistant mode that answers in the recorder panel instead of pasting

Common Use Cases

• Drafting long-form writing by voice - writers and researchers dictate paragraphs into a note or document app and let the enhancement pass handle punctuation, paragraph breaks and self-corrections
• Dictating in a terminal or code editor - developers set up a mode whose prompt keeps filenames, flags and identifiers intact instead of prose-formatting them
• Replying to messages and email hands-free - a per-app mode produces short, correctly punctuated replies in a chat or mail client and can send after paste
• Handling confidential material - clinicians, lawyers and anyone under a data policy run the local model chain so audio and transcripts never leave the Mac
• Transcribing existing recordings - importing an interview or meeting file runs it through the same model and cleanup pipeline as live dictation
• Working with domain jargon - a personal dictionary of product names and technical terms keeps the recogniser from mangling them, and AutoLearn adds new entries from the corrections you type yourself

Under The Hood

Architecture The app is a SwiftUI document-less scene with a strict separation between feature modules, infrastructure services and a small core of shared types. Dependencies are wired by hand in the app entry point rather than by a container: model managers, the enhancement service, the recording engine and the UI coordinator are constructed in order, handed to each other explicitly, and published into the environment. Recording and transcription are modelled as a session abstraction with two implementations — a file-based one that uploads after the recording stops, and a streaming one that opens a socket, emits partial transcripts, and silently falls back to the file path if the connection fails or the provider asks for a batch pass. Everything after the transcript is a linear pipeline: transcribe, filter, format, apply word replacements, optionally enhance with an AI model, deliver to the cursor, persist. Provider selection sits behind a registry that maps a model’s provider enum to a service conforming to a single transcription protocol, so adding a speech backend means implementing that protocol rather than touching the pipeline. Persistence is split into separate stores for transcripts, dictionary and statistics, which is what lets the dictionary sync through CloudKit while transcripts stay device-local, and the local language model for text refinement is isolated in its own XPC process so a model crash or a memory spike cannot take the app down with it.

Tech Stack Swift and SwiftUI on macOS 15 or later, built with Xcode and a Makefile that compiles whisper.cpp into an XCFramework before the app target. Local transcription uses whisper.cpp through a Swift actor wrapper, FluidAudio for Parakeet, and transcribe.cpp for GGUF models; Apple’s own Speech framework is available as a fourth local option. Cloud transcription goes through LLMkit against Groq, Deepgram, ElevenLabs, AssemblyAI, Mistral, Gemini, Soniox, Speechmatics, Cartesia, xAI, OpenRouter and OpenAI-compatible endpoints, with WebSocket streaming for the providers that support it. Local AI refinement runs MLX Swift with Hugging Face tokenizers inside an XPC service restricted to Apple silicon. Storage is SwiftData across three configured stores, with CloudKit private database sync on the dictionary store only; credentials live in the Data Protection Keychain. System integration leans on ScreenCaptureKit and Vision for on-screen context, the Accessibility API for reading and pasting text, AppIntents for Shortcuts support, and Sparkle for signed updates, with KeySender, SelectedTextKit, Zip and swift-atomics filling in the rest.

Code Quality Error handling is the strongest signal here: nearly every subsystem defines its own typed error enum conforming to LocalizedError, with localised descriptions and, in the transcription core, recovery suggestions written for end users. Logging goes through os.Logger with explicit privacy annotations on interpolated values, and failure paths are deliberate rather than swallowed — storage initialisation falls back from a persistent container to an in-memory one and warns the user, streaming failures degrade to batch upload, license writes roll back to the previous credentials when a partial write fails. Concurrency is modern and careful, with actors around the model containers, MainActor isolation on the UI-facing services, and Sendable annotations on the types that cross boundaries. Naming is descriptive and consistent, types are specific instead of stringly-typed, and user-facing strings are localised throughout. Automated testing is the gap: the only test target holds the Xcode UI-test templates with no real assertions, there is no unit-test suite for the diffing, normalisation and pipeline logic that would benefit most from one, and the repository carries no continuous integration workflows or lint configuration, so correctness rests on manual verification and the release script.

What Makes It Unique Two pieces go beyond what a dictation front end normally attempts. The first is AutoLearn: after text is pasted, the app keeps watching the target field through the Accessibility API, and when you fix a word by hand it diffs the original against the edited version at segment granularity, filters the resulting hunks through privacy and plausibility limits, and asks a language model to decide whether each correction should become a word replacement, a dictionary entry, both or neither. Dictation quality improves from ordinary editing rather than from a settings screen. The second is the refinement engine: instead of shipping AI cleanup as a cloud call, an MLX model is loaded, warmed and generation-capped inside a dedicated XPC service with its own GPU cache limits and unload path, so the entire pipeline from microphone to polished text can run with no network at all. Around those, the contextual layer is unusually thorough — window and URL detection driving mode selection, screen OCR feeding the prompt, clipboard and selected-text context, dictated trigger words that switch modes mid-sentence — and the streaming session’s automatic degradation to a batch upload means a flaky network costs latency instead of the recording.

Self-Hosting

The repository ships the GNU General Public License v3, and the README states the same, although GitHub’s detector reports no assertion because the bundled LICENSE file is abridged to a preamble plus a link. Under GPL v3 you may use VoiceInk commercially, study it and modify it without paying anyone; the copyleft term means that if you distribute a modified build, you owe its recipients the corresponding source under the same licence. Running a private fork inside your own company is unrestricted. Note that the project does not accept pull requests — bug reports and feature requests go through issues, and changes you want beyond that live in your fork.

Operationally this is a desktop app, so there is no server to run, no database to back up and no uptime to carry. The cost is per-machine setup: macOS 15 or later, Xcode with command line tools, and a build that clones whisper.cpp and compiles it into an XCFramework before the app target, which takes real time on a first run. A local build signs ad hoc or with an Apple Development identity, and the maintainers are explicit that it drops two things — iCloud dictionary sync and automatic updates, so refreshing means pulling and rebuilding. Beyond that you own model management yourself: downloading speech models, deciding which ones live on disk, and supplying API keys if you enable any cloud provider. Keys are stored in the device-local Keychain and audio retention is configurable, so a strict environment can keep the whole pipeline offline.

The commercial version is a one-time lifetime licence rather than a subscription, sold in tiers by device count, currently twenty-five dollars for a single Mac up to a hundred and fifty-nine for a ten-seat startup licence, with a free trial. Paying gets you a notarised, signed build, Sparkle-delivered automatic updates, iCloud sync for the personal dictionary, and priority support over Discord and email. Self-hosting the build yourself trades those conveniences for the setup burden, and there is no managed tier, SLA or support contract on offer at either end — the product is a local app either way, so the comparison is a build pipeline and manual updates against a signed installer, rather than infrastructure against someone else’s cloud.