Most local dictation apps ask you to pick a model before they'll do anything, and most people pick badly - either the largest one, which makes dictation laggy, or the default, which is often the smallest and least accurate.
The choice is a straightforward trade between accuracy, speed, memory, and disk. Here's how to make it.
OpenAI released Whisper under the MIT licence in 2022, in several sizes trained on the same data. Larger models are more accurate and slower. Because the licence is permissive, essentially every local dictation tool is built on Whisper or a derivative: superwhisper, MacWhisper, Handy, Buzz, Vibe, VoiceInk, Vocalinux, VOXD, and more.
They ship the same underlying models, which is why they're closer in accuracy than their marketing suggests. What differs is the app around the model.
| Model | Parameters | Disk | RAM (approx) | Use for |
|---|---|---|---|---|
| tiny | 39M | ~75 MB | ~1 GB | Testing; very weak hardware |
| base | 74M | ~140 MB | ~1 GB | Short commands, clean audio |
| small | 244M | ~460 MB | ~2 GB | Everyday dictation, older machines |
| medium | 769M | ~1.5 GB | ~5 GB | The accuracy/speed sweet spot |
| large (v3) | 1550M | ~3 GB | ~10 GB | Files, accents, jargon |
| turbo | 809M | ~1.6 GB | ~6 GB | Near-large accuracy, much faster |
Figures are approximate and vary by quantisation - a 4-bit quantised large model needs far less memory than the numbers above, at a small accuracy cost. Tools using whisper.cpp or GGML, including Handy, Vocalinux, and VOXD, quantise by default.
Note also that tiny and base ship in English-only variants (tiny.en, base.en) that are meaningfully better than the multilingual versions at the same size, if you only dictate in English.
Dictating at the cursor on Apple Silicon: turbo, or large if your machine has headroom. Both run in real time on an M-series chip, and the accuracy is worth it.
Dictating on Windows or Linux without a GPU: small, or medium if you're patient. Large on a CPU is slow enough to break the flow of dictation, and a laggy large model costs you more than its extra accuracy is worth.
Dictating with a GPU (CUDA or Vulkan): turbo or large. Handy, Buzz, and Vibe all use GPU acceleration where available; Vocalinux supports Vulkan on AMD, Intel, and NVIDIA.
Transcribing files: large, always. Latency doesn't matter when you're processing a file in the background, so take the accuracy. This is what MacWhisper Pro, Buzz, and Vibe unlock.
Accents, background noise, or specialist vocabulary: the largest model you can run. The accuracy gap between sizes widens sharply on difficult audio - small and large are close on a clean recording of a standard accent, and far apart on anything else.
Testing whether local dictation works for you at all: base or small, then upgrade. Just don't judge the category on tiny.
Whisper large-v3-turbo is a distilled version of large-v3 with far fewer decoder layers. It's several times faster, uses roughly half the memory, and loses very little accuracy on most audio.
For live dictation on capable hardware, turbo is generally the best default: close to large in quality, fast enough not to interrupt you. Handy and OpenWhispr both offer it explicitly.
The exception is multilingual work, where turbo degrades more than large on some languages. If you dictate in something other than English, test both.
Whisper isn't the only local option any more, and several tools now ship others.
NVIDIA Parakeet. Notably faster than Whisper at comparable accuracy on English, with a permissive licence. Handy ships Parakeet V3, Spokenly offers it alongside Whisper, OpenWhispr supports it, and Vibe has Parakeet TDT v3. If you're on English and want speed, it's worth testing against turbo.
VOSK. Much smaller and lighter than Whisper, with lower accuracy. Used by nerd-dictation and available in Vocalinux. The case for it is responsiveness on weak hardware - it's fast on a CPU where Whisper isn't.
Nemotron. Available in Vibe alongside Whisper and Parakeet.
Apple's on-device model. What Apple Dictation uses, and available to OpenTypeless on macOS. Well-optimised for Apple Silicon, no download, no configuration.
Most Linux and cross-platform tools don't run OpenAI's Python implementation. They use whisper.cpp, a C++ port that's also MIT-licensed, runs on CPU efficiently, quantises models to 4-bit and 8-bit, and has no Python dependency.
That's what makes offline dictation practical on ordinary hardware. Vocalinux, VOXD, and Whispering's desktop build all use it.
The practical consequence: a quantised medium model through whisper.cpp may be both faster and smaller than an unquantised small model through the Python implementation. Don't compare model sizes across tools without knowing which runtime each uses.
One failure mode is worth knowing regardless of which size you pick. During silence or noise, Whisper models sometimes generate fluent text that was never spoken - often a repeated phrase, sometimes something plausible.
Larger models are not immune. What helps is trimming silence before transcribing and using voice activity detection where the tool offers it. See speech-to-text accuracy explained for why this matters more than the raw error rate.
small.en often beats multilingual small.Turbo on capable hardware, small on a CPU-only machine, and large for transcribing files where latency doesn't matter.
On clean audio with a standard accent, the gap is modest. On accents, background noise, or specialist vocabulary it's substantial. If you can run large in real time, run it.
Roughly 1 GB for tiny and base, 2 GB for small, 5 GB for medium, and 10 GB for large - considerably less with quantisation, which most whisper.cpp-based tools apply by default.
A distilled version of large-v3 with fewer decoder layers: several times faster, about half the memory, and very little accuracy loss on English. It's the best default for live dictation on capable hardware.
On English it's faster at comparable accuracy, which makes it a good choice for live dictation. Whisper has broader language coverage. Handy and Spokenly let you try both.
No. whisper.cpp runs quantised models acceptably on a modern CPU, and VOXD explicitly requires no GPU. A GPU lets you run larger models in real time.
Last verified: 10 August 2026.