Key Takeaways
- Created by Georgi Gerganov in 2022; today maintained under the ggml-org GitHub organization.
- MIT license β free to use, modify, and redistribute, including commercially.
- Runs on CPU, Apple Metal/Core ML, NVIDIA CUDA, Vulkan, OpenVINO, AMD ROCm, and Ascend NPU backends.
- No Python runtime required β ships as a compiled C/C++ binary with optional Python bindings.
- Supports real-time microphone transcription via its stream example, in addition to batch file transcription.
- Latest stable release: v1.9.3, published August 20, 2026.
π In One Sentence
whisper.cpp is a free, MIT-licensed C/C++ port of OpenAI's Whisper speech-to-text model, created by Georgi Gerganov, that transcribes audio entirely on-device across CPU, Apple Metal, NVIDIA CUDA, and other backends with no Python required.
π¬ In Plain Terms
It turns spoken audio into text on your own computer or device instead of sending it to a cloud API β you download a compiled binary or build it yourself, feed it an audio file or a live microphone stream, and it gives you back a transcript, for free, using the same Whisper models OpenAI trained.
πNote: This review focuses on whisper.cpp as a standalone tool: its history, installation, real commands, licensing, and honest limits. For a head-to-head benchmark against faster-whisper on Apple Silicon and NVIDIA GPUs, see the whisper.cpp vs faster-whisper comparison.
History: Who Built Whisper.cpp and Why
OpenAI released Whisper, its automatic speech recognition model, in September 2022 as an open-weight model trained on a large amount of multilingual audio, distributed as a Python package (openai-whisper) that depends on PyTorch and, for good performance, a CUDA-capable GPU.
Georgi Gerganov ported the model to plain C/C++ shortly after, in 2022, under the ggml-org/whisper.cpp repository. Gerganov is also the creator of the ggml tensor library that underpins whisper.cpp's math and quantization, and later became known for llama.cpp, the equivalent C/C++ port for running large language models locally β the two projects share the same ggml foundation and the same design goal: run a model that normally needs Python and a GPU on ordinary hardware instead.
The motivation was portability and resource efficiency, not just speed. The original Python/PyTorch implementation of Whisper is straightforward to run on a workstation with a good GPU, but heavy to deploy on a Raspberry Pi, an iOS app, a WebAssembly page, or an embedded Linux board with no Python interpreter at all. whisper.cpp removes the PyTorch and Python dependency entirely, compiles down to a small binary, and adds quantization support so smaller model variants fit in a few hundred megabytes of RAM.
The project has grown well beyond a single-author side project. It now has hundreds of contributors, is packaged for Debian, and ships official support for Core ML (Apple Neural Engine), CUDA, Vulkan, OpenVINO, and other backends that did not exist in the original 2022 release. It remains a Whisper *runtime* β it does not train or fine-tune its own models, and every transcription still uses the same weights OpenAI published for a given model size (tiny through large-v3), converted into the project's GGML format.
Who created whisper.cpp?
Georgi Gerganov created whisper.cpp, first publishing it in 2022 as a C/C++ port of OpenAI's Whisper model. Gerganov also created the ggml tensor library it runs on and later created llama.cpp, the equivalent local-inference port for large language models.
What Whisper.cpp Actually Does
whisper.cpp takes an audio input β a file (WAV, and other formats via optional FFmpeg decoding) or a live microphone stream β and produces a text transcript, optionally with per-segment timestamps and translation into English. It does this by loading a Whisper model (converted to the project's GGML weight format) and running inference through the ggml tensor library, entirely on the local machine.
- Batch transcription. Point the
whisper-clibinary at an audio file and get back a transcript, with options for output as plain text, SRT/VTT subtitles, JSON, or CSV. - Real-time streaming. The
whisper-streamexample captures live microphone audio and transcribes it continuously, useful for voice assistants or live captioning. - Multilingual transcription and translation. Whisper's underlying models were trained on many languages; whisper.cpp can transcribe in the source language or translate directly to English, depending on the flags passed.
- Hardware-accelerated inference. On Apple Silicon, whisper.cpp can export models to Core ML format to use the Apple Neural Engine; on NVIDIA hardware it uses CUDA; on other GPUs it can use Vulkan or OpenVINO. On CPU-only machines, it uses AVX2 (x86) or NEON (ARM) vector instructions.
- Quantization. Models can be quantized (for example to 4-bit or 5-bit GGML formats) to trade a small amount of accuracy for significantly lower memory use and faster inference β the same technique llama.cpp uses for LLMs.
Install and Run Whisper.cpp: Step by Step
This walkthrough builds whisper.cpp from source and runs a first transcription, using the commands documented in the project's own README.
- 1Clone the repository.
Why it matters: Run `git clone https://github.com/ggml-org/whisper.cpp.git` followed by `cd whisper.cpp`. This pulls the full C/C++ source tree, including the CMake build files and model-download script. - 2Download a model.
Why it matters: Run `sh ./models/download-ggml-model.sh base.en` to fetch the English-only base model in GGML format. Swap `base.en` for `tiny`, `small`, `medium`, or `large-v3` depending on the accuracy/speed trade-off you want, or drop the `.en` suffix for a multilingual model. - 3Build the project.
Why it matters: Run `cmake -B build` followed by `cmake --build build -j --config Release`. This compiles the CLI binaries (`whisper-cli`, `whisper-stream`, and others) into the `build/bin/` directory. No Python installation is required for this step. - 4Transcribe a sample file.
Why it matters: Run `./build/bin/whisper-cli -f samples/jfk.wav` using the sample audio file bundled with the repository. This confirms the build works end-to-end and prints a transcript to the terminal. - 5Transcribe your own audio.
Why it matters: Replace the sample path with your own WAV file: `./build/bin/whisper-cli -m models/ggml-base.en.bin -f your-audio.wav`. Add `-osrt` to also write an `.srt` subtitle file, or `-oj` for JSON output. - 6(Optional) Enable GPU acceleration.
Why it matters: On Apple Silicon, Metal acceleration is used automatically once built with the default CMake flags on macOS. On an NVIDIA machine, add `-DGGML_CUDA=ON` to the `cmake -B build` step (requires the CUDA toolkit installed) to build with CUDA support. - 7(Optional) Try real-time transcription.
Why it matters: Build the streaming example and run `./build/bin/whisper-stream -m models/ggml-base.en.bin` to transcribe live microphone audio continuously instead of a fixed file.
Real Usage Examples
Beyond the basic install walkthrough above, these are common real-world invocations of the whisper-cli binary.
- pywhispercpp provides Python bindings for whisper.cpp for teams that want the Metal/CUDA acceleration but still prefer to call it from Python code rather than shelling out to the CLI binary.
- whisper.cpp also ships a small local HTTP server example (
whisper-server) for teams that want to send audio over HTTP instead of invoking the CLI per file β useful for wiring whisper.cpp into an existing service without a Python dependency.
# Transcribe an audio file to plain text (default output)
./build/bin/whisper-cli -m models/ggml-base.en.bin -f interview.wav
# Transcribe and output SRT subtitles, using the larger, more accurate model
./build/bin/whisper-cli -m models/ggml-large-v3.bin -f lecture.wav -osrt
# Translate non-English speech directly into English text
./build/bin/whisper-cli -m models/ggml-medium.bin -f french-audio.wav -tr
# Pick a specific GPU device (multi-GPU machines)
./build/bin/whisper-cli -m models/ggml-large-v3.bin -f audio.wav -g 0
# Real-time transcription from the default microphone
./build/bin/whisper-stream -m models/ggml-base.en.bin -t 8License and Cost
whisper.cpp is licensed under the MIT License β the license file in the official repository permits free use, modification, and redistribution, including in closed-source and commercial products, with no royalty and no attribution requirement beyond keeping the license notice.
There is no paid tier, subscription, or license fee for whisper.cpp itself. The only real costs are the hardware you run it on (or a cloud VM if you choose to host it) and, if you build a product on top of it, your own development time. There is no usage metering, no API key, and no vendor lock-in.
The underlying Whisper model weights are separately licensed by OpenAI under MIT as well, so both the runtime (whisper.cpp) and the model weights it loads are permissively licensed for commercial use.
Is whisper.cpp free to use commercially?
Yes. whisper.cpp is MIT-licensed, and the Whisper model weights it uses are also released by OpenAI under an MIT license. Both permit commercial use, modification, and redistribution without a fee.
What Whisper.cpp Is Not Good For
whisper.cpp is a transcription runtime, not a full conversational-AI or speaker-diarization product. It is the wrong tool for the following situations:
- Speaker diarization ("who said what"). whisper.cpp transcribes what was said but does not natively separate or label different speakers in a multi-person recording. Diarization requires a separate model or pipeline (for example, pairing whisper.cpp's transcript with a diarization tool) layered on top.
- Sub-100-millisecond streaming latency at scale. The built-in
whisper-streamexample works well for a single live microphone on one machine, but whisper.cpp is not a purpose-built, horizontally scaled streaming ASR service the way a dedicated real-time speech API is designed to be for many concurrent users. - Zero setup for non-technical users. whisper.cpp is a command-line tool that most people build from source or fetch as a compiled binary β it has no polished graphical installer or app-store listing aimed at non-developers. Users who want a point-and-click transcription app should look at a GUI application built on top of whisper.cpp, or a hosted transcription service, instead.
- Squeezing the last bit of NVIDIA GPU throughput on a Python-first pipeline. On the largest models on NVIDIA hardware, PromptQuorum's benchmark found faster-whisper's CTranslate2 backend to be quicker and lighter on VRAM than whisper.cpp's CUDA path β if your deployment is already a Python service on an NVIDIA GPU, faster-whisper is usually the better fit.
Alternatives to Whisper.cpp
faster-whisper
- Best fit:
- Python pipelines on NVIDIA GPUs β CTranslate2 backend, ~4x throughput vs. original Whisper
- License:
- MIT
WhisperX
- Best fit:
- When you need word-level timestamps and speaker diarization on top of Whisper transcripts
- License:
- BSD-2-Clause
OpenAI Whisper API
- Best fit:
- Teams that prefer a managed cloud API over self-hosting, in exchange for per-minute usage fees
- License:
- Proprietary (paid API)
Vosk
- Best fit:
- Very low-resource offline devices needing a small footprint over Whisper-level accuracy
- License:
- Apache-2.0
Frequently Asked Questions
What is whisper.cpp?
whisper.cpp is a free, MIT-licensed C/C++ reimplementation of OpenAI's Whisper speech-to-text model, created by Georgi Gerganov, that runs transcription locally without a Python runtime.
Is whisper.cpp free?
Yes. whisper.cpp is MIT-licensed with no paid tier, subscription, or usage fee. The Whisper model weights it uses are also MIT-licensed by OpenAI.
Do I need a GPU to run whisper.cpp?
No. whisper.cpp runs on CPU using AVX2 (x86) or NEON (ARM) optimizations, and smaller models (tiny, base) run comfortably in real time on CPU-only hardware, including a Raspberry Pi. A GPU (Apple Metal, NVIDIA CUDA, or Vulkan) speeds up larger models like large-v3 but is not required.
Does whisper.cpp support real-time transcription?
Yes, via the whisper-stream example, which captures live microphone audio and transcribes it continuously. Latency depends on model size and hardware β smaller models on a fast CPU or GPU keep pace closest to real time.
What is the difference between whisper.cpp and faster-whisper?
whisper.cpp is a pure C/C++ implementation with no Python dependency, built for portability across CPU, Apple Metal, CUDA, and embedded devices. faster-whisper is a Python library built on CTranslate2, optimized primarily for NVIDIA GPU throughput inside Python pipelines. See PromptQuorum's detailed benchmark comparison for platform-specific numbers.
Can whisper.cpp run on a Raspberry Pi?
Yes. The tiny and base models run in real time on a Raspberry Pi 5's CPU using whisper.cpp's ARM NEON optimizations, since the project has no Python or CUDA dependency to install.
Does whisper.cpp translate audio into English?
Yes. Passing the -tr (translate) flag to whisper-cli transcribes non-English speech and translates it directly to English text, using the same multilingual Whisper models' built-in translation capability.
Who maintains whisper.cpp today?
The project is maintained under the ggml-org GitHub organization, founded by original creator Georgi Gerganov, with contributions from hundreds of community developers. It remains actively released, with v1.9.3 published August 20, 2026.
Does whisper.cpp separate different speakers in a recording?
Not natively. whisper.cpp transcribes speech to text but does not perform speaker diarization on its own. For "who said what," pair it with a dedicated diarization tool or use WhisperX, which adds diarization on top of Whisper transcripts.
Verdict
whisper.cpp succeeds at exactly what it set out to do: bring OpenAI's Whisper speech-to-text model to any device that can compile C/C++, without requiring Python, CUDA, or a heavy runtime. That portability β running unmodified from a Raspberry Pi to an Apple Silicon Mac to a Vulkan-capable GPU β has no close free equivalent for local, offline transcription, and the MIT license makes it safe to build on for commercial products. It is free, well maintained, and uses the same model weights as upstream Whisper, so accuracy for a given model size matches what OpenAI published. Where it is not the strongest choice is a Python-first, NVIDIA-GPU-only pipeline chasing maximum throughput β faster-whisper's CTranslate2 backend wins there, as PromptQuorum's head-to-head comparison documents. For everyone else β developers targeting embedded hardware, Apple Silicon, cross-platform apps, or anyone who wants a single self-contained binary instead of a Python environment β whisper.cpp is a well-verified, no-cost starting point.
Sources
- whisper.cpp on GitHub β official repository: README, install instructions, license, and release history.
- whisper.cpp releases β version history, including v1.9.3 (August 20, 2026).
- whisper.cpp LICENSE β MIT license text.
- OpenAI Whisper announcement β original 2022 release of the Whisper model.