Whisper large-v3 turbo is OpenAI’s speed-optimized Whisper variant, and it’s the single on-device transcription engine in Kajo Voice. When you transcribe a recording in Kajo today, the model converting speech to text is Whisper large-v3 turbo — quantized to q8_0, weighing about 834 MiB.
This guide explains what large-v3 turbo is, how it compares to the full large-v3 model, and the honest reasoning behind this choice. If you’re a non-engineer trying to set realistic expectations for accuracy, speed, and language coverage, this is the whole picture — including the trade-offs involved.
What Is Whisper?
Whisper is a neural network model for automatic speech recognition (ASR), released by OpenAI as open source in September 2022. Its paper offers a backronym for the name — Web-scale Supervised Pretraining for Speech Recognition — which describes how it was trained.
The original model was trained on roughly 680,000 hours of multilingual and multitask supervised data collected from the internet (the Whisper paper); large-v3 was later trained on about 1 million hours of weakly labelled audio and 4 million hours of pseudo-labelled audio (the large-v3 model card). That scale is far larger than previous open-source ASR models, and it’s a primary reason for Whisper’s accuracy advantage. The diversity of that data — different speaking styles, recording environments, accents, and languages — gives the model robustness to real-world audio that earlier systems lacked.
Whisper is a transformer-based sequence-to-sequence model: audio in, text out. Unlike traditional ASR systems that bolted together separate acoustic, pronunciation, and language-model components, Whisper handles all of it in a single end-to-end model.
The Whisper Model Family: Understanding the Variants
OpenAI released Whisper in multiple sizes, trading accuracy against computational cost. The naming convention:
- tiny — smallest, fastest, least accurate (~39M parameters)
- base — small and fast, moderate accuracy (~74M parameters)
- small — good accuracy, reasonable speed (~244M parameters)
- medium — strong accuracy, moderate compute (~769M parameters)
- large — highest accuracy in the original release (~1.5B parameters)
- large-v2 — improved large model (same size, better training)
- large-v3 — further improved, same size; strong accuracy leader
- large-v3-turbo — large-v3 pruned to a 4-layer decoder and fine-tuned, for speed
The last two are where every serious local-transcription decision gets made today, so they deserve a proper comparison.
What Whisper Large-v3 Turbo Actually Is
Large-v3 turbo (sometimes written large-v3-turbo, or just “turbo”) is the most recent addition to the family. It is not a new, more capable model — it’s a pruned version of large-v3. OpenAI took the full model, cut the decoder from 32 layers down to 4, then fine-tuned the pruned model (model card).
That single change is the entire story:
- It’s fast. Most of Whisper’s runtime cost is in the decoder, so cutting it to an eighth of its depth makes turbo much faster — OpenAI’s model table lists it at roughly 8× the relative speed of large-v3, measured on English speech.
- It’s smaller. The q8_0-quantized turbo weights Kajo runs are about 834 MiB, against about 2.9 GiB for full-precision large-v3 in GGML format. Roughly half of that saving is the pruning (turbo at full precision is about 1.5 GiB) and the rest is quantization — meaningful when every user downloads the model before their first transcript.
- It costs some accuracy. A shallower decoder has less capacity. On clean English audio the gap is tiny — often within noise. For non-English languages the gap is larger, and accuracy varies widely by language: OpenAI’s model card reports strong results in about ten languages and uneven performance across the rest, so test your own languages on the free tier.
Why Kajo Runs Large-v3 Turbo
The choice comes down to the on-device constraint. Kajo Voice runs entirely on your machine — there is no cloud fallback. That means the model has to be practical to ship, download, and keep in memory on the hardware real users own today.
~834 MiB (q8_0) vs ~2.9 GiB. Full-precision large-v3 takes about three and a half times the disk space and memory of the file Kajo downloads. On a 16 GB machine shared between the OS, the Kajo app, a local LLM, and whatever else is running, that difference matters. The turbo model fits comfortably alongside the rest of the on-device stack; the full model puts real pressure on RAM.
Roughly 8× the decoding speed. On Apple Silicon, where Kajo runs the model with GPU acceleration, the wait is usually the model download rather than the transcript. On Windows and Linux, where Kajo transcribes on the CPU, turbo’s speed advantage over the full model is what keeps batch transcription practical at all.
Accuracy is still strong. Turbo is marginally less accurate than full large-v3 on multilingual benchmarks — the gap is real but small. The Arabic leaderboard is the worked example: 33.30% WER for turbo against 29.87% for large-v3 across dialect-heavy sets (arXiv:2412.13788, Table 1). For interviews, depositions, client calls, and field recordings, turbo delivers results you can use with normal review.
The translation job is separate. One place the full large-v3 has a structural advantage over turbo is its cross-lingual training: it was trained for transcript-level translation. But Kajo handles translation through its on-device Gemma 4 model, not through the ASR engine. So turbo’s lack of that training path is irrelevant — translation is a separate step that doesn’t touch the Whisper decoder.
ASR quality is weight-bound, not runtime-bound. A faster runtime doesn’t make a model less accurate — the accuracy lives in the weights. Turbo’s pruned decoder is the right architectural trade when size and speed matter; in Kajo, translation rides the same on-device Gemma 4 session rather than a separate translation model.
One decode profile, fixed and named. Kajo runs a single profile built for multi-speaker conversation: an 80 Hz high-pass and speechnorm on the way in, Silero VAD to drop the silence, greedy decoding, and a duplicate-segment collapse on the way out. There is no profile picker and no auto-classifier, because every buyer segment here imports the same thing — people talking. One profile means the same file decodes the same way twice, and it always runs the same large-v3 turbo weights on your machine — never a cloud cleanup stage.
How Large-v3 Turbo Achieves Its Accuracy
Several architectural choices account for the model’s strong performance despite the shallower decoder:
Encoder depth preserved. Turbo keeps the full large-v3 encoder — all of its capacity for building rich audio representations is intact. The pruning targets the decoder only. The encoder is where most of Whisper’s multilingual robustness comes from, so preserving it is the right call.
Fine-tuned after pruning. OpenAI didn’t just chop the decoder — it fine-tuned the whole pruned model for two more epochs on transcription data only (OpenAI’s release notes), so the model learned to compensate for the reduced depth. The result is better than a naive pruning would suggest.
Large-scale training data diversity. The training behind large-v3 — about a million hours of weakly labelled audio and four million of pseudo-labelled audio — spans many sources, recording conditions, languages, and speaking styles. That diversity is baked into the encoder weights that turbo retains in full.
Accuracy Benchmarks: What to Expect
Whisper’s accuracy is measured with Word Error Rate (WER) — the percentage of words that differ from a ground-truth reference. Lower is better.
Turbo is marginally less accurate than full large-v3 across most benchmarks, with the gap smallest on clean English audio and somewhat larger on multilingual and noisy audio. OpenAI publishes per-language WER on Common Voice 15 and FLEURS for large-v3 and large-v2 in its README, and turbo’s own chart, for the languages where large-v3 scores under 20%, in its release notes. Together they are the honest map of where the model is strong and where it is not.
Kajo publishes no accuracy benchmark of its own yet. The free allowance is your benchmark: transcribe ten minutes of your own audio and count the corrections — see what accuracy to expect and how to check it.
Comparing Whisper Variants for Different Use Cases
| Use case | Best fit | Reason |
|---|---|---|
| On-device transcription with fast results (what Kajo optimizes for) | large-v3 turbo | ~8× relative speed, ~834 MiB, strong accuracy, fits the on-device stack |
| Maximum accuracy at any cost, server inference | large-v3 (full) | Highest accuracy, ~3 GiB, slower |
| Rapid draft transcription on weak hardware | small or medium | Faster, smaller, acceptable on easy audio |
| Near-real-time / streaming | tiny or base | Fast enough for low-latency use |
| Very limited storage | small | Much smaller model file |
For Kajo’s users — professionals who want accurate on-device transcription without sending audio to a cloud — turbo is the right call on the dimensions that matter: speed, size, and accuracy that satisfies real workflows.
Language Performance by Region
Turbo’s accuracy across the 99 languages Kajo exposes is not uniform — it performs best where it had the most training data, inheriting that from the full large-v3 it was pruned from. OpenAI’s per-language WER chart (Common Voice 15 and FLEURS, in its README) is the map: English, Spanish, and the major European languages sit near the top; Arabic, Hindi, and many Asian languages further down; low-resource languages and heavily dialectal speech at the bottom. For Arabic specifically, the independent leaderboard above is the better reference.
What Whisper Cannot Do
Accurate expectations require naming the limits — and these apply to turbo just as they would to the full model:
Multi-party conversations. Multi-speaker audio is harder for Whisper — overlapping talk and turn-taking raise error rates. Kajo runs on-device speaker diarization after every transcription, labels turns per recording, and carries those names into exports, summaries, and cited chat. Review multi-party transcripts against the audio when attribution matters.
Real-time transcription. Whisper processes audio in chunks and works best on complete recordings. True word-by-word live transcription needs a different architecture. That’s not a limitation for Kajo, which works on recordings you already have — you import a finished audio or video file and Kajo transcribes the whole thing locally.
Transcript-level translation. The full large-v3 was trained to translate speech into English; turbo was fine-tuned on transcription only, so it is not built for that job. Kajo handles translation through its on-device Gemma 4 model rather than the ASR engine, so this architectural difference has no practical impact in Kajo.
Prosody and paralanguage. The transcript captures words, not tone, emotion, pitch, or pace. A sarcastic line and a sincere one transcribe identically.
Long unbroken speech. Whisper works in 30-second internal windows; very long uninterrupted speech without pauses can occasionally produce alignment hiccups at window boundaries.
FAQ
Which Whisper model does Kajo actually run? Whisper large-v3 turbo (q8_0, ~834 MiB) — the pruned, fine-tuned variant of large-v3 built for speed. It downloads once on first setup and then runs entirely on your machine.
Why not the full large-v3? The full large-v3 is approximately 3 GiB and notably slower. On a machine running the full Kajo on-device stack — transcription, embeddings, and local LLM — the extra size and speed cost is not worth the marginal accuracy gain for typical professional transcription workflows.
Is large-v3 turbo in Kajo the same model OpenAI released? Yes — the same weights, quantized to q8_0 for efficient on-device inference. Accuracy sits in the same band as any other tool running the same turbo weights; quantization and decode settings (voice-activity detection, beam size, thresholds) still cause small differences in the output.
Which model will Kajo run next year? Kajo pins exactly one transcription model per release and lists it, with every other model it runs, on What runs on your machine. Whatever ships next, your installed version keeps working forever.
Conclusion: Production-Grade On-Device Speech Recognition
Whisper large-v3 turbo is a thoughtfully engineered model: it preserves the full encoder that carries Whisper’s multilingual accuracy, prunes the decoder for roughly 8× the relative speed at about half the size (less still once quantized), and fine-tunes the result to recover accuracy. For on-device transcription — where model size and inference speed genuinely constrain what’s practical — turbo is the right pick.
Running it locally — as Kajo Voice does — means transcription across 99 languages, all on your own hardware, with no audio ever leaving your machine.
Understanding the model helps you use it well: know its strengths (broad multilingual coverage, fast on-device inference, robustness to messy audio), know its limits (dialect variation, overlapping multi-party audio, transcript-level translation handled separately), and set realistic expectations for the review work that professional transcription always involves.
When to run the model yourself instead
Whisper is open-weight, and whisper.cpp runs the same turbo weights from a terminal for free. Use the CLI when you want a one-off transcript on a machine you already administer, need to script a batch, or want to change decode flags Kajo does not expose. Use Kajo when the transcript is the start of something: automatic speaker labels, a library with folders, on-device translation and summaries, cited chat across a folder, and exports including QDPX — packaged for Mac, Windows, and Linux with no Python to maintain. Either way the audio never leaves your machine.
- Free — 5 files or 150 minutes of audio (total, for life), the same on-device model, no card
- Lifetime — one payment ($49 launch / $99 standard) unlocks unlimited imports and Lifetime convenience (watch folders, batch export)