For a transcription service on NVIDIA graphics cards, faster-whisper is usually the engine of choice: it executes Whisper models on CTranslate2, handles recordings in batches and needs the least code. WhisperX sits on top of it and adds a timestamp for every word plus speaker labels, which subtitles and interview transcripts depend on. whisper.cpp is written in C/C++ with processors and small devices in mind, yet it also computes on CUDA, almost as quickly as faster-whisper without batching.
Below you will find where each project stood in October 2026, the speed figures that have been published, setup on RTX PRO Blackwell, Ukrainian and Russian, and the cases in which NVIDIA's Parakeet model gains more than a quicker engine would. Model memory and the number of live streams per card are worked out in our article on a speech recognition server for Whisper.
In brief
- In the test in the faster-whisper README, 13 minutes of audio on an 8 GB card took 63 seconds without batching and 17 seconds with a batch of 8; OpenAI's reference code needed 2 min 23 s.
- WhisperX adds word timing through wav2vec2 alignment and speakers through pyannote; whisper.cpp on CUDA finished the same test in 65 seconds.
- The latest faster-whisper release is 1.2.1 (31.10.2025), while CTranslate2 underneath has reached 4.8.4 (25.10.2026); WhisperX is at 3.8.6, whisper.cpp at v1.9.5.
- RTX PRO Blackwell (sm_120) needs CTranslate2 4.6.3 or newer, and INT8 is switched off for sm_120, so plan on float16.
- On Ukrainian FLEURS, Whisper large-v3 scores a WER of 6.51% and Parakeet TDT 0.6B v3 6.79%, while on an A100 Parakeet runs roughly 23 times faster.
Whisper engines: versions and licences as of October 2026
Search for the fastest Whisper implementation and seven projects usually come up. We compare three engines; the rest serve as a reference point or as an option for a bigger service.
| Project | Latest release | Licence | Built on |
|---|---|---|---|
| faster-whisper | 1.2.1 (31.10.2025) | MIT | CTranslate2 |
| WhisperX | 3.8.6 (25.05.2026) | BSD-2-Clause | faster-whisper with wav2vec2 and pyannote |
| whisper.cpp | v1.9.5, tagged Latest | MIT | ggml in C/C++ |
| openai-whisper | 20250625 (26.06.2025) | MIT | PyTorch |
| insanely-fast-whisper | 0.0.15 (27.05.2024) | MIT | Transformers |
| NeMo with Parakeet and Canary | 3.0.0 (07.08.2026) | Apache 2.0 | PyTorch |
| vLLM | 18.10.2026, under active development | Apache 2.0 | PyTorch |
Source: package pages on PyPI; GitHub pages of faster-whisper, WhisperX and whisper.cpp (no year given for v1.9.5); vLLM documentation of 19.10.2026; read on 30.10.2026.
faster-whisper has not been updated since 31 October 2025, but CTranslate2, which it calls, keeps moving: 4.8.1 (3 July 2026) fixed the Whisper alignment path and 4.8.4 added fresh GPU and CPU code for operations used by audio models. So install faster-whisper 1.2.1 together with a recent CTranslate2. insanely-fast-whisper has had no release since May 2024, and PyPI describes it as a project kept alive only by its community, a shaky footing for business use. The WhisperX repository already lists a 3.8.7rc1 candidate, so stay on 3.8.6 in your working environment.
Published speed figures and what lies behind them
No README gives figures for RTX PRO Blackwell, and we have not found an independent measurement of all three engines on the same GPU. The fullest comparison comes from faster-whisper itself: a 13-minute recording, large-v2 at beam size 5, a GeForce RTX 3070 Ti with 8 GB, CUDA 12.4.
| Implementation | Time, s | Peak GPU memory | Precision |
|---|---|---|---|
| openai-whisper | 143 | 4,708 MB | fp16 |
| Transformers with SDPA | 112 | 4,960 MB | fp16 |
| whisper.cpp with Flash Attention | 65 | 4,127 MB | fp16 |
| faster-whisper | 63 | 4,525 MB | fp16 |
| faster-whisper at batch size 8 | 17 | 6,090 MB | fp16 |
| faster-whisper at batch size 8 | 16 | 4,500 MB | int8 |
Source: faster-whisper README on GitHub, read on 30.10.2026; versions openai-whisper v20240930, whisper.cpp v1.7.2, Transformers 4.46.3, faster-whisper 1.1.0. Measured by the faster-whisper project, not by us.
By our count, 780 seconds of audio in 63 seconds works out at roughly 12 times real time, and whisper.cpp lands almost exactly there too. Batching is what pulls them apart: with a batch of 8, faster-whisper climbed to about 46 times real time. On a single file the two are nearly level; for a queue of recordings on a server, the deciding piece is BatchedInferencePipeline, which the README presents as a direct substitute for the usual transcribe call.
WhisperX promises batched processing at 70 times real time on large-v2 with under 8 GB of video memory, though it does not say which card. insanely-fast-whisper on an 80 GB A100 got through 150 minutes of audio in 1 min 38 s (large-v3, Transformers, batch 24, Flash Attention 2) against 9 min 23 s for faster-whisper (large-v2, beam size 1, no batching), roughly 92× and 16× real time. That 2024 comparison uses different models and mostly shows what batching is worth.
Actual speed depends on the model (large-v3, turbo or a distilled one), batch and beam size, compute type, the share of silence and file length, so a reliable number comes from an hour of your own recordings.
Word timestamps and speaker labels
Whisper on its own stamps segments, and the WhisperX README warns that these stamps belong to whole utterances and may drift by several seconds.
| Capability | whisper.cpp | faster-whisper | WhisperX |
|---|---|---|---|
| Per-word timing | -ml 1, still experimental |
option word_timestamps=True |
forced alignment with wav2vec2 |
| Who is speaking | tinydiarize, still experimental | README says nothing | pyannote community-1 |
| Silence filter | --vad switches on Silero VAD |
Silero VAD | VAD runs ahead of batching |
| Batch processing | README says nothing | yes | yes |
| Built-in server | whisper-server | README says nothing | README says nothing |
Source: READMEs of faster-whisper, WhisperX and whisper.cpp on GitHub, read on 30.10.2026.
WhisperX aligns words with a separate phoneme model. For English, German, French, Italian and Spanish the stock models come from torchaudio, and the four non-English ones (VoxPopuli) carry the non-commercial CC BY-NC 4.0 licence. For Ukrainian and Russian, WhisperX downloads Hugging Face models by default: Yehor/wav2vec2-xls-r-300m-uk-with-small-lm and jonatasgrosman/wav2vec2-large-xlsr-53-russian (alignment.py, read on 13.11.2026). Check the licence on the model card before commercial use, and pass a different model through --align_model if needed. Test word timing on your own audio. Numbers and currency symbols get no timing. Speakers are labelled by pyannote speaker-diarization-community-1 (accepted terms and a Hugging Face token required); according to the README it struggles with overlapping speech, and its card gives no DER for Ukrainian. More in our article on speaker diarisation on your own server.
faster-whisper returns word timing with word_timestamps=True and drops silence using the Silero model. The default filter removes only pauses over 2 seconds and is switched on by default in batched mode. Whisper's model card warns about text that nobody actually said in the audio, so the silence filter earns its place. For meetings where Ukrainian and Russian are mixed, compare the language parameter (fixed language) with multilingual (language detected per segment): we found no measurements on mixed meetings or surzhyk.
whisper.cpp labels both word timing and speaker-change detection as experimental; the latter relies on an English small model and only marks the change without naming the speaker. Its strengths are a program free of Python, quantised models and whisper-server, an HTTP transcription server with an OpenAI-style API.
Setup on RTX PRO Blackwell: CUDA 12.8, CTranslate2 and INT8
RTX PRO Blackwell cards have compute capability 12.0, i.e. sm_120. According to NVIDIA's notes, compiler support for SM_100, SM_101 and SM_120 arrived with CUDA 12.8, whose minimum driver is 570.26 for Linux and 570.65 for Windows. Software compiled for older CUDA versions crashes on these cards with the error "no kernel image is available".
For faster-whisper the key component is CTranslate2. Its changelog switched INT8 off for sm120 Blackwell GPUs in 4.6.2 (5 December 2025), while 4.6.3 (6 January 2026) brought CUDA 12.8 support and turned cuDNN into an optional dependency. INT8 on sm_120 had not returned by 4.8.4. Install CTranslate2 4.6.3 or newer, run in float16 or bfloat16, and treat INT8 rows in older tests as figures for other GPUs. ctranslate2.get_supported_compute_types("cuda") lists the compute types available.
On its main branch WhisperX pins PyTorch 2.8 from the CUDA 12.8 index and asks you to install the CUDA 12.8 toolkit first, but it only requires CTranslate2 4.5.0, so pin 4.6.3 yourself. whisper.cpp is compiled with cmake -B build -DGGML_CUDA=1 against CUDA 12.8 or newer. pywhispercpp 1.5.1 ships only CPU packages on PyPI; for GPU you build it from source. Apps built on these engines face the same packaging issue; Scriberr, for one, publishes a separate Blackwell image. ETE can supply the workstation on its own, and Vixen.UNO engineers can install the engines and models on it when needed.
When Parakeet or vLLM gets you further
When many hours of recordings must be processed, a different model helps more than a quicker engine. A December 2025 paper on the Open ASR Leaderboard (arXiv 2510.06961v3) measured Parakeet TDT 0.6B v3 on a single A100 at roughly 3,333 s of audio for each second of compute, against 145.5 s for Whisper large-v3, so by our count Parakeet is roughly 23 times faster.
| Model | Audio per 1 s of compute, A100 | WER uk, FLEURS, % | WER ru, FLEURS, % |
|---|---|---|---|
| Whisper large-v3 | 145.5 s | 6.51 | 4.17 |
| Parakeet TDT 0.6B v3 | about 3,333 s | 6.79 | 5.51 |
Source: speed from arXiv 2510.06961v3 (December 2025); WER from the NVIDIA paper arXiv 2509.14128, tables 11 and 13, read on 13.11.2026.
Their accuracy on Ukrainian is close, while on Russian Whisper is noticeably more accurate. The Handy ranking (FLEURS, Q8_0 weights) shows different numbers: Parakeet v3 at 6.84% and Whisper large-v3 at 6.28%, so keep values from different sources apart. Meetings produce more errors than the read sentences of FLEURS. Parakeet covers 25 European languages, Ukrainian and Russian among them, is licensed under CC BY 4.0 and runs in NeMo or NVIDIA's speech NIM. Models for Ukrainian, surzhyk and dialects are covered in our article on local Ukrainian speech recognition.
vLLM serves Whisper through the OpenAI-compatible /v1/audio/transcriptions endpoint with a standard 25 MB file limit that an environment variable lifts. The vLLM docs dated 19 October 2026 describe beam search for Whisper as very inefficient for now, so plan greedy decoding there. Speaches wraps faster-whisper in a server with the OpenAI API, but its v0.9.0-rc.3 is still only a release candidate. Streaming servers for live captions are covered in our article on live captions on your own server.
Which graphics card each stage needs
OpenAI puts Whisper large at about 10 GB of video memory and turbo at 6 GB, so the card is decided by what runs alongside and how many jobs run at once. Usable memory by our rule: 90% of what the driver reports, minus 3 GiB.
| Stage | Card | Memory headroom | Workload | Users |
|---|---|---|---|---|
| Development | one 24 GB RTX PRO 4000 SFF Blackwell | 18.5 GiB usable; roughly 9.2 GiB free once Whisper large is loaded | all three engines, Whisper large plus alignment and pyannote, batches one by one | the engineer building the pipeline |
| Comparison tests | one 96 GB RTX PRO 6000 Workstation Edition | 83.0 GiB usable; roughly 55 GiB free next to both Whisper variants and gpt-oss-20b | large-v3, turbo, Parakeet and a summariser loaded together, bigger batches | a team testing engines on its own recordings |
| Transcription server | 48 GB L40S, or RTX PRO 6000 Server Edition split by MIG | MIG keeps engines apart on one card; rack cooling for constant queues | NIM or vLLM in front, queues from several departments | the whole company |
Source: usable memory by our rule; Whisper large about 10 GB, turbo about 6 GB (OpenAI repository); gpt-oss-20b weights 12.8 GiB (Hugging Face); up to four MIG instances on the RTX PRO 6000 (NVIDIA). Our estimate, not a measurement.
On the RTX PRO 4000, Whisper large occupies 9.3 GiB: what remains is enough to assemble the pipeline, but large batches next to other models are cramped. On the RTX PRO 6000 Workstation Edition both Whisper models occupy around 14.9 GiB, and 27.7 GiB with gpt-oss-20b. If the summary model runs in vLLM, lower --gpu-memory-utilization from the standard 0.92, since vLLM reserves that share of the card at start-up.
The L40S does not support MIG, so one card serves one engine or one NIM. According to NVIDIA's FAQ, NIM in a working environment requires an NVIDIA AI Enterprise licence; the open engines need none. MIG splits the RTX PRO 6000 Server Edition into isolated instances, up to four per card. A server with two such cards draws around 1.8 kW by our estimate, and given the power cuts it is planned with a UPS and a generator (on powering a workstation with several GPUs). No RTFx figures for these engines on RTX PRO have been published, so a test run will show the throughput. ETE works out the configuration for your hours of audio and languages from the real workload.
A test plan before you decide
Checking on your own recordings takes a day.
- Take an hour of typical audio: a meeting, a call, a recording with long pauses and, if it happens in your company, a mixed Ukrainian and Russian conversation.
- Run it through faster-whisper without batching and with a batch of 8 or 16, through WhisperX and through whisper.cpp built for CUDA, with one model in float16.
- Log processing time per audio hour and peak GPU memory as
nvidia-smireports it. - Compare WER against a transcript a person has proofread, and check pauses for invented text.
- For subtitles and a search index, check word timing on numbers and names.
faster-whisper suits a service your code calls; WhisperX suits subtitles, interviews and anything needing speakers; whisper.cpp suits CPUs, edge devices and a single file without Python. Parakeet pays off for large volumes.
FAQ
Which is faster on a GPU: faster-whisper or whisper.cpp?
On a single file they are nearly level: 63 and 65 seconds for 13 minutes of audio with large-v2 in the faster-whisper README test. With a batch of 8 faster-whisper finished in 17 seconds, so for a queue of recordings it is the quicker one.
How does WhisperX differ from faster-whisper?
WhisperX transcribes via faster-whisper and adds word timing through wav2vec2 alignment and speakers through pyannote. faster-whisper offers word timing as an option and does not label speakers. For Ukrainian, WhisperX loads a Hugging Face alignment model by default; check its licence and timing accuracy separately.
Does faster-whisper work on RTX PRO Blackwell?
Yes, with CTranslate2 4.6.3 or newer and a driver from 570.26 on Linux. INT8 is disabled on sm_120, so run float16 or bfloat16 and use a first run to confirm that the graphics card is in use.
How much video memory do faster-whisper and WhisperX need?
About 10 GB for Whisper large and 6 GB for turbo according to OpenAI. In the faster-whisper test, large-v2 in float16 used 4,525 MB, and 6,090 MB with a batch of 8; WhisperX claims under 8 GB. Alignment and diarisation come on top.
Parakeet or Whisper for Ukrainian?
Parakeet TDT 0.6B v3 is roughly 23 times faster than Whisper large-v3 on an A100. On Ukrainian FLEURS their WER is 6.79% and 6.51%, on Russian 5.51% and 4.17%. Parakeet covers 25 European languages, Whisper far more.
Which graphics card does a Whisper server need?
For development an RTX PRO 4000 SFF Blackwell with 24 GB is enough, for tests with several models an RTX PRO 6000 Workstation Edition with 96 GB, and for a company service a server with L40S or RTX PRO 6000 Server Edition cards.
What ETE supplies for this
- NVIDIA RTX PRO 4000 SFF Blackwell 24 GB: 24 GB for the development stage in a compact 70 W form factor.
- ETE AI Workstation: an RTX PRO 6000 Blackwell with 96 GB for comparing engines and models side by side.
- NVIDIA RTX PRO 6000 Server Edition 96 GB: a server card that MIG divides into up to four instances for different engines.
- NVIDIA L40S 48 GB: one card per engine or NIM in a shared service.
Need a configuration for a transcription service?
Tell us how many hours of audio you process per week, which languages are involved and whether per-word timestamps or speaker labels matter to you. ETE will work out the configuration and, when needed, Vixen.UNO engineers will install faster-whisper, WhisperX or whisper.cpp with the models.