Local Speech to Text on Old Hardware: It Needs Less Than You Think

Whisper's own table says 10GB of VRAM. The implementation most people install runs the same model in 3.9GB of ordinary memory. Here are the real numbers.

Flat illustration of a row of vertical bars of varying heights, like an audio waveform, on a cream background
9 min read
1,879 words

Local speech to text has a reputation problem, and it comes from a table.

Open OpenAI’s Whisper repository and the first thing you meet is a models list with a column headed Required VRAM. It runs from about 1GB for the tiny model to about 10GB for large. VRAM means graphics card, a figure like 10GB means an expensive one, and a reasonable person closes the tab and goes back to paying for transcription.

That table is accurate and it is also describing a different piece of software than the one most people end up installing.

The numbers that put people off are the wrong numbers

Table from the Whisper README listing tiny through turbo with parameters, English-only and multilingual model names, required VRAM from about 1 GB to about 10 GB, and relative speed
OpenAI's Whisper README, captured 3 Nov 2026: the VRAM column is what sends people looking for a GPU, and it describes a different implementation than the one most people install.

Now look at whisper.cpp, the C++ implementation of the same models. Its table lists the same checkpoints with two columns, disk and memory, and the numbers are not in the same universe.

The tiny model is 75 MiB on disk and wants around 273 MB of memory. Base is 142 MiB and about 388 MB. Small is 466 MiB and roughly 852 MB. Medium is 1.5 GiB and about 2.1 GB. Large — the one quoted at 10GB of VRAM — is 2.9 GiB on disk and about 3.9 GB of memory.

Not video memory. Ordinary system memory, on a CPU. The gap exists because the reference implementation is a Python project whose table is written around GPU memory, while whisper.cpp runs the same weights on a CPU, with integer quantisation available on top to shrink them further.

A laptop from 2016 with 8GB of RAM can run the small model with room to spare. Whether small is accurate enough for your audio is a separate question, and the benchmark section below is the honest answer to it.

Getting local speech to text running

The repository is MIT-licensed and the path is short. Clone it, fetch a model, build, transcribe:

sh ./models/download-ggml-model.sh base.en
cmake -B build
cmake --build build -j --config Release
./build/bin/whisper-cli -f samples/jfk.wav

One constraint catches everyone exactly once: the CLI accepts 16-bit WAV files only. Anything else — an m4a voice memo, an mp3, the audio inside a video — has to be converted first, and the repository gives the line to do it:

ffmpeg -i input.mp3 -ar 16000 -ac 1 -c:a pcm_s16le output.wav

That is 16 kHz, mono, 16-bit PCM. Get one of those three wrong and you get an error, or a transcript of something that is not quite what you recorded.

The platform list is unusually long for a project like this: macOS on both Intel and Arm, iOS, Android, Linux, FreeBSD, Windows through MSVC or MinGW, WebAssembly, Raspberry Pi and Docker. The old laptop in the drawer is almost certainly on it.

Shrinking it further

If the memory figures above are still tight on the machine you have, there is one more step, and it is a single command. whisper.cpp supports integer quantisation, and the repository gives the example directly:

./build/bin/quantize models/ggml-base.en.bin models/ggml-base.en-q5_0.bin q5_0

That takes the model you downloaded and writes a quantised copy beside it. The project’s own description is plain — quantised models require less memory and disk space — and q5_0 keeps roughly five bits per weight.

The trade is accuracy, and how much you lose depends on your audio rather than on a number anyone can quote you. The practical approach is to transcribe the same two-minute clip with both files and read the two transcripts side by side. If you cannot tell which is which, keep the smaller one. That comparison takes five minutes and is worth more than any benchmark, because it is measured on the only voice that matters to you.

It is also the step that turns “this model is slightly too big for my laptop” into “this model fits”, which on ten-year-old hardware is frequently the difference between using this and not.

The Apple Silicon shortcut

If the machine is a Mac with Apple Silicon, the performance story changes enough to matter. The project describes Apple Silicon as a “first-class citizen”, optimised through ARM NEON, the Accelerate framework, Metal and Core ML.

The Core ML path is the interesting one, because it moves the encoder onto the Neural Engine — the part of the chip that otherwise sits idle — and the repository puts that at “more than x3 faster compared with CPU-only execution”. There is also an alternative encoder path called ANEForge which it describes as about 2x faster again than the Core ML encoder, from tiny through medium.

On x86 there are AVX intrinsics, and on POWER there are VSX ones. GPU backends exist for CUDA, Vulkan, ROCm, OpenVINO and several NPUs, but the point of this article is that you do not need them.

The other option, and what its numbers mean

Whisper is not the only game. NVIDIA’s Parakeet TDT 0.6B v3 is about 600 million parameters on a FastConformer encoder with a TDT decoder, covering 25 European languages with automatic language detection — you do not have to tell it which language it is hearing. It is CC-BY-4.0 and the card states it is ready for commercial or non-commercial use, which is a cleaner licence position than a lot of what this site has looked at lately — and the reason that matters is the same one that decides whether a local model is the right answer for business data.

Its stated hardware floor is modest: “At least 2GB RAM for model to load”. The card recommends Linux, lists Ampere, Blackwell, Hopper and Volta GPUs, and says it runs faster on NVIDIA GPUs than CPU-only — but it never says a GPU is required, and one of its listed runtimes is NeMo-Speech.cpp with a q8_0 GGUF, which is the same CPU-first pattern as whisper.cpp.

Two figures on that card need handling with care. It says audio up to 24 minutes with full attention and up to 3 hours with local attention — measured on an A100 80GB. Those are not laptop numbers, and reading them as a promise about your machine is the mistake the card’s own hardware section quietly warns against.

It outputs punctuated, capitalised text with word, segment and character timestamps, which is more structure than a plain transcript and matters if you are building anything that needs to jump to a moment in the audio.

How accurate is accurate

Parakeet publishes its word error rates, and the spread between them is more informative than any single number.

On LibriSpeech test-clean — studio-quality read audiobooks — it reports 1.93%. On AMI, which is recordings of real meetings, 11.31%. Earnings-22 lands at 11.42%. The Open ASR Leaderboard average across the set is 6.34%.

That range is the honest answer to “is local transcription good enough”: on clean, close-miked, one-person speech it is excellent, and on a meeting recorded by a laptop in the middle of a table it makes a mistake in roughly one word in nine.

The noise table says the same thing more precisely. The 6.34% average rises to 7.12% at a 10 dB signal-to-noise ratio and to 11.66% at 0 dB, where the background is as loud as the voice. Nearly doubling the error rate is the cost of a noisy room, and no model size fixes that — a better microphone does.

Multilingual results vary more again: Fleurs averages 11.97%, MLS 7.83% and CoVoST 11.98%, with per-language figures that range from around 3% to over 20%. OpenAI says the same thing about Whisper in plainer words, that its “performance varies widely depending on the language”.

Picking a size

Start smaller than you expect to need, because the jump in resources is steeper than the jump in quality for most jobs.

If your audio is English, use the .en variants. OpenAI’s own card notes that the English-only models tend to perform better, “especially for the tiny.en and base.en models” — the advantage shrinks at small and medium. For a 2016 laptop transcribing your own voice memos, base.en at 142 MiB and under 400 MB of memory is a sensible first try, and small.en is the upgrade when it starts mangling names.

Size costs time as well as memory, and OpenAI’s table quantifies it: relative to large, tiny runs about 10x faster, base about 7x, small about 4x and medium about 2x. Those multiples were measured on an A100 rather than your laptop, so treat them as ratios rather than durations — but the ratios hold, and they mean that stepping from base to medium is not a small decision when you have an hour of audio and a slow CPU. There is also a turbo checkpoint at 809M parameters which the table puts at about 8x — slightly faster than base in that table, with ten times the parameters behind it.

If your audio is not English, or you do not know in advance what language it will be, Parakeet’s automatic detection across 25 languages removes a step that Whisper makes you handle yourself.

And if the machine is an Apple Silicon Mac, the Core ML path means you can reach for a larger checkpoint than the CPU numbers alone would suggest — this is the same hardware advantage that Ollama’s Phonon speech models exploit in the opposite direction, turning text back into audio.

What still goes wrong

Noise is the ceiling, not model size. The numbers above make this unambiguous. Before downloading a bigger checkpoint, move the microphone closer.

Accents and languages are uneven, and both projects say so themselves rather than leaving you to discover it. Parakeet’s own per-language spread on Fleurs runs from roughly 3% to over 20% word error — which is the difference between a transcript you skim and one you retype.

Long audio is not a solved problem on small machines. Parakeet’s headline figures for 24-minute and 3-hour inputs come with an A100 attached to them, and whisper.cpp’s speed on a long recording is whatever your CPU can manage. Budget real time for an hour of audio, and run it while you do something else.

The WAV constraint is a real friction in any pipeline, because the audio you actually have is almost never 16 kHz mono PCM. Build the ffmpeg step in from the start rather than bolting it on.

Nothing here flags its own mistakes. A transcript arrives as flat text whether the model was certain or guessing, which is the same gap that makes checking an OCR result against the page a human job. If the transcript feeds something consequential, the review step is yours.

The reputation problem is the thing worth undoing here. Local transcription does not need a graphics card, a subscription or a new machine. It needs about 400 MB of memory, a quiet room and a correctly formatted WAV file, and the quiet room matters most.

Sources

Every figure in this article traces to one of these. Dates are when the page was read.

  1. ggml-org/whisper.cpp
    GitHubAccessed Nov 3, 2026Official docs
  2. openai/whisper
    OpenAIAccessed Nov 3, 2026Official docs
  3. parakeet-tdt-0.6b-v3 model card
    NVIDIAAccessed Nov 3, 2026Official docs

Written by

Kai Devlin AI Automation Engineer

Full-stack developer who builds and runs AI automation systems in production. Runs local LLMs on personal hardware, builds N8N pipelines that actually ship, and deploys on Cloudflare Pages. Every guide on Pipeline Monk is tested on real consumer hardware — a Ryzen 7 5800HS with 16GB RAM and a GTX 1650. If it works on that, it works.