Run Whisper Locally on Windows 11, Mac and Kali Linux: whisper.cpp vs faster-whisper, Which Model to Pick, Real CPU Speeds, a Local OpenAI-Compatible Server, and Parakeet

To run Whisper locally, for free and fully offline, use whisper.cpp on any computer or faster-whisper if you work in Python. On Windows 11, download whisper-bin-x64.zip (8.9 MB) from the whisper.cpp releases page plus a model file such as ggml-base.en.bin (148 MB), then run whisper-cli.exe -m ggml-base.en.bin -f talk.wav. On Mac and Linux, including Kali, build it in about three minutes with cmake. Pick base.en for English on an ordinary laptop, and large-v3-turbo only if you have a graphics card: on a modest four-core laptop CPU, base.en transcribed a 127-second recording in 98 seconds with whisper.cpp, and turbo needed over two minutes for an 11-second clip. The surprise: on that same old laptop, the Python route was the fast one. faster-whisper did the same recording, with the same words, in 31 seconds.

Jake records every supplier call on his phone, "so nobody can argue about the price later", and then never listens to them again. Ethan offered to turn the recordings into text he could search. "Not through some website," Jake said. "Those calls have prices in them." So Ethan did it on the shop's old laptop, with nothing uploaded anywhere: a free model from OpenAI called Whisper, running offline. The first transcript came back with every price right, and a supplier's name spelled three different ways.

New to running AI on your own computer? This is one of the friendliest places to start, because speech-to-text models are small compared with chat models, and the result is immediately useful: meeting notes, subtitles, searchable voice memos, interviews you never have to type up. Everything on this page runs offline once the model is downloaded, so your recordings never leave your machine. For the bigger picture of local AI, see the run-AI-locally guide series.

What Whisper is, in plain English

Whisper is a speech recognition model that OpenAI released as open source in 2022, under the MIT license, so anyone can download it and use it, commercially included. It listens to audio and writes down what was said, in about 100 languages, with punctuation. It can also translate speech in other languages into English text. It was trained on a very large amount of varied audio from the web, which is why it copes far better than older dictation tools with accents, background noise and people who do not speak like newsreaders.

The model itself is just a file of numbers. To use it you need a program that runs it, and there are three popular ones:

• openai-whisper: OpenAI's original Python package. The reference version, built on PyTorch. Simple to use, large to install, slowest on a plain CPU.
• faster-whisper: a Python reimplementation on the CTranslate2 engine. Its developers measure it at up to four times faster than the original for the same accuracy, with less memory, and it needs no separate FFmpeg install.
• whisper.cpp: Whisper rewritten in C and C++ by the same project family as llama.cpp. One small program, no Python, runs on almost anything from a Raspberry Pi to a gaming PC, with optional GPU support on NVIDIA, AMD, Intel and Apple hardware.

All three use the same Whisper models and give very similar text. The choice is about convenience and speed on your hardware, which is what most of this guide measures.

Jake: "So Whisper is the recipe, and these are three different kitchens."

Ethan: "And one of them fits in a backpack."

Which Whisper model to pick: sizes, memory and speed

Whisper comes in sizes from tiny to large. Bigger models are more accurate, especially on accents, noisy audio and less common languages, and much slower. Models ending in .en are English-only versions that are a little more accurate for English at the same size. The table combines OpenAI's published parameter counts and relative speeds with the file sizes and memory use of whisper.cpp's versions:

Two things the table does not say on its own. First, turbo is a trimmed large-v3: it keeps the big listening part of the model and cuts the writing part from 32 layers to 4. On a GPU that makes it nearly as fast as base with close to large-v3 accuracy, which is why it is OpenAI's default. On a CPU, the big listening part is exactly the slow bit, so turbo stays slow. Second, quantized versions (files with q5_0, q5_1 or q8_0 in the name) store the numbers in fewer bits: ggml-base.en-q5_1.bin is 60 MB instead of 148 MB, and on a CPU it also ran faster, as the speed table below shows. The idea is the same as for chat models; quantization trades a sliver of accuracy for size.

The short version: on a laptop without a graphics card, start with base.en (English) or base (other languages), and move to small if names and numbers come out wrong. With an NVIDIA, AMD or Apple GPU, go straight to large-v3-turbo for transcription.

Real speeds on an ordinary laptop CPU

Published benchmarks usually come from fast desktop processors or GPUs. These numbers come from the other end: a modest four-core laptop CPU from several years ago, no graphics card, whisper.cpp 1.9.5 with 4 threads, on two public speech recordings, an 11-second clip and a 127-second radio address. If your computer is newer, expect it to be faster, often by several times; the ratios between models are the useful part.

The errors are worth seeing, because they are the kind you will meet. On the radio address, tiny.en wrote "After months of spirited debate in vigorous campaigning" (the speaker said "and"), "about our nation's future and encourage all Americans" (he said "future. I encourage") and "whether they are richer, poor, older, young" (he said "rich or poor, old or young"). base.en slipped twice, more quietly: "it is always required brave defenders" for "it has always required", and "the example that our election set" for "elections". The quantized base.en-q5_1 and small.en wrote all 375 words correctly, and turbo missed one ("had been made" for "have been made").

That the smaller quantized file beat the full-size one here is luck on one recording, not a rule; on another voice it could go the other way. The rule that holds is simpler: tiny is for rough drafts, base is for your own notes, and anything you will quote, publish or bill a client for needs small or larger, or a check by ear.

whisper.cpp also reports where the time goes. Whisper listens in 30-second windows, and nearly all the time is spent "encoding" each window: about 2.7 seconds per window for tiny, 7 for base, 5 for the quantized base, 31 seconds for small and over two minutes for turbo, against a fraction of a second for writing the words out. That is why turbo's shortcut, a smaller writing part, saves so little on a CPU, and why a GPU, which does the encoding many times faster, changes the picture completely.

Install whisper.cpp on Linux and Kali (three minutes)

whisper.cpp builds with a C++ compiler and CMake, both standard on Linux. On Kali, Debian or Ubuntu, install the tools once with sudo apt install build-essential cmake git ffmpeg, then:

git clone --depth 1 https://github.com/ggml-org/whisper.cpp
cd whisper.cpp
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j --config Release       # about 3 minutes on 4 cores

sh ./models/download-ggml-model.sh base.en      # 148 MB, from Hugging Face
./build/bin/whisper-cli -m models/ggml-base.en.bin -f samples/jfk.wav

The build tunes itself to your processor (the configure step prints Adding CPU backend variant ggml-cpu: -march=native) and produces whisper-cli for files, whisper-server for a local web API, whisper-bench, whisper-quantize and a few more in build/bin. The download script fetches models from the project's Hugging Face repository, huggingface.co/ggerganov/whisper.cpp; the same files work on every operating system, so you can download once and copy them around. The last command prints:

[00:00:00.000 --> 00:00:11.000]   And so my fellow Americans, ask not what your country can do for you, ask what you can do for your country.

Despite an older note in the project's README saying the command-line tool only takes 16-bit WAV, the current whisper-cli reads more than that. It decoded samples/jfk.mp3, an Ogg Vorbis radio recording and a 44.1 kHz stereo WAV directly, with the same text as from the 16 kHz WAV:

$ ./build/bin/whisper-cli -m models/ggml-base.en.bin -f samples/jfk-44k-stereo.wav -nt
read_audio_data: trying to decode with miniaudio
main: processing 'samples/jfk-44k-stereo.wav' (176000 samples, 11.0 sec), 4 threads, ...
 And so my fellow Americans, ask not what your country can do for you, ask what you can do for your country.

The help text lists flac, mp3, ogg, wav. For anything else, such as phone recordings in M4A, a WhatsApp voice note or a video file, convert first with FFmpeg into the format Whisper uses internally, 16 kHz mono 16-bit:

ffmpeg -i call.m4a -ar 16000 -ac 1 -c:a pcm_s16le call.wav

Useful options, all shown by whisper-cli -h: -t 4 sets the number of CPU threads (match your physical cores), -l auto detects the language with a multilingual model, -l de forces German, -otxt, -osrt, -ovtt and -oj write text, subtitle and JSON files next to the input (-of name chooses the file name), and -nt drops the timestamps from the screen output. To shrink a model yourself, ./build/bin/whisper-quantize models/ggml-base.en.bin models/ggml-base.en-q5_0.bin q5_0, or download ready-made quantized files with the script (for example base.en-q5_1 or large-v3-turbo-q5_0).

On Kali, the same steps work in a virtual machine and on a live USB with persistence. If a Python step anywhere in this guide fails with externally-managed-environment, that is Kali protecting its system Python, and the pip fix shows the virtual environment way around it. whisper.cpp itself needs no Python at all.

If you would rather not build anything, the same release page that has the Windows zips (next section) also has whisper-bin-ubuntu-x64.tar.gz and an ARM64 version. Despite the name, the x64 one ran on Kali as it was, picking the right processor library by itself:

$ tar xzf whisper-bin-ubuntu-x64.tar.gz
$ cd whisper-bin-ubuntu-x64 && ./whisper-cli -m ggml-base.en.bin -f jfk.wav
load_backend: loaded CPU backend from ./libggml-cpu-haswell.so
[00:00:00.000 --> 00:00:11.000]   And so my fellow Americans, ask not what your country can do for you, ask what you can do for your country.

Run Whisper on Windows 11 without installing anything

On Windows, you do not need to build anything. The whisper.cpp project publishes ready-made Windows programs with every build. One detail trips people up: the version-numbered releases, such as v1.9.5, now come with no download files attached. The programs are on the matching build release published alongside it, named with a b and a number (b5454 for v1.9.5). On that release page, pick:

• whisper-bin-x64.zip (8.9 MB): CPU only, works on any 64-bit Windows PC. Start here.
• whisper-blas-bin-x64.zip (21.7 MB): CPU with the OpenBLAS math library, sometimes faster on long files.
• whisper-bin-win-cuda-12.4.0-x64.zip (685 MB) or whisper-bin-win-cuda-11.8.0-x64.zip (285 MB): NVIDIA graphics cards. Choose 12.4 for current drivers.
• whisper-bin-win-cpu-arm64.zip: Windows on ARM laptops, such as Snapdragon Copilot+ PCs.

Unzip it to a folder such as C:\whisper. The programs are not at the top of the zip: they unpack into a Release folder inside it, next to the DLL files they need, so that is the folder to work in. Download a model file into it from the Hugging Face repository above (for example ggml-base.en.bin), and in PowerShell:

cd C:\whisper\Release
.\whisper-cli.exe -m ggml-base.en.bin -f C:\Users\you\Music\call.wav -otxt -osrt

That writes call.wav.txt and call.wav.srt beside the recording. If PowerShell says it does not recognize whisper-cli.exe, you are one folder too high, in C:\whisper instead of C:\whisper\Release. Windows SmartScreen may warn about an unrecognized program the first time; the files come from the project's official GitHub releases, which is the only place to get them. If you prefer Python on Windows, pip install faster-whisper works there too (next sections), and for NVIDIA acceleration on Windows faster-whisper also needs NVIDIA's cuBLAS and cuDNN libraries.

Run Whisper on a Mac

On Apple Silicon Macs (M1 and later), whisper.cpp is at its best: it runs the model on the Mac's GPU through Metal automatically, with no extra settings. Install Apple's command-line tools (xcode-select --install) and CMake (from cmake.org or a package manager), then use exactly the build commands from the Linux section. The project also documents an optional Core ML build that runs the listening part of the model on the Mac's Neural Engine, which it measures at more than three times faster than CPU-only; it needs a one-time model conversion with Python tools, so try the plain build first and add Core ML only if you transcribe a lot.

faster-whisper also installs on a Mac with pip, but it runs on the CPU only there, because its engine does not use Apple's GPU. On an M-series Mac, whisper.cpp is usually the faster choice.

faster-whisper in Python, with timestamps and voice detection

If you want to call Whisper from your own scripts, faster-whisper is the most practical package. Install it in a virtual environment:

python3 -m venv whisper-env
source whisper-env/bin/activate        # Windows: whisper-env\Scripts\activate
pip install faster-whisper              # 1.2.1 in October 2026, Python 3.9+

It pulls in CTranslate2 (the engine), PyAV (which bundles the FFmpeg libraries, so MP3, M4A and video files just work without installing FFmpeg), ONNX Runtime (for the voice detector) and the Hugging Face downloader. A first script:

from faster_whisper import WhisperModel

model = WhisperModel("base.en", device="cpu", compute_type="int8", cpu_threads=4)
segments, info = model.transcribe("call.mp3", beam_size=5)

print(f"Language: {info.language} ({info.language_probability:.0%}), {info.duration:.0f} s")
for s in segments:
    print(f"[{s.start:6.1f} -> {s.end:6.1f}] {s.text}")

The first run downloads the model from Hugging Face (the CTranslate2 conversions published by SYSTRAN) into your Hugging Face cache, ~/.cache/huggingface/hub; later runs work offline. Model names are the familiar ones: tiny.en, base, small.en, medium, large-v3, large-v3-turbo (or simply turbo), and distil-large-v3. compute_type="int8" is the right choice on a CPU; on an NVIDIA GPU use device="cuda", compute_type="float16".

On the first run it prints Language: en (100%), 127 s and then each segment with its start and end time. And on an older processor it is quick. On the same four-core laptop as the speed table above, with compute_type="int8" and 4 threads, it was two and a half to four times faster than whisper.cpp with the same models, and the words matched: base.en made the same two slips in both programs, and small.en none.

On a newer processor the gap may shrink or even flip, so if speed matters to you, time both on one of your own recordings; it takes five minutes. The times exclude the one-off model download. Jake's verdict on the table: "So the slow kitchen was the fast one."

Three options are worth knowing from day one. vad_filter=True runs a small voice-activity detector first and skips silence, which saves time on recordings with long pauses and prevents the invented text Whisper sometimes writes into silence. word_timestamps=True gives you the start and end time of every word, for karaoke-style subtitles or for jumping to a word in a long recording. And BatchedInferencePipeline wraps the model to process several windows at once; on a GPU it is the single biggest speed-up, at the cost of more memory.

The original openai-whisper package

OpenAI's own package is the reference everything else is compared with, and the easiest to use from a terminal once installed:

pip install -U openai-whisper           # version 20250625 is the current release
whisper call.mp3 --model turbo           # turbo is the default model
whisper interview.m4a --model small --language Spanish --task translate

It has two requirements the others avoid. It needs the ffmpeg program installed separately (sudo apt install ffmpeg on Kali, brew install ffmpeg on a Mac, choco install ffmpeg or scoop install ffmpeg on Windows), and it installs PyTorch, which is a download of several hundred megabytes on its own and more with GPU support. Its tokenizer occasionally needs the Rust compiler on unusual platforms. On a CPU it is also the slowest: in faster-whisper's published comparison, the small model took 6 minutes 58 seconds on 13 minutes of audio with openai-whisper, against 2 minutes 5 seconds with whisper.cpp and 1 minute 42 seconds with faster-whisper in int8, on an 8-thread desktop CPU. Use it if you are following a tutorial or a research paper that uses it; otherwise faster-whisper gives the same results sooner.

whisper.cpp vs faster-whisper vs openai-whisper

Ethan's choice for the shop: faster-whisper with small.en on the old laptop for the daily calls, because on that machine it was the fastest way to get every word right, and whisper.cpp's Windows zip on Jake's own PC for the odd recording, because it needs nothing installed. For the one big job, a two-hour training video, a friend's gaming PC with a graphics card turned hours into minutes.

Using a graphics card

A GPU is where Whisper becomes fast enough to transcribe hours of audio while you make coffee. How you enable it depends on the program:

• whisper.cpp with NVIDIA: install the CUDA toolkit, then build with cmake -B build -DGGML_CUDA=1. On Windows, the CUDA zip from the releases page already includes what it needs.
• whisper.cpp with AMD, Intel or older NVIDIA cards: build with -DGGML_VULKAN=1 (any card whose driver supports Vulkan), or -DGGML_HIP=1 plus -DAMDGPU_TARGETS= set to your card's code (such as gfx1201) with AMD's ROCm installed.
• whisper.cpp on Apple Silicon: Metal is on by default; nothing to do.
• faster-whisper: NVIDIA only. It needs NVIDIA's cuBLAS and cuDNN 9 libraries for CUDA 12; on Linux, pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.* plus an LD_LIBRARY_PATH line from its documentation is the quickest route. Older setups with CUDA 11 or cuDNN 8 need an older CTranslate2 (3.24.0 for CUDA 11, 4.4.0 for CUDA 12 with cuDNN 8).

The most common GPU error in faster-whisper comes from asking for the GPU on a machine that cannot provide one. With device="cuda" on a laptop without an NVIDIA card, loading the model fails with:

RuntimeError: CUDA failed with error CUDA driver version is insufficient for CUDA runtime version

Despite the wording, on a computer without an NVIDIA card no driver update will help; use device="cpu", compute_type="int8". On a computer that does have one, it means what it says: the NVIDIA driver is older than the CUDA version the libraries need, so update the driver. The opposite mistake, compute_type="float16" on a CPU, stops with ValueError: Requested float16 compute type, but the target device or backend do not support efficient float16 computation. The pairing to remember: int8 on processors, float16 on NVIDIA cards.

For scale: faster-whisper's own GPU benchmark, 13 minutes of audio with the large-v2 model on an 8 GB RTX 3070 Ti, took 1 minute 3 seconds in float16, and 16 to 17 seconds with batching. If your machine has a GPU and Whisper is still slow, the program is probably running on the CPU without saying so, the same trap covered for chat models in Ollama not using the GPU.

Translating speech to English, and why turbo will not

Whisper can listen to French, Hindi or Japanese and write English. In whisper.cpp add -tr (with a multilingual model such as small or medium, not a .en one); in openai-whisper add --task translate; in faster-whisper pass task="translate". One model is the exception: turbo was not trained for translation, and with --task translate it returns the original language instead of English. For translation, use medium or large-v3. For transcription in the original language, turbo is excellent.

Language detection works the same way: a multilingual model listens to the first 30 seconds and guesses. On short or mixed-language clips the guess can be wrong, so if you know the language, say it (-l es, --language Spanish, language="es"). It is faster too.

Run Whisper as a local API server

whisper.cpp includes whisper-server, a small web server that accepts audio files and returns text, so other programs on your computer can use Whisper without loading the model every time. Start it with a model:

./build/bin/whisper-server -m models/ggml-base.en-q5_1.bin --host 127.0.0.1 --port 8178 -t 4

Without --port it listens on 8080. Then send it a file from any terminal:

curl 127.0.0.1:8178/inference -F file=@call.wav -F response_format=text

response_format can be json, text, srt, vtt or verbose_json, which adds per-segment timings. MP3 uploads worked as they were. An M4A upload did not: the server answered Invalid request with HTTP status 400 and logged error: failed to decode audio data from memory buffer. Starting the server with --convert makes it convert any format first, as long as FFmpeg is installed. The same 400 comes back when the form field is not named file; the server log then says no 'file' field in the request.

To make it a drop-in replacement for OpenAI's speech-to-text API, add --inference-path /v1/audio/transcriptions to the start command. Then the official OpenAI Python library talks to your own computer instead:

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:8178/v1", api_key="local")
with open("call.wav", "rb") as f:
    result = client.audio.transcriptions.create(model="whisper-1", file=f)
print(result.text)

The API key can be any text and the model name any name; the server uses the model it was started with. Two cautions. With an English-only model, verbose_json reports a meaningless detected_language (it said "dutch", with a probability of 0.01, for an American president's speech), so trust its language field instead. And the server has no password: keep --host 127.0.0.1 unless you deliberately want other machines on your network to use it, and never expose it to the internet.

Ethan: "Any app that knows how to talk to OpenAI can now talk to the laptop."

Jake: "And the laptop doesn't send an invoice."

Getting better transcripts: the settings that matter

1. Use the right size. If names, numbers or accents come out wrong, go up one model size before changing anything else.
2. Set the language instead of relying on detection, especially for short clips.
3. Give it the spelling of names. An initial prompt (--prompt in whisper.cpp, initial_prompt= in faster-whisper and openai-whisper) such as "Call with Hartley Timber about oak, walnut and birch" nudges the spelling of names and terms. This is how Ethan fixed the supplier name that came out three ways.
4. Cut silence and music. Whisper was trained to always write something, so on long silences or background music it can invent a short line of text. Voice detection (vad_filter=True in faster-whisper, or whisper.cpp's Silero VAD options) removes those stretches before Whisper hears them.
5. Record closer to the mouth. A phone held near the speaker beats an expensive microphone across the room. Whisper is robust, but distance and echo still cost accuracy.
6. Keep the beam search on. The default beam_size=5 considers several candidate sentences; turning it down to 1 is faster and slightly sloppier.

Jake: "So the trick for the supplier's name was telling it the name."

Ethan: "Same as with a new employee. Tell them who they're going to meet."

Whisper vs Parakeet: the newcomer whisper.cpp can also run

Parakeet TDT 0.6B v3 is NVIDIA's open speech recognition model, published in August 2025 under the CC-BY-4.0 license, which allows commercial use with attribution. It has 600 million parameters, handles English and 24 other European languages (Russian and Ukrainian included) with automatic language detection, and writes punctuation, capital letters and word timestamps. It does not translate, and it does not cover Asian, Indian or African languages, where Whisper remains the choice. whisper.cpp 1.9.5 builds a separate parakeet-cli program next to whisper-cli, and ready-converted model files are on Hugging Face in ggml-org/parakeet-GGUF: ggml-parakeet-tdt-0.6b-v3-q8_0.bin is 669 MB, the q4_0 version 356 MB.

./build/bin/parakeet-cli -m models/ggml-parakeet-tdt-0.6b-v3-q8_0.bin -f samples/gb0.wav -t 4

On the same laptop, Parakeet transcribed the 11-second clip in 18 seconds and the 127-second radio address in 103 seconds, and it wrote all 375 words of the long recording correctly, with punctuation as tidy as small.en's. That is small.en's accuracy in under a third of small.en's time, at about base.en's speed. For English and the European languages it covers, it is the strongest offline option in whisper.cpp on a CPU; for anything else, or for translation, stay with Whisper. Test both on your own audio, because accents and microphones change the ranking more than any benchmark.

What running Whisper locally costs, against the cloud

The software is free and open source, the models are MIT-licensed, and nothing is billed per minute. Your costs are electricity and, if you want speed, a graphics card you may already own. Cloud speech-to-text services charge per minute of audio and are worth it when you need live streaming, speaker labels or a guarantee someone else keeps it running; for those, Mistral Voxtral 3 and MAI-Transcribe-2 compare prices against Whisper. For private recordings such as Jake's supplier calls, medical dictation or legal interviews, local transcription also settles the privacy question completely, because the audio never leaves the machine. If you need something far smaller than Whisper for a phone or a tiny device, Cactus Whistle runs in 17 MB.

Common errors and their fixes

Find the message on your screen below; each one is quoted exactly as the programs print it.

error: model file not found 'models/ggml-base.bin'
The model name in the command does not match the file you downloaded. The download script saves ggml-<name>.bin, so after download-ggml-model.sh base.en the file is ggml-base.en.bin, not ggml-base.bin. Run ls models and copy the exact name.

whisper_model_load: invalid model data (bad magic), followed by error: failed to initialize whisper context
The file is not a model. The usual cause is a browser "Save link as" on the Hugging Face page, which saves a small web page with a .bin name. A real ggml-base.en.bin is 148 MB; if yours is a few kilobytes, download it again with the script or the file's direct download link.

error: failed to read audio file 'call.m4a'
whisper-cli reads WAV, MP3, FLAC and OGG only. Convert with ffmpeg -i call.m4a -ar 16000 -ac 1 -c:a pcm_s16le call.wav.

main: WARNING: model is not multilingual, ignoring language and translation options
You asked an English-only .en model for another language (-l de) or for translation (-tr). It quietly transcribes in English instead. Download a multilingual model such as base or small. faster-whisper does the same, with The current model is English-only but the language parameter is set to 'de'; using 'en' instead.

ValueError: Invalid model size 'large-v4', expected one of: tiny.en, tiny, base.en, base, ...
There is no Whisper model by that name. The message lists every valid one, including large-v3-turbo (or turbo) and the distil- models.

InvalidDataError: [Errno 1094995529] Invalid data found when processing input
faster-whisper could not decode the file: it is not audio, or the download or recording is broken. Try playing it in a media player first; if that fails too, the file is the problem, not Whisper.

FileNotFoundError: [Errno 2] No such file or directory
The path is wrong. On Windows, use a raw string such as r"C:\Users\you\Music\call.mp3" so the backslashes are not read as escape codes.

RuntimeError: CUDA failed with error CUDA driver version is insufficient for CUDA runtime version and ValueError: Requested float16 compute type ...
GPU settings on a machine without a usable NVIDIA GPU, or float16 on a CPU. See the GPU section.

Invalid request (HTTP 400) from whisper-server
The upload is not a format the server can read (start it with --convert), is not audio at all, or was sent in a form field not named file.

Text appears in a silent stretch, or a phrase repeats over and over
Whisper was trained to always write something, so silence and music invite invented lines. Turn on voice detection (vad_filter=True in faster-whisper) and set the language.

The two-minute checklist

1. Windows: whisper-bin-x64.zip from the latest b-numbered whisper.cpp release, plus ggml-base.en.bin.
2. Linux, Kali or Mac: clone whisper.cpp, cmake -B build, cmake --build build -j, download a model with the script.
3. Python: pip install faster-whisper in a virtual environment; compute_type="int8" on a CPU.
4. No GPU: base.en or base; small if accuracy matters more than time. GPU: large-v3-turbo.
5. Translation to English: small, medium or large-v3, never turbo.
6. Set the language, add an initial prompt with names, and turn on voice detection for long recordings.
7. Subtitles: -osrt or -ovtt in whisper.cpp.

Frequently asked questions

Jake's calls now land in a folder as text files a few minutes after he gets back to the shop, and he searches them the way he searches email. The supplier who swore he had quoted a lower price for walnut had not, and the transcript, with its timestamp, ended the argument in one message. "The best part," Jake said, "is that it never asked me to sign up for anything." Ethan pointed at the laptop's fan. "It's charging you in noise instead."

Revision note. Written October 23, 2026, with whisper.cpp 1.9.5, faster-whisper 1.2.1 and openai-whisper 20250625, and timings from a four-core laptop CPU without a GPU. "Slow and steady wins the race," the proverb says, and on an old laptop, base.en is the steady one.