🎙️ Run Whisper Locally: Free Offline Transcription (2026)

I transcribe every podcast pull and scratch voiceover for this site with Whisper running on my own desk, not an API bill — and the only question that actually matters before you copy any install command is whether the model ends up talking to a GPU or a CPU. That alone swings your wait time 10x or more.

By the numbers

• large-v3-turbo needs about 6GB of VRAM against large-v3's ~10GB, and runs roughly 8x the baseline speed in OpenAI's own relative-speed table, for an accuracy hit most independent write-ups land around 1-2% WER (openai/whisper)
• The entire turbo trick is trimming the decoder from 32 layers down to 4 — less a diet than an amputation, and the accuracy barely notices
• On an RTX 4090, large-v3 processes roughly 7 seconds of compute per minute of audio; the same file on a plain Intel i9 CPU runs closer to 150 seconds per minute, more than 20x apart (aggregated GPU/CPU benchmark data)
• faster-whisper's own published CPU benchmark (small model, 8 threads) transcribed a 13-minute file in 2 minutes 37 seconds, against 6 minutes 58 seconds for stock openai/whisper on identical hardware (SYSTRAN/faster-whisper)

Install faster-whisper, not the original package

Two implementations share the Whisper name. openai/whisper is the reference code Whisper first shipped with. faster-whisper rebuilds the inference engine on CTranslate2 and is what I actually run day to day: same MIT-licensed model weights, meaningfully less waiting. Install is one line:

pip install faster-whisper

You'll also need ffmpeg on your PATH (brew install ffmpeg, apt install ffmpeg, or a static build added manually on Windows). Then:

from faster_whisper import WhisperModel

model = WhisperModel("large-v3-turbo", device="cuda", compute_type="float16")
segments, info = model.transcribe("podcast.mp3", beam_size=5)

for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

No GPU? Swap in device="cpu" and compute_type="int8". CTranslate2 doesn't do float16 math on CPU, and that mismatch is the single most common first-run crash I see people hit.

large-v3 or large-v3-turbo? The choice that actually matters

Model	Params	VRAM	Relative speed	Pick it when
tiny	39M	~1GB	~10x	Real-time captions, accuracy is secondary
base	74M	~1GB	~7x	Quick drafts, English-only
small	244M	~2GB	~4x	CPU-only boxes, patience available
medium	769M	~5GB	~2x	Rarely; turbo beats it on both axes
large-v3	1550M	~10GB	1x (baseline)	Rare languages, heavy accents, max accuracy
large-v3-turbo	809M	~6GB	~8x	Everything else, my default

I run turbo for almost everything that crosses my desk: English podcast pulls, YouTube scripts, meeting notes. Full large-v3 only comes out for a language turbo handles worse, or a recording rough enough that the extra accuracy earns its keep. If you're batching hundreds of English files and don't need millisecond-precise timestamps, distil-large-v3 is worth a look too. It trades a bit more accuracy for speed on top of turbo.

What a real file actually costs you: CPU vs GPU

Hardware	Seconds per minute of audio	A 10-minute file
RTX 4090	~7s	~70 seconds
RTX 3090	~12-22s	2-3.7 minutes
RTX 4060 Ti 16GB	~18s	~3 minutes
RTX 3060 12GB	~35s	~5.8 minutes
Intel i9 CPU (large-v3)	~150s	~25 minutes

Large-v3, aggregated from published GPU/CPU benchmarks (source). Twenty-five minutes for a ten-minute file is plenty of time to reconsider skipping the GPU line in your budget.

My own 4080 isn't on anyone's official chart. It's the same generation as the 4060 Ti and the 4090, with more silicon than the Ti and less than the 4090, closer to the fast end of that range than the middle. I won't invent a decimal I haven't personally measured.

Notice what's missing from that table: a 10-minute file finishing in under 90 seconds on CPU alone. It doesn't, not with large-v3. The one CPU number faster-whisper actually publishes (small model, 8 threads, 13-minute file in 2m37s) scales to roughly 2 minutes for a 10-minute file, not 90 seconds. Under 90 seconds is real. It's just an RTX 4090 number, not a CPU one. I go deeper on where the marketed speedup holds up and where it quietly doesn't in the faster-whisper vs openai-whisper breakdown.

Mistakes that cost you the first hour

• Missing ffmpeg. The error rarely says so directly.
• compute_type="float16" on a CPU-only box. Use int8 instead.
• Leaving language auto-detection on when you already know the language. Passing language="en" skips a real, measurable detection pass.
• Defaulting to large-v3 out of habit. Turbo is faster and, for most content, close enough that you won't hear the difference.

Where this fits into a bigger stack

Whisper is the "hear" half of a local voice setup. Pair it with Kokoro or Piper for the "speak" half, or feed the transcript straight into a local model through Ollama for summaries that never leave your machine. Want the whole loop wired into an actual voice assistant instead of a batch script? That's the Home Assistant build.

How I picked these numbers

Every timing figure above traces back to a published source: OpenAI's own model table, SYSTRAN's faster-whisper README benchmark, or an aggregated GPU roundup I cross-checked against more than one hardware tier. Where I don't have a real measurement (my own 4080, specifically) I said so instead of guessing. No fake decimals.

Once transcription is free, offline, and done before your coffee's cold, the bottleneck stops being the audio. It moves to whatever you're building with the text on the other side, and mine mostly ends up as prompts for a model that doesn't phone home either.