Whisper Model Comparison for Subtitles: Tiny, Small, Turbo and Large-v3

The largest Whisper model is not automatically the best one for subtitles. large-v3-turbo has roughly half the parameters of large-v3 and runs about eight times faster, and on ordinary footage the difference in the finished subtitle file is small enough that speed decides it. There are also real cases where a smaller model produces a better transcript than a bigger one.

Here are the numbers, what they mean for subtitle work specifically, and the failure modes that make a model look worse than it is.

The models side by side

Parameters and relative speed come from OpenAI's Whisper model card; the sizes are the real totals of the CTranslate2 builds that Sablate downloads, not rounded estimates.

The row that breaks the pattern is turbo. It has more parameters than medium and still runs about four times faster, which is not what the parameter count alone predicts.

Why turbo changes the recommendation

Turbo is not a smaller model trained from scratch. It is large-v3 with its decoder pruned from 32 layers to 4, then fine-tuned for two further epochs on the same multilingual transcription data. Whisper spends most of its time in the decoder, so cutting it that hard buys a very large speed gain while the encoder — the part that actually listens — is untouched.

Two caveats come with it, and both are documented by OpenAI rather than folklore:

• It was fine-tuned without translation data. Turbo is a transcription model. If you want Whisper's speech-to-English-translation task, turbo is the wrong tool; transcribe in the source language and translate the text afterwards, which is the better workflow anyway.
• Some languages degrade more than others. Turbo tracks large-v2 across most languages but loses noticeably more on Thai and Cantonese. If you work in those, test before committing.

For everything else, turbo is the sensible default for subtitles: near-large quality at a speed that makes a two-hour recording a practical job.

Does the biggest model give the best subtitles?

Not always, and the exception is worth knowing about because it looks like a bug when you hit it.

We measured this on a 101-second Turkish clip, on an RTX 3060 Ti with float16, through the app's own transcription path. Ranked by how much of the speech each model actually caught, medium came first. large-v3 skipped speech that medium transcribed correctly — the opening words of the clip and several short interjections simply did not appear. None of the usual levers brought them back: disabling the voice-activity filter, raising the no-speech threshold, removing the log-probability threshold, pinning the temperature. Removing the log-probability threshold made it dramatically worse, cutting the transcript from about 1,110 characters to 429.

We also tested the widely repeated community advice to use large-v2 instead of large-v3. On this clip it was the worst of the set: it dropped a continuous 30-second stretch of speech entirely, from 28.7s to 58.7s, producing 106 words where medium produced 178.

One clip is not a benchmark, and this one was short, Turkish, and conversational. Take the method rather than the ranking: transcribe the same file with two models, look at what is missing rather than what is misspelled, and pick the one that heard everything. Omissions cost far more in subtitles than typos do, because a viewer can read past a wrong word and cannot read a line that is not there.

When a good model looks like a bad one

Three failure modes produce "the big model is worse" complaints that have nothing to do with the model.

1. Word-timestamp ties break line splitting. Whisper emits per-word timestamps, and adjacent words frequently share a boundary exactly — in the clip we examined, 172 of 177 word gaps were exactly 0.000 seconds. A splitter that breaks a long cue at the largest gap therefore finds every candidate tied, takes the first one, and recurses — peeling off one word at a time. The symptom is a transcript shredded into single-word subtitles, and it gets worse with the model that produces the most words. Fixing the tie-break to favour the temporal midpoint took one clip from 90 cues (78 of them single-word) to 28 cues with a single one-word line. The model never changed.

2. The model you selected is not the model that ran. Model repositories are named inconsistently between download registries and inference libraries. A downloaded model sitting on disk under one repository name, while the loader searches for another, produces either a silent fallback or an error that reads like a network problem — while 1.6 GB of the correct model is already present.

3. A failed re-transcription leaves the old transcript on screen. If a re-run fails and the application rolls the job back but keeps the requested model name, you are now looking at the previous model's output labelled as the new one. Every comparison made from that state is wrong. If you are benchmarking, verify that the text actually changed before drawing conclusions — identical output from two different models is a red flag, not a finding.

VRAM, disk and what your machine can run

The download sizes in the table above are also a good proxy for memory pressure during transcription. Practical guidance:

• 4 GB VRAM or less, or no discrete GPU — small is the sweet spot. tiny is for drafting and timing checks, not for delivery.
• 6–8 GB VRAM — large-v3-turbo comfortably. This is the configuration most people should be on.
• 10 GB VRAM or more — large-v3 if the audio genuinely needs it: heavy accents, overlapping speakers, poor microphones.
• CPU only — small for anything you need today, turbo if you can leave it running.

Precision matters as much as model size here. The CTranslate2 builds Whisper runs on support float16 and int8, and dropping precision reduces memory substantially at a quality cost that is small for int8 and usually invisible for float16 on a GPU.

On GPU, expect roughly a five to ten times speedup over the same machine on CPU. In Sablate on Windows, the NVIDIA CUDA runtime is downloaded the first time a GPU run happens rather than shipped in the installer, which keeps the download small for people who will never use it.

Which model should you actually pick?

That last row is the one that changes the calculus. When a transcript is the input to eight translations, an error is not one error — it is eight. The multilingual workflow explains why the source transcript deserves the slow model and the careful proofread.

In Sablate, Fast and Balanced (tiny and small) run on the free plan; Accurate and Best are part of Pro, a single $29 payment covered on the pricing page. Whichever model you run, the output lands in the same editor and exports to the same formats — SRT, VTT and ASS — so the model choice is about how much correcting you do afterwards, not about what you can produce.

How to test this on your own footage

Five minutes of method beats any published benchmark, including this one:

1. Take a 60 to 120 second clip that is representative — your worst microphone, your usual accents, your actual room.
2. Transcribe it with two candidate models, changing nothing else.
3. Compare for omissions first, misspellings second.
4. Count the single-word cues. A pile of them points at segmentation, not at the model.
5. Only then compare the wall-clock time, and decide what that time is worth to you.

The model that hears everything on your material is the best model for you, and it will not necessarily be the biggest one.