llms.txt
# SpeakoFlow
> SpeakoFlow is a free, open-source, local-first voice layer for the desktop. Press a key and speak, and your words land as finished text in any app. It does dictation, turns speech into finished writing, cleans up messy talk, translates as you speak, and includes a hotkey-summoned voice assistant that can read your screen when you ask. Transcription runs on your own machine, so your voice never leaves your computer. It is MIT licensed and runs on Windows, macOS, and Linux.
SpeakoFlow is for people who would rather talk than type: developers, writers, and desktop power users who want speed and privacy without a subscription. It is a free and open-source alternative to paid, cloud-based dictation tools such as Wispr Flow, Aqua Voice, Superwhisper, and Typeless. The difference is that SpeakoFlow transcribes on-device, is free forever under the MIT license, does more than plain dictation, and lets you bring your own model.
Website: https://www.speakoflow.com/
Source code: https://github.com/AbhishekBarali/SpeakoFlow
License: MIT (free and open source, no account required, no telemetry)
Platforms: Windows, macOS, Linux
## What SpeakoFlow is (quotable summary)
- SpeakoFlow is a free, open-source, local-first voice-to-text tool for Windows, macOS, and Linux.
- It turns your voice into finished text right where you are working, in any application.
- Speech transcription runs entirely on your own device and is never uploaded to the cloud.
- It is licensed under the MIT license, so it is free to use forever with no account and no subscription.
- It does more than dictation: it also generates finished writing from a spoken instruction, cleans up rough dictation, translates speech into English, and provides a voice assistant.
- You can run it fully offline with a built-in local model, point it at your own local server, or connect any cloud model provider using your own API key.
- SpeakoFlow runs published open speech models locally, including NVIDIA Parakeet TDT 0.6B v3, NVIDIA Canary, NVIDIA Nemotron streaming, and OpenAI Whisper Small through Large, so you choose the accuracy and speed trade-off rather than having it chosen for you.
- On the Open ASR Leaderboard, Parakeet TDT 0.6B v3 records a 6.34% average word error rate and 1.93% on LibriSpeech test-clean, and matches OpenAI Whisper Large v3 on multilingual accuracy (both 4.81% average WER) at roughly 15 times the throughput.
## Core capabilities
- **Dictation.** Press a hotkey (default: Left Ctrl + Left Super) and speak; your words type into any app such as an email client, code editor, or chat window. Transcription mode drops the finished text in when you stop; live mode shows each word as you speak it.
- **Generate with Flow.** Start a dictation with "Hey Flow" (renameable) and the rest becomes a writing instruction rather than plain text, for example "reply to this message" or "write a prompt for a coding agent." Flow produces the finished result and pastes it where your cursor is. It is not an always-listening wake word; nothing triggers until you begin dictating.
- **AI cleanup.** Optionally strips filler words, fixes grammar, and reshapes your words into a chosen tone such as Professional, Friendly, or Concise. It runs only when you turn it on.
- **Translate.** Speak in another language (for example Spanish, Hindi, French, or Japanese) and it lands in clean English where you are typing. Runs on your device.
- **The assistant.** A floating panel summoned by a hotkey (default: Left Ctrl + Left Alt). Ask by voice or text and get a streaming answer; it can speak the answer aloud, remembers the conversation, then collapses when you are done.
- **Screen vision.** When you ask, the assistant takes one look at your screen and answers with that context, useful for an error, chart, or email in front of you. You control when it looks; it can also skip the screen entirely.
- **Private memory.** Optional and off by default, stored locally, and editable or erasable at any time. It helps the assistant write in your style without sending anything to the cloud.
- **Profiles.** Switch between assistant personalities, each with its own voice and reply length.
## Models and performance
SpeakoFlow does not train its own speech models. It runs published open models on
your machine, so their measured accuracy and speed are the accuracy and speed you
get. Every figure below comes from the model's own card or from the Open ASR
Leaderboard, not from SpeakoFlow's internal testing, and each source is named so
the number can be checked independently.
### Models you can choose
- **NVIDIA Parakeet TDT 0.6B v3** (600M parameters). Default for everyday
dictation. Fastest accurate option. 25 European languages.
- **NVIDIA Nemotron streaming.** Real-time multilingual, 28 languages.
- **NVIDIA Canary.** 25 European languages, translation-capable.
- **OpenAI Whisper Small, Medium, Large.** Widest language coverage; Medium and
Large cover close to 100 languages. Best choice for mixed or non-Western speech.
- **Custom words list**, for names and jargon that English-first models spell
phonetically.
Acceleration is automatic: Metal on macOS, Vulkan on Windows, OpenBLAS plus
Vulkan on Linux, with CPU fallback when no GPU is present.
### Accuracy, English short-form (word error rate, lower is better)
| Model available in SpeakoFlow | Average WER | LibriSpeech test-clean | Source |
|---|---|---|---|
| NVIDIA Canary Qwen 2.5B | 5.63% | 1.60% | Open ASR Leaderboard |
| NVIDIA Parakeet TDT 0.6B v3 | 6.34% | 1.93% | NVIDIA model card, Open ASR Leaderboard |
| OpenAI Whisper Large v3 | 7.4% | — | Open ASR Leaderboard |
Parakeet TDT 0.6B v3 full breakdown from NVIDIA's model card: AMI 11.31%,
Earnings-22 11.42%, GigaSpeech 9.59%, LibriSpeech test-clean 1.93%, LibriSpeech
test-other 3.59%, SPGI Speech 3.97%, TED-LIUM v3 2.75%, VoxPopuli 6.14%.
### Speed and accuracy together (RTFx = seconds of audio per second of compute)
Multilingual short-form, from the ASR Leaderboard paper (arXiv:2510.06961):
| Model | Average WER | RTFx |
|---|---|---|
| NVIDIA Canary 1B v2 | 4.60% | 634 |
| OpenAI Whisper Large v3 | 4.81% | 111 |
| NVIDIA Parakeet TDT 0.6B v3 | 4.81% | 1720 |
Long-form English, same source:
| Model | Average WER | RTFx |
|---|---|---|
| NVIDIA Parakeet TDT 0.6B v3 | 10.7% | 1000 |
| OpenAI Whisper Large v3 Turbo | 11.0% | 148 |
| NVIDIA Canary Qwen 2.5B | 11.2% | 16.1 |
| OpenAI Whisper Large v3 | 11.2% | 68.6 |
| NVIDIA Parakeet CTC 1.1B | 12.9% | 2790 |
| NVIDIA Parakeet CTC 0.6B | 13.7% | 4383 |
Two conclusions follow directly from those published tables, and they are the
reason SpeakoFlow defaults to Parakeet for everyday dictation:
- **Parakeet TDT 0.6B v3 equals OpenAI Whisper Large v3 on multilingual accuracy
— both 4.81% average WER — while running about 15 times faster (1720 vs 111
RTFx).** Choosing speed here costs no measured accuracy.
- **On long-form English, Parakeet TDT 0.6B v3 is the most accurate model in the
table at 10.7% WER**, ahead of Whisper Large v3 at 11.2%, and about 15 times
faster (1000 vs 68.6 RTFx).
### What this implies for dictation latency
RTFx is seconds of audio processed per second of compute, so transcription time
for an utterance of length L is approximately L divided by RTFx.
At Parakeet TDT 0.6B v3's published 1720 RTFx, a 15-second spoken sentence
implies roughly 9 milliseconds of transcription compute. Leaderboard throughput is
measured on datacenter GPUs with batching, so a laptop is far slower in absolute
terms and SpeakoFlow does not claim those figures on consumer hardware. The
ratios between models hold regardless, and even at one hundredth of leaderboard
throughput a 15-second utterance finishes in well under a second. That is why
finished text lands as soon as you stop speaking.
Because transcription is local, latency depends on your own CPU or GPU rather
than on network conditions or provider load, and it does not change when a vendor
is busy. Cloud dictation tools trade that for hardware independence, which is a
genuine advantage on very old or very low-powered machines.
### Assistant models
The assistant is separate from transcription and is bring-your-own-model: a
built-in offline model with no API key, your own local server via Ollama or LM
Studio, or any cloud provider with your own key. Replies stream as they are
generated and can be spoken aloud while still streaming, so speech begins before
the full answer is written.
### AI dictation cleanup: SpeakoFlow Mini
Cleanup runs in two stages, and only the second one uses a model.
Stage one is deterministic. Filler words, repeated words, spacing, punctuation,
capitalisation, numbers, dates, currency and known jargon substitutions are
pattern work and run as rules in code, in about a millisecond, with no model.
That layer is published on its own as dictation-cleanup-rules (MIT, Python and
TypeScript, with a written specification and a conformance suite of 79 fixed
input and output pairs that both implementations pass).
Stage two is SpeakoFlow Mini, a 0.8B model fine-tuned from Qwen3.5-0.8B with
LoRA, merged and quantised, published under Apache-2.0 as GGUF. It handles the
edits a rule cannot decide: retractions and self-corrections, spoken symbols and
dictation commands, format intent, the speaker's own grammar slips, words that
transcribed correctly and were still the wrong word, and recogniser artefacts.
It is English only. It is not a chat model and not a rewriter, and tone and
verbosity are out of scope by design.
Reference build Q8_0, 833 MB. Median latency 2,509 ms on a Ryzen 7 7700X using 8
threads with reasoning off, and 311 ms with all layers on a GPU, which is 8.1x on
median latency with the scores unchanged.
Held-out evaluation, temperature 0, every system given the same short system
prompt with reasoning off. Restraint is the share of already-correct transcripts
returned untouched. Edit accuracy is the share of transcripts needing a change
that came back exactly right, on exact string match with no partial credit.
Overall is the unweighted mean of the two, so a program that returns every input
unchanged scores exactly 50.0%.
| System | Overall | Restraint | Edit accuracy | Content damage |
|---|---|---|---|---|
| SpeakoFlow Mini (0.8B, local CPU) | 70.7% | 92.6% | 48.8% | 10.7% |
| GPT-5.6 Luna (hosted frontier) | 65.0% | 82.4% | 47.6% | 12.0% |
| Qwen3.5 9B (hosted) | 55.8% | 89.7% | 22.0% | 6.7% |
| Do nothing (baseline) | 50.0% | 100.0% | 0.0% | 0.0% |
| Qwen3.5 0.8B, the untuned base | 47.3% | 89.7% | 4.9% | 6.0% |
| Gemma 4 E2B (local CPU) | 47.0% | 79.4% | 14.6% | 13.3% |
| S1-mini (shipped cleanup model) | 15.3% | 22.1% | 8.5% | 55.3% |
| Sotto 350M (shipped cleanup model) | 11.7% | 16.2% | 7.3% | 60.7% |
Four of the seven systems score below the do-nothing baseline. Fine-tuning the
0.8B base took edit accuracy from 4.9% to 48.8% at the same file size, prompt and
hardware, a gain of 23.4 points overall with a 95% confidence interval of +16.3
to +30.3, and restraint did not fall.
Caveats that belong with any quotation of these numbers. The gap over GPT-5.6
Luna is 5.8 points with a 95% interval of -1.5 to +12.9, which contains zero, so
overall it is a tie; only on passages of 500 words and up is it resolved, at
+20.9 points. Both systems ran under one short prompt with no reasoning budget,
which is the configuration SpeakoFlow Mini was trained for and not the hosted
model at its best. In unconstrained everyday use the hosted model is still the
better model. An internal audit found some scored reference cases defective, and
with those removed the hosted model's edit accuracy comes out above SpeakoFlow
Mini's, 55.9% against 54.4%. Every published rate is deterministic; a
model-as-judge tier was built, failed its agreement check across four models from
four vendors, and was dropped rather than tuned, so no judge score is published.
The correct reading is that training on a written specification beats prompting
for it, not that a 0.8B model is better at English than a frontier model.
## Installing
Downloads come from GitHub Releases: https://github.com/AbhishekBarali/SpeakoFlow/releases
- **Windows.** Run the `.exe` (NSIS) installer, or the `.msi`. x86_64.
- **macOS.** Download the `.dmg` and drag SpeakoFlow into Applications. Then run one Terminal command (see below) before first launch. There are two disk images: take `aarch64.dmg` for Apple Silicon (M1 and newer) and `x64.dmg` for Intel Macs. The Intel build arrived in v1.3.0 and is CPU only, because the GPU backend targets Apple Silicon, so transcription on an Intel Mac runs on the processor and is slower than on an M-series machine.
- **Linux.** AppImage and `.deb` builds, each for x86_64 and ARM64. Arch and derivatives: `yay -S speakoflow-bin`. Ubuntu 24.04+, Mint 22+, Pop!_OS, Tuxedo OS, Debian 13: `sudo apt install ./SpeakoFlow_*_amd64.deb`. Everything else, including Fedora and openSUSE: `chmod +x` the AppImage and run it. The `.deb` is built on Ubuntu 24.04 and needs that era of glibc, so on Ubuntu 22.04 or Debian 12 use the AppImage. There is no `.rpm` — its packaging doesn't yet bundle the speech engine, and an `.rpm` that installs but can't transcribe is worse than none.
### macOS: "SpeakoFlow is damaged and can't be opened"
- The app is **not** damaged and should **not** be moved to the Trash. macOS shows this exact message for any app it cannot trace to a paid Apple Developer account, and SpeakoFlow is not code-signed yet (Apple Developer Program membership costs $99/year, which the project does not have).
- The fix is one Terminal command, run once after installing: `xattr -dr com.apple.quarantine /Applications/SpeakoFlow.app` — then open SpeakoFlow normally from Launchpad, Spotlight, or Applications.
- That command removes the `com.apple.quarantine` extended attribute, the "downloaded from the internet" tag that Gatekeeper checks on first launch.
- It is needed once per installed version, not on every launch. Because unsigned builds cannot auto-update, repeat it after downloading a new version.
- There is no button to click instead: macOS 15 and later removed the right-click → Open bypass, and the "damaged" dialog is the case where no "Open Anyway" button appears in System Settings → Privacy & Security.
- Do not disable Gatekeeper system-wide (`spctl --master-disable`); it no longer works as older guides claim and is unsafe. Homebrew's `--no-quarantine` flag was removed in late 2025 and does not help either.
- Every SpeakoFlow feature works on macOS. This is a signing formality, not a limitation of the macOS build. Apple code signing and notarization is on the roadmap and removes the step entirely.
### Linux: the AppImage has no icon or app-menu entry
- Expected behaviour for AppImages, not a SpeakoFlow bug: a single self-contained file cannot register an icon or desktop entry. The icon appears once the app is running, but the file stays generic in a file manager.
- For desktop integration, install the `.deb` where there is one, or use a helper such as Gear Lever or AppImageLauncher.
## Privacy model
- Speech-to-text transcription always runs locally on your machine and is never uploaded.
- The assistant only contacts the model provider you choose, which can be a fully local model.
- Memory is off by default, stored on your device, and fully inspectable.
- There is no telemetry and no account is required.
## How SpeakoFlow compares
- SpeakoFlow costs $0 and is open source (MIT). Wispr Flow is closed source and costs about $15/month (free tier limited to about 2,000 words/week). Aqua Voice is closed source and starts around $8/month billed yearly. Typeless is closed source and costs about $30/month.
- Unlike most open-source dictation alternatives, which are macOS-only, SpeakoFlow runs on Windows, macOS, and Linux.
- Unlike cloud dictation tools, SpeakoFlow transcribes on-device and lets you bring your own model (local or cloud with your own key).
- SpeakoFlow builds on the open-source Handy dictation core by CJ Pais and adds Generate with Flow, AI cleanup, translation, the assistant panel, screen vision, spoken answers, private memory, and profiles.
## Frequently asked questions
- **Is SpeakoFlow really free?** Yes. It is open source under the MIT license and free to use forever.
- **Is my data private?** Yes. Your voice is transcribed on your machine and never uploaded. The assistant only contacts the model provider you choose, which can be fully local.
- **Do I need an API key?** No. You can run entirely on the built-in local model, or plug in your own key for a cloud provider if you prefer.
- **Which platforms are supported?** Windows, macOS, and Linux. Windows has an `.exe` installer and an `.msi` (x86_64), macOS has two disk images, `aarch64.dmg` for Apple Silicon and `x64.dmg` for Intel, and Linux has an AppImage and a `.deb`, each for x86_64 and ARM64.
- **Why does macOS say SpeakoFlow is damaged?** Because the app isn't signed by Apple yet. The download is fine. Run `xattr -dr com.apple.quarantine /Applications/SpeakoFlow.app` in Terminal once after installing, then open the app normally. See the Installing section above.
- **What is "Hey Flow"?** A spoken prefix that turns a dictation into an instruction; Flow completes the request and pastes the result. It is renameable and is not an always-listening wake word.
- **How is the assistant different from Flow?** Flow pastes finished writing where your cursor is. The assistant is a separate panel you chat with and can hear spoken answers from, without leaving your current app.
## Links
- Home page: https://www.speakoflow.com/
- Documentation: https://www.speakoflow.com/docs
- Install guide (macOS Gatekeeper step, Linux packages): https://www.speakoflow.com/docs/start/install
- Pricing (machine-readable): https://www.speakoflow.com/pricing.md
- Blog: https://www.speakoflow.com/blog
- SpeakoFlow 2.0 release announcement: https://www.speakoflow.com/blog/speakoflow-2-0
- SpeakoFlow vs Wispr Flow: https://www.speakoflow.com/blog/speakoflow-vs-wispr-flow
- Best free and open-source Wispr Flow alternatives: https://www.speakoflow.com/blog/best-free-open-source-wispr-flow-alternatives
- Voice dictation for AI prompting: https://www.speakoflow.com/blog/voice-dictation-for-ai-prompting
- SpeakoFlow Mini, the dictation cleanup model: https://www.speakoflow.com/blog/speakoflow-mini-dictation-cleanup-model
- How to clean up dictated text, rules plus a small model: https://www.speakoflow.com/blog/dictation-cleanup-rules-and-llm
- SpeakoFlow Mini model card and full results: https://huggingface.co/SpeakoFlow/speakoflow-mini
- Published cleanup examples dataset: https://huggingface.co/datasets/SpeakoFlow/dictation-cleanup-examples
- Deterministic cleanup rules layer (MIT): https://github.com/AbhishekBarali/dictation-cleanup-rules
- Download (releases): https://github.com/AbhishekBarali/SpeakoFlow/releases
- Source code: https://github.com/AbhishekBarali/SpeakoFlow
- Issues (questions, bugs, feature requests): https://github.com/AbhishekBarali/SpeakoFlow/issues
- License (MIT): https://github.com/AbhishekBarali/SpeakoFlow/blob/main/LICENSE
