Deploy WhisperX v3.8.5: Real-Time Transcription Guide

End state: you type whisperx interview.mp3 --model large-v3 --diarize, and 90 seconds later you have an SRT file with word-level timestamps and speaker labels – SPEAKER_00, SPEAKER_01, the works. That’s what this guide gets you to, on WhisperX v3.8.5 (released April 1, 2026), the current stable release.

Work backwards with me. Requirements first, then the install that holds together in 2026, then the cuDNN mess that eats half of new setups, then verification. Already hit libcudnn_ops_infer.so.8: cannot open shared object file? Jump to section 5. That section exists specifically for you.

1. What you actually need on the box

WhisperX runs on CPU, but the numbers in the WhisperX paper (arXiv:2303.00747) were benchmarked on GPU – and that’s where the performance lives. Word-level timestamps via wav2vec2 forced alignment hit ±50 ms accuracy versus ±500 ms in vanilla Whisper. On an RTX 4090 with batched inference, the tool reaches 70× real-time speed on large-v2.

The GPU version runs about 10× faster than CPU (per community benchmarks). macOS is CPU-only – no CUDA support on Apple hardware.

2. Install WhisperX v3.8.5 the clean way

Do this in an isolated Python 3.10 environment. Not your system Python. Not your project’s shared venv. A dedicated one – because WhisperX pulls specific torch, ctranslate2, and pyannote versions that will conflict with other ML packages.

Think of WhisperX’s dependency graph like a set of nested Russian dolls. The outermost doll is WhisperX itself; inside sits ctranslate2 (the inference backend), and inside that sits a specific cuDNN expectation. Crack open the wrong doll in the wrong order and nothing fits back together. The install sequence below keeps the dolls intact.

# Create isolated env
conda create -n whisperx python=3.10 -y
conda activate whisperx

# Install PyTorch matched to CUDA 12.8 FIRST
# (WhisperX 3.8.5 pins torchvision + torchcodec for torch 2.8)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128

# Then WhisperX from PyPI
pip install whisperx

# Verify
whisperx --help
python -c "import torch; print('CUDA:', torch.cuda.is_available())"

Install torch first. Pip’s resolver is greedy – if WhisperX lands first, pip picks whatever torch version satisfies the broadest constraint, and you end up with a mismatched CUDA build. The v3.8.5 release notes specifically call out the torchvision and torchcodec pins for torch 2.8 compatibility (PR #1397). Locking torch before WhisperX slots in means those pins land correctly instead of being overridden.

3. First-run configuration

Models download automatically on first use and land in ~/.cache/huggingface/hub – 3-5 GB total across Whisper weights, wav2vec2 alignment models, and pyannote diarization. Budget disk space before you start, and don’t read stalled output as a crash. That first run taking 4 minutes is the download, not a hang.

Speaker diarization needs a Hugging Face token. Generate a read token at huggingface.co and accept the model license for pyannote/speaker-diarization-community-1. Then:

export HF_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# Basic transcribe
whisperx sample.mp3 --model large-v3 --language en

# With word-level highlights + diarization
whisperx sample.mp3 --model large-v3 --diarize 
 --highlight_words True --hf_token $HF_TOKEN

Watch out: for recordings longer than 30 minutes, set --batch_size explicitly. The default of 16 is tuned for CUDA. On CPU it triggers an out-of-memory kill (exit code 137) – a bug documented in the whisperx-asr-service v0.3.2 changelog. Drop it to 2 for CPU, or 4-8 if your VRAM is tight.

4. Verify end-to-end before touching real audio

Three checks. Any failure here – fix it before proceeding.

1. Import test:python -c "import whisperx; print(whisperx.__version__)" – expect 3.8.5.
2. GPU test:python -c "import torch; print(torch.cuda.get_device_name(0))" – expect your GPU name, not a stack trace.
3. End-to-end test: Grab any 10-second WAV or MP3 and run whisperx test.wav --model tiny --compute_type int8. Smallest model, CPU-friendly compute type, done in under a minute if the pipeline is intact.

Step 3 crashes but step 2 passed? You’re in cuDNN territory.

5. The cuDNN version conflict

Could not load library libcudnn_ops_infer.so.8 on Linux. Could not locate cudnn_ops_infer64_8.dll on Windows. Not random – this is a deterministic version collision between two of WhisperX’s dependencies.

The failure is structural. WhisperX uses ctranslate2 as the inference backend for faster-whisper. Per GitHub issue #954, ctranslate2 4.4.0 requires torch below 2.4.0 to work correctly; ctranslate2 4.5.0 is the version that updated to cuDNN 9. PyTorch 2.5+ ships cuDNN 9 by default. So pip pulls torch 2.5.1 (cuDNN 9) alongside ctranslate2 4.4.0 (expecting cuDNN 8) – imports succeed, runtime blows up looking for a shared library that doesn’t exist in your cuDNN 9 tree.

Turns out the Windows variant is the same problem with a different filename. GitHub issue #1216 documents WhisperX 3.4.2 on an RTX 3080 with CUDA 12.1 failing on cudnn_ops_infer64_8.dll despite having cuDNN 9 installed. v3.8.5 is meant to close this by pinning torch 2.8 with matched torchvision and torchcodec – but if you’ve mixed in pins from an older tutorial, you can reintroduce the conflict yourself.

The fix on Linux, per community reports:

export LD_LIBRARY_PATH=`python -c 'import os; import nvidia.cublas.lib; import nvidia.cudnn.lib; print(os.path.dirname(nvidia.cublas.lib.__file__) + ":" + os.path.dirname(nvidia.cudnn.lib.__file__))'`

This redirects ctranslate2 to the cuDNN bundled with nvidia-cudnn-cu12 (the pip-installable package) instead of whatever system cuDNN it was hunting. Add it to your shell profile – the setting doesn’t survive a new terminal session otherwise.

6. Pascal GPU owners: read this before anything else

GTX 10xx series users have a specific problem. WhisperX’s install chain used to silently pull torch 2.8 during dependency resolution – and PyTorch 2.8’s cuDNN/CUDA 12.8 build drops Pascal and Maxwell support. Install completes without a warning. CUDA fails at model load. The whisperx-asr-service docs called this out explicitly: the upstream fork was silently upgrading torch to 2.8 and breaking Pascal rigs.

The fix is to pin torch to a pre-2.8 build with a matching CUDA toolkit before installing WhisperX, or use a community Docker image that was built with Pascal support in mind. GTX 1080, GTX 1070, Tesla P100 – all affected.

Alignment models are also language-specific, and this one’s easy to miss. Default alignment covers en, fr, de, es, it, ja, zh, nl, uk, and pt (as of the current README). Vietnamese, Arabic, Hindi – transcription runs fine, but forced alignment falls back and word-level timestamps get imprecise. You’ll need a phoneme-based ASR model from Hugging Face passed via --align_model for anything outside that list.

7. Upgrade and uninstall

pip install --upgrade whisperx works for patch bumps. For anything crossing a minor version boundary, nuke the env and rebuild – 5 minutes, and it prevents ctranslate2/pyannote version drift from accumulating silently.

# Full uninstall
conda deactivate
conda env remove -n whisperx

# Clean the model cache (frees ~5 GB)
rm -rf ~/.cache/huggingface/hub/models--openai--whisper*
rm -rf ~/.cache/huggingface/hub/models--pyannote*
rm -rf ~/.cache/torch/hub/checkpoints

The cache lives outside the conda env. Remove the env without clearing the cache and those gigabytes stay on disk. If you’re switching between ASR tools regularly, keep the Whisper weights and only delete the pyannote ones – pyannote updates most often and is the most likely to cause version skew.

Which raises a question worth sitting with before you commit to this stack: WhisperX processes files, not streams. If your use case is moving toward live audio, you’ll eventually hit the ceiling of this architecture. Good to know now rather than six months into a production deployment.

FAQ

Does WhisperX do real-time transcription of a live microphone stream?

No – it processes files. The “70× real-time” figure is throughput, not latency: a 60-minute file transcribed in under a minute on an RTX 4090. For live mic use, feed it 10-30 second WAV chunks as they’re captured, or switch to whisper.cpp or faster-whisper directly.

Which model should I use?

Start with large-v3-turbo – it’s faster than plain large-v3 and covers most transcription tasks well. Reserve large-v3 for noisy audio, heavy accents, or domain-specific vocabulary where accuracy on the tail matters. If you’re on a 4 GB GPU, medium is your ceiling; the large models won’t fit without quantization tricks, and even then it’s marginal. Run the end-to-end verification check from Section 4 with your actual audio before committing to a model for production – benchmark on your content, not someone else’s.

Do I need the Hugging Face token if I’m skipping diarization?

No. Plain transcription and alignment work offline once models are cached – HF_TOKEN only gates the pyannote pipeline. Leave it unset and WhisperX won’t ask for it.

Next step: record a 2-minute test clip of yourself reading something, run whisperx test.wav --model large-v3 --diarize --highlight_words True --hf_token $HF_TOKEN, and open the resulting .srt in a text editor. If the word timings land where you expect, you’re production-ready – move on to wrapping it in an API service.