Whisper Model Sizes Explained: Tiny vs Base vs Small vs Medium vs Large

The tiny model is the smallest and fastest Whisper variant. At just 39 million parameters and a GGML file size of 75 MB, it can run comfortably on almost any hardware — including Raspberry Pi, older laptops, and low-end mobile devices. It transcribes at roughly 10x real-time speed relative to the large model, making it the best choice when latency matters more than perfect accuracy.

On the tiny.en variant (English-only), LibriSpeech test-clean WER is around 5.6%, rising to ~14.9% on test-other (noisy/accented audio). The multilingual tiny model performs slightly worse on English but supports all 99 Whisper languages.

Tiny is ideal for quick notes, low-stakes dictation, live captioning prototypes, and embedded or edge devices where compute is limited. It is the default starting model for many whisper.cpp-based tools because it downloads in seconds and runs instantly.

The base model doubles the parameter count of tiny (74M vs 39M) while remaining very lightweight. At 142 MiB (GGML) and ~388 MB of RAM at runtime, it still fits comfortably on virtually any modern device. The accuracy improvement over tiny is noticeable — especially on noisy audio and accented speech.

The base.en variant achieves around 4.3% WER on LibriSpeech test-clean and ~12.8% on test-other. This is a meaningful improvement over tiny.en (5.6% and 14.9% respectively), particularly on challenging audio.

Base is a good choice for low-power devices where tiny is not quite accurate enough. It is also popular for real-time transcription pipelines where you want a balance of speed and quality without going above 500 MB of RAM.

Small is where Whisper starts to feel genuinely accurate. At 244M parameters, it represents a 3.3x jump from base and delivers a significant accuracy improvement — especially for non-English languages and noisy recordings. The GGML file is 466 MiB, and runtime RAM usage is around 852 MB. It runs at about 4x the speed of large.

The small.en variant reaches about 3.0% WER on LibriSpeech test-clean — a remarkable result for a model that fits in under 500 MB. For many English-only use cases, small.en provides accuracy that is close to medium at a fraction of the resource cost.

Small is often recommended as the default model for most users. It runs well on any modern laptop (including MacBook Air M1 with 8 GB RAM), delivers good accuracy across languages, and transcribes fast enough for real-time dictation workflows.

Medium is where diminishing returns begin to set in — but the accuracy gains over small are still meaningful, especially for multilingual transcription, technical vocabulary, and challenging audio conditions. At 769M parameters, it requires 1.5 GiB of disk space (GGML) and about 2.1 GB of RAM at runtime.

The medium.en model achieves around 3.0% WER on LibriSpeech test-clean and approximately 7.5% on test-other. However, across broader benchmarks — particularly those with diverse accents, background noise, and domain-specific vocabulary — medium consistently outperforms small.

Medium is a strong choice for professional transcription workflows where accuracy matters but you do not have the hardware (or patience) for large. It runs well on machines with 8 GB or more of RAM and benefits significantly from GPU acceleration.

The large model is the most accurate Whisper variant, with 1.55 billion parameters. There are three versions: large-v1 (the original release), large-v2 (trained for 2.5x more epochs with added regularization), and large-v3 (trained on more data with 128 Mel frequency bins instead of 80). Large-v3 is the current recommended version for maximum accuracy.

large-v2 vs large-v3

Which large model to use: For new projects, use large-v3. It is strictly better than large-v2 on average across languages. However, some users have reported that large-v2 produces fewer hallucinations (generating text not present in the audio) in specific edge cases with very quiet or silent audio segments. If you encounter hallucination issues with large-v3, try large-v2 as a fallback.

The turbo model is a distilled version of large-v3 that dramatically reduces inference time while retaining most of the accuracy. OpenAI achieved this by pruning the decoder from 32 layers down to just 4 layers — cutting the parameter count from 1,550M to 809M. The encoder (which does the heavy lifting) remains identical to large-v3.

Turbo is the best choice when you want near-large-v3 accuracy but cannot afford the latency of the full large model. On GPU with optimizations like torch.compile, turbo can achieve up to 4.5x speed improvement over standard inference, making it extremely fast.

For the tiny, base, small, and medium sizes, Whisper offers two variants: a multilingual model and an English-only (.en) model. The large and turbo models are multilingual only — there are no English-only versions.

The performance gap between .en and multilingual models is most significant at smaller sizes. For tiny and base, the .en variants are noticeably better at English. By the time you reach small and medium, the difference narrows considerably. At the large level, there is only a multilingual model — and it performs excellently on English regardless.

The hardware you need depends heavily on the model size and whether you are using whisper.cpp (CPU/Metal/CUDA) or the PyTorch implementation (GPU-focused). Here is what to expect on common hardware classes.

whisper.cpp Acceleration Backends

whisper.cpp — the C/C++ port that most desktop apps use — supports several hardware acceleration backends that can dramatically improve performance:

Approximate Transcription Speed

Real-time factor (RTF) for a 60-second audio clip. RTF < 1.0 means faster than real-time. These are rough estimates — actual performance depends on audio content, model quantization, and system load.

OpenWhispr is an open-source desktop dictation app that uses whisper.cpp under the hood. It lets you download and switch between any Whisper model directly from the settings — no command-line required. Models are downloaded once and stored locally. You can change models at any time to balance speed and accuracy for your hardware.

• Radford et al. "Robust Speech Recognition via Large-Scale Weak Supervision" (2022) — The original Whisper paper with full benchmark results.
• OpenAI Whisper GitHub Repository — Official model table, parameter counts, VRAM requirements, and relative speed figures.
• OpenAI Whisper Model Card — Official training data composition and evaluation caveats.
• whisper.cpp GitHub Repository — GGML model sizes, RAM usage, and hardware acceleration details.
• Whisper large-v2 Model Card (HuggingFace) — LibriSpeech benchmark context used in many WER comparisons.
• Whisper large-v3 Model Card (HuggingFace) — Training details, architecture changes from large-v2, and multilingual improvements.
• Whisper large-v3-turbo Model Card (HuggingFace) — Turbo architecture details, decoder pruning specifics, and performance tradeoffs.
• OpenAI Whisper Turbo Announcement (GitHub Discussion #2363) — Official turbo release notes and cross-language performance comparisons.
• OpenWhispr — Practical local deployment context for choosing model sizes.