# faster-whisper: Whisper inference rebuilt on CTranslate2

> A reimplementation of OpenAI's speech recognition that swaps the runtime under it and keeps the model weights. The README's own tables show where the speedup is real and where it quietly turns into a memory trade.

**SYSTRAN/faster-whisper** — Faster Whisper transcription with CTranslate2

- Repository: https://github.com/SYSTRAN/faster-whisper
- Stars: 25,809 · Forks: 2,121
- Language: Python
- License: MIT
- Published: 2026-10-08 · Updated: 2026-10-08 · Language: en
- Canonical page: https://hysenlabs.com/projects/systran-faster-whisper

## What the package actually is

The project is a Python package that exposes the Whisper transcription interface and delegates the actual computation to CTranslate2, an inference engine built for Transformer models by OpenNMT. The repository description is one line and accurate: faster-whisper transcription with CTranslate2. The README expands it into a reimplementation of OpenAI's Whisper using that engine, and the claim it leads with is that this implementation is up to four times faster than openai/whisper for the same accuracy while using less memory, with 8-bit quantization improving things further on both CPU and GPU.

The package installs from PyPI as faster-whisper and requires Python 3.9 or greater. It is licensed MIT and published by SYSTRAN, the same group behind the CTranslate2 engine and a family of translation models, so this is not an outside party reimplementing someone else's work. The package structure is visible in the tree and it is small: a faster_whisper directory holding the library, a benchmark directory, a tests directory, a docker directory, and the packaging files. There is no examples directory in the tree, so the README's usage snippet is the canonical entry point.

One detail in the requirements is worth flagging because the README never mentions it. requirements.txt declares a dependency on onnxruntime, pinned to at least 1.14 and below 2. Nothing in the README explains what onnxruntime is used for, and it is not part of the transcription path described in the usage section. It is an undocumented dependency that arrives with the install and that you will pay for in download size and in occasional runtime discovery problems.

## The usage snippet and the generator gotcha

The README's main example is short enough to read in full, which is a compliment. It constructs a model, requests a device and a compute type, calls transcribe, prints the detected language, then iterates segments.

```python
from faster_whisper import WhisperModel

model_size = "large-v3"

# Run on GPU with FP16
model = WhisperModel(model_size, device="cuda", compute_type="float16")

# or run on GPU with INT8
# model = WhisperModel(model_size, device="cuda", compute_type="int8_float16")
# or run on CPU with INT8
# model = WhisperModel(model_size, device="cpu", compute_type="int8")

segments, info = model.transcribe("audio.mp3", beam_size=5)

print("Detected language '%s' with probability %f" % (info.language, info.language_probability))

for segment in segments:
    print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))
```

The commented alternatives matter because compute_type is the main performance dial. float16 on a CUDA device is the fast path. int8 on CPU is the memory-constrained path. There is also int8_float16 on GPU, which sits between them, and the README does not benchmark that combination at all.

Then there is the warning that follows the example, and it is the single most important line in the README for anyone writing production code on this library. segments is a generator, so transcription does not begin until you iterate over it. If you call transcribe, drop the result, and go off to do something else, you have done nothing at all and you will find out much later. The README's own fix is to gather the segments into a list, and it shows that as a two-line snippet.

```python
segments, _ = model.transcribe("audio.mp3")
segments = list(segments)  # The transcription will actually run here.
```

This is a reasonable design for long files, where you want to start emitting segments as they are produced rather than buffering an entire transcript in memory. It is also the kind of API that turns a silent mistake into a support ticket.

## Reading the benchmark tables honestly

The benchmark section is the most valuable part of the README and it deserves to be read as carefully as it was written. It transcribes thirteen minutes of audio and it names its competitors precisely: openai/whisper at v20240930, whisper.cpp at v1.7.2, transformers at v4.46.3, and faster-whisper itself at v1.1.0. The hardware is stated too, an NVIDIA RTX 3070 Ti 8GB on CUDA 12.4 for the GPU tables and an Intel Core i7-12700K with eight threads for the CPU table.

Start with the CPU table, because it is the one that undercuts the headline. On the small model in fp32 with beam size 5, faster-whisper takes two minutes thirty-seven seconds and uses 2257MB of RAM. whisper.cpp on the same model takes two minutes five seconds and uses 1049MB. So on that row faster-whisper is both slower than whisper.cpp and more than twice as memory-hungry. It is faster than openai/whisper, which takes six minutes fifty-eight seconds and 2335MB, but that is the comparison the four times claim is built on, and it is the least flattering comparison available.

Now add batching and the picture changes. With batch_size set to 8, faster-whisper fp32 drops to one minute six seconds at the cost of 4230MB of RAM, and the int8 variant drops to fifty-one seconds at 3608MB. Compare that to the plain int8 row at one minute forty-two seconds and 1477MB. The time is now genuinely ahead of whisper.cpp by a wide margin, and the memory is now roughly three and a half times whisper.cpp. Every one of these wins was paid for in RAM.

The GPU table follows the same shape. Large-v2 in fp16 at the default batch takes one minute three seconds at 4525MB, just behind whisper.cpp with Flash Attention at one minute five seconds and 4127MB. Turn batching on and faster-whisper reaches seventeen seconds, but at 6090MB, which is the largest VRAM figure in the entire GPU table and gets uncomfortably close to the 8GB the benchmark card carries. The int8 rows tell the same story in reverse, since int8 at the default batch needs only 2926MB and the batched version needs 4500MB.

There is a third table for distil-whisper-large-v3 and it is the only one reporting accuracy, in the form of word error rate on YouTube Commons. transformers with batch_size 16 takes forty-six minutes twelve seconds at a WER of 14.801. faster-whisper with batch_size 16 takes twenty-five minutes fifty seconds at a WER of 13.527. So on that comparison faster-whisper is both much faster and slightly more accurate, which is the closest thing in the README to an apples-to-apples accuracy claim. The footnote under the first GPU table also explains that transformers runs out of memory for any batch size above one, which is a caveat about the competitor rather than about faster-whisper.

One thing the tables do not say is how long the distil-whisper audio was. Twenty-five minutes of transcription on a 3070 Ti is a large workload, and without the duration you cannot compute a speed ratio for it. That gap is small, and it is the one place where the benchmark cannot be checked from the outside.

## Where the dependency pins and the README disagree

The requirements file declares ctranslate2 at least 4.0 and below 5, huggingface_hub at least 0.23, tokenizers at least 0.13 and below 1, onnxruntime at least 1.14 and below 2, av at least 11, and tqdm. The README, in its GPU requirements section, says the latest versions of ctranslate2 only support CUDA 12 and cuDNN 9, and that for CUDA 11 with cuDNN 8 the current workaround is downgrading to version 3.24.0 of ctranslate2, while for CUDA 12 with cuDNN 8 the workaround is downgrading to 4.4.0.

Those two statements cannot both be satisfied by a single pip invocation. A downgrade to 3.24.0 puts you below the floor that requirements.txt declares, so pip will either refuse or you will have to force it. The README is explicit about the mechanism for the 4.4.0 case, telling you to run pip install --force-reinstall ctranslate2==4.4.0 or to pin that version in a requirements.txt of your own. Force-reinstalling a single package like that also risks quietly changing what faster-whisper resolves to, since it defeats the resolver for the packages it touches.

Both facts stand and neither one invalidates the other. The requirement floor reflects what the current code has been tested against, and the downgrade advice reflects what people with older NVIDIA drivers actually need in order to run at all. If your GPU is a recent one, the floor is the right target. If it is not, you will be living in the space between the two, and the README's note is the only description of that space.

The packaging itself is old-fashioned in a way that mostly does not matter. setup.py reads the long description from README.md, reads the version by executing faster_whisper/version.py, and reads both the base and the conversion dependency lists from requirements.txt and requirements.conversion.txt. There is no pyproject.toml in the tree. The classifiers stop at Python 3.11, listing 3.9, 3.10 and 3.11 explicitly even though the README says 3.9 or greater, so 3.12 and 3.13 are unclassified rather than unsupported. The version is written into a Python file and read by exec rather than imported, which is a common trick for keeping a single source of truth.

## Audio decoding without FFmpeg

One of the more convenient claims in the README is that unlike openai-whisper, FFmpeg does not need to be installed on the system. The audio is decoded with PyAV, a Python library that bundles the FFmpeg libraries in its own package. The requirements file corroborates this with av at least 11.

The practical effect is that installation gets shorter and more portable, particularly on Windows and in containers where managing a system FFmpeg is a recurring chore. The cost is that you no longer control which FFmpeg is doing the decoding, and a bundle that is convenient to install is also harder to patch on your own schedule. For most users that trade is clearly worth making.

The rest of the installation section offers the master branch as a tarball URL and a specific commit as a tarball URL, both installed with pip install --force-reinstall and a PEP 508 direct reference. There is also a docker directory in the tree, and the README points at an official NVIDIA CUDA image, nvidia/cuda:12.3.2-cudnn9-runtime-ubuntu22.04, as one way to get cuBLAS and cuDNN without installing them by hand. It also describes a Linux-only pip route using the nvidia-cublas-cu12 and nvidia-cudnn-cu12 packages with an explicit LD_LIBRARY_PATH export, and a route that downloads prebuilt libraries from another project's releases archive for Windows and Linux.

That third option deserves a note. Borrowing NVIDIA libraries from a third-party release archive is the kind of dependency that works well until it does not, and it puts an unrelated maintainer's release cadence in your path. The Linux pip route with the explicit library path export is more work but keeps everything under pip's view.

## Signals about the project's current state

The repository metadata is worth reading as a snapshot. It has 25727 stars, 2112 forks and 40 open issues, which is a very high fork-to-issue ratio and suggests a large population of people running the library in production without filing much. The default branch is master and the most recent push is dated 2026-10-06, which is well inside the last 183 days, so the repository is actively worked.

The releases tell a different story about cadence. There are three tagged releases: v1.1.1 published on 2025-01-01, v1.2.0 on 2025-08-06, and v1.2.1 on 2025-10-31. So the newest release is roughly eleven months older than the newest commit. That gap is common in libraries where most users install from PyPI and the master branch accumulates fixes that have not been rolled into a release yet, and it does mean the benchmark tables were produced against v1.1.0 while the code on master has moved on by two minor versions.

The eight repository topics are deep-learning, inference, openai, quantization, speech-recognition, speech-to-text, transformer and whisper. That list is accurate and unembellished, which is more than most repositories manage. There is no homepage set in the metadata, so the PyPI page and the GitHub repository are the whole of the official presence.

What is missing from the README is as notable as what is in it. There is no changelog beyond the GitHub releases, no documentation directory, and no comparison of faster-whisper against newer alternatives built on the same CTranslate2 engine. For a library with this much adoption, the documentation is effectively the README table plus the docstrings in the package.

## Conclusion

faster-whisper is a thin and well-targeted piece of engineering. It keeps the Whisper weights and the decoding options, and swaps in CTranslate2 as the execution engine. That single decision is where all the speed comes from, and it is also where every sharp edge lives. The README's own benchmark is the most useful thing in the repository, because it is specific enough to be checked: it names the model, the precision, the beam size, the time and the memory, and it puts competing implementations in the same table. Read it closely and a pattern appears. Where batch_size stays at the default, faster-whisper lands near its competitors rather than far ahead of them. Where batch_size is raised to 8, the time collapses and the memory figure roughly doubles. The speedup is a batching result wearing a runtime's clothes. The second thing worth knowing before you install anything is that the dependency range in requirements.txt and the version advice in the README disagree about what CTranslate2 is acceptable. One says at least 4.0 and below 5, the other tells you to force reinstall 3.24.0 on older CUDA. Both are true statements about different environments, and reconciling them is the first thing you will do if your GPU is not a recent one.

## FAQ

### What is the fastest version of Whisper?

It depends on what you are comparing against and whether you use batching. In faster-whisper's own benchmark on a small model with fp32 and the default batch, whisper.cpp is faster at two minutes five seconds against two minutes thirty-seven seconds. Raise batch_size to 8 and faster-whisper reaches one minute six seconds while using more memory. Read the table row that matches your hardware rather than the headline number.

### Is Faster Whisper free?

The library is MIT licensed and free to install from PyPI. The model weights it downloads are a separate matter, since they come from Hugging Face rather than from this repository, and each model's own license applies to them. The CTranslate2 engine underneath it is also open source.

### What is the difference between OpenAI Whisper and Faster Whisper?

faster-whisper keeps the same Whisper model weights and the same transcription interface but runs them through CTranslate2 instead of PyTorch. The repository contains no model weights of its own. In the README's large-v2 GPU table, fp16 at the default batch takes one minute three seconds against openai/whisper at two minutes twenty-three seconds.

### How to use faster Whisper?

Install it with pip install faster-whisper, then construct WhisperModel with a model size, a device and a compute type, and call transcribe. Two things trip people up. The result's segments is a generator, so nothing runs until you iterate it or wrap it in list. And on GPU you need cuBLAS for CUDA 12 plus cuDNN 9 installed separately, since the package does not pull them in.

## Sources

- [Issues](https://github.com/SYSTRAN/faster-whisper/issues)
- [License: MIT](https://github.com/SYSTRAN/faster-whisper/blob/master/LICENSE)
- [README](https://github.com/SYSTRAN/faster-whisper/blob/master/README.md)
- [Releases](https://github.com/SYSTRAN/faster-whisper/releases)
- [SYSTRAN/faster-whisper on GitHub](https://github.com/SYSTRAN/faster-whisper)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/systran-faster-whisper