Faster-Whisper and whisper.cpp take two different routes to local Whisper transcription: one is a Python package built for application pipelines, while the other is a native C/C++ toolkit with a command-line workflow. This guide sets up both for dictation and subtitles, then shows how to compare them on your own audio.

Choose by Workflow

Faster-Whisper is a Python package built on CTranslate2. It is a good fit for applications that already use Python and need programmatic segments, word timestamps, batched transcription, or integrated Silero voice-activity detection.

whisper.cpp is a C/C++ implementation with a command-line tool and multiple hardware backends. It is attractive for a small deployable binary, CPU use, Apple Silicon, or an application that embeds its C API.

Both projects offer multiple acceleration backends, and each backend adds its own build and runtime requirements. Choose the intended backend before installation.

Install Faster-Whisper

On Python 3.12, create a virtual environment and install the versions used for the checked example. The PyAV 19 API removed an argument that Faster-Whisper 1.2.1 still passes, so keep av==17.1.0 with this version rather than taking the newest resolver choice:

python3.12 -m venv whisper-env
source whisper-env/bin/activate
python -m pip install --upgrade pip
python -m pip install faster-whisper==1.2.1 ctranslate2==4.8.2 av==17.1.0

The project’s current example creates one WhisperModel object, then calls transcribe on it:

from faster_whisper import WhisperModel

model = WhisperModel("tiny.en", device="cpu", compute_type="int8")

segments, info = model.transcribe(
    "audio.wav",
    beam_size=5,
    word_timestamps=True,
    vad_filter=True,
)

print(f"language={info.language} probability={info.language_probability:.3f}")
for segment in segments:
    print(f"[{segment.start:.2f} -> {segment.end:.2f}] {segment.text}")

Replace audio.wav with your own readable audio file. The checked smoke test used whisper.cpp’s bundled samples/jfk.wav on an Apple M4 with these Python package versions; it returned two segments and 22 word timestamps. segments is a generator, so transcription begins when it is iterated or converted to a list. Keep the model object alive and call model.transcribe(...) again for later files; a new transcription call does not inherently reload the model.

Faster-Whisper already integrates Silero VAD. Set vad_filter=True for ordinary transcription; its batched transcription path enables the VAD filter by default. You may tune vad_parameters, but test changes on the intended room noise and speaking style rather than copying a universal silence threshold.

NVIDIA acceleration requires compatible CUDA libraries. The Faster-Whisper README documents the versions expected by its current CTranslate2 release; follow that matrix because an older blog’s CUDA recipe can become wrong after an upgrade.

Build whisper.cpp with Current Commands

The project now uses CMake in its primary quick-start instructions:

git clone https://github.com/ggml-org/whisper.cpp.git
cd whisper.cpp
git checkout 6e4ab854f67f743900934a703d5603419384c961
sh ./models/download-ggml-model.sh tiny.en
cmake -B build
cmake --build build -j --config Release

Transcribe the included sample or your own compatible audio with whisper-cli:

./build/bin/whisper-cli \
  -m models/ggml-tiny.en.bin \
  -f samples/jfk.wav

At the pinned revision, the bundled samples/jfk.wav produced an SRT file with -osrt -of jfk on Apple M4. That is a smoke test, not an accuracy or speed comparison. The project’s basic quick start specifies 16-bit WAV input. Convert other audio with FFmpeg when needed:

ffmpeg -i input.mp3 -ar 16000 -ac 1 -c:a pcm_s16le output.wav
./build/bin/whisper-cli -m models/ggml-tiny.en.bin -f output.wav

For an NVIDIA build, use the current CMake option:

cmake -B build -DGGML_CUDA=1
cmake --build build -j --config Release

The old WHISPER_CUDA=1 make and ./main examples refer to earlier project layouts. Current binaries are normally under build/bin/, including whisper-cli and example programs built by the selected configuration.

On Apple Silicon, whisper.cpp supports Metal and separately offers an optional Core ML path for encoder acceleration on the Apple Neural Engine. The default Metal path and optional Neural Engine path are distinct.

Voice Activity Detection and Streaming

Voice activity detection finds regions likely to contain speech. It can reduce work on silence and help a dictation interface decide when to submit an utterance, but aggressive settings can cut off quiet words.

Faster-Whisper exposes Silero VAD directly through vad_filter=True. whisper.cpp also has documented VAD support and example applications. A complete live-dictation product still needs microphone capture, buffering, partial-result behavior, text insertion, and recovery when speech boundaries are wrong.

Reuse the same WhisperModel across audio chunks. Live responsiveness depends on model size, backend, chunk policy, and the moment at which the interface decides speech has ended, so measure the complete dictation path on the target computer.

Subtitle Output and Word Timing

For Faster-Whisper, request word timestamps and build the subtitle file from returned segments and words. Validate subtitle line length and reading duration separately; raw word timestamps do not automatically produce readable captions.

whisper.cpp’s CLI can write SRT output with its output options. Run ./build/bin/whisper-cli -h for the exact options in the checked-out revision. Save the commit or release number with automated workflows so a later CLI change is visible.

Both engines can produce plausible but wrong words, especially with names, overlapping speakers, music, accents underrepresented by a model, or noisy recordings. Human review remains necessary for publication-quality subtitles.

Compare Them on Your Own Audio

Use a small, disclosed corpus rather than quoting untraceable throughput numbers:

  1. Select clean speech, noisy speech, accents, names, and the longest recording type you actually handle.
  2. Create a human-corrected reference transcript.
  3. Pin the model, project release or commit, backend, compute type, and command options.
  4. Run at least three timed passes after a separate cold-load measurement.
  5. Record wall-clock time, peak memory, word error rate, and manual errors on names or punctuation.
  6. For dictation, measure end-of-speech to displayed text in the actual application.

Model download size and runtime memory are separate measurements. The whisper.cpp README publishes disk and approximate memory figures separately, while Faster-Whisper memory also varies with model and compute type.

Practical Choice

Start with Faster-Whisper if you are building a Python transcription pipeline and want its direct VAD, batch, and word-timestamp APIs. Start with whisper.cpp if you want a compiled CLI, broad backend choices, Apple-focused optimization, or a small native integration.

Then test both if accuracy or throughput is operationally important. Test the model size and audio you actually use; the project name alone is not a performance measurement, and upstream capabilities can change faster than a static comparison table.

Sources