Whisper.cpp vs faster-whisper 2026 : Benchmarks STT local, configuration & accélération GPU

En un coup d'œil

• Les deux outils : basés sur le modèle Whisper open source d'OpenAI (licence MIT). Même précision — runtimes différents.
• whisper.cpp : écrit en C/C++ par Georgi Gerganov. Supporte CPU (AVX2/NEON), CUDA, Metal (Apple), Vulkan. Aucun Python requis.
• faster-whisper : bibliothèque Python utilisant CTranslate2. Supporte CPU (int8) et CUDA. Pas de support Apple Metal.
• Tailles de modèles Whisper : tiny (39M), base (74M), small (244M), medium (769M), large-v3 (1.55B). Tous au format GGML / CTranslate2.
• Meilleur modèle pour la plupart des usages : Whisper small — 3.4 % WER, tourne dans 2 GB de RAM, 6× le temps réel sur CPU moderne.
• Benchmark RTX 4070 (large-v3) : faster-whisper ~12× temps réel ; whisper.cpp CUDA ~8× temps réel. faster-whisper gagne sur NVIDIA.
• Benchmark M5 Pro (large-v3) : whisper.cpp Metal ~10× temps réel ; faster-whisper CPU uniquement ~3× temps réel. whisper.cpp gagne sur Apple.

Pourquoi la reconnaissance vocale locale ?

• Confidentialité : l'audio ne quitte jamais votre machine. Aucun contrat de sous-traitance RGPD requis — le traitement s'effectue localement.
• Coût : zéro frais à la minute. Un développeur transcrivant 8 heures de réunions par semaine économise env. 110–440 €/mois par rapport aux tarifs STT cloud.
• Hors ligne : fonctionne en avion, dans des installations sécurisées, sans connexion fiable. Aucune gestion de clé API.
• Latence : pas d'aller-retour upload/download. Pour les interfaces vocales temps réel, le traitement local réduit la latence STT de 300–800 ms (cloud) à 50–300 ms.
• Personnalisation : affinage sur un vocabulaire spécifique au domaine. Utilisation de n'importe quelle taille de modèle adaptée à votre matériel.

Tailles des modèles Whisper

Distil-Whisper : l'alternative plus rapide

• Paramètres : ~756M — environ la moitié des 1.55B de large-v3, tenant dans ~4 GB de VRAM au lieu de ~10 GB.
• Vitesse : ~6× le temps réel sur RTX 4070 (vs 1× de référence pour large-v3) — comparable à medium en vitesse, avec une précision proche de large-v3.
• WER : ~2.6 % sur l'anglais — seulement ~0.1 % au-dessus des 2.5 % de large-v3. Différence imperceptible en pratique sur de la parole typique.
• Compatibilité : fonctionne nativement avec faster-whisper (WhisperModel("distil-large-v3", device="cuda", compute_type="int8")). Pour whisper.cpp : conversion au format GGML via le script de conversion distil-whisper.
• Idéal pour : transcription par lots, déploiements serveur avec VRAM limitée, et tout cas d'usage nécessitant la qualité de large-v3 à la vitesse du modèle medium.
• Déconseillé pour : la transcription multilingue — distil-large-v3 est optimisé uniquement pour l'anglais. Pour d'autres langues, utiliser large-v3 ou medium.

whisper.cpp – le port C/C++

• Support plateforme : CPU (AVX2, AVX512, ARM NEON), Apple Metal (Core ML), CUDA (NVIDIA), Vulkan (GPU AMD/Intel), OpenCL.
• Avantage Apple Silicon : whisper.cpp exporte les modèles au format Core ML, permettant l'inférence sur l'Apple Neural Engine. Large-v3 tourne à ~10× le temps réel sur M5 Pro via Metal — plus rapide que tout aller-retour cloud.
• Installation : cloner le dépôt, exécuter make (ou cmake). Binaires pré-compilés disponibles pour les plateformes courantes. Aucune dépendance Python.
• Téléchargement du modèle : bash ./models/download-ggml-model.sh base.en — télécharge le fichier modèle GGML (~142 MB pour base).
• Exemple CLI : ./main -m models/ggml-base.bin -f audio.wav — transcrit un fichier WAV vers stdout. Ajouter -l fr pour le français.
• Mode stream temps réel : ./stream -m models/ggml-base.bin --step 3000 --length 10000 — transcrit depuis le microphone par chunks de 3 secondes.
• Wrapper Python : pywhispercpp fournit une liaison Python pour whisper.cpp, permettant son utilisation dans des pipelines Python sans sacrifier l'accélération Metal.
• Limitation : pas de VAD natif. Le mode stream nécessite l'ajustement des paramètres --step et --length selon le cas d'usage.

# Build from source (macOS / Linux)
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp
make -j4

# Download a model
bash ./models/download-ggml-model.sh large-v3

# Transcribe a file
./main -m models/ggml-large-v3.bin -f recording.wav

# Enable Metal on Apple Silicon (Core ML)
make -j4 WHISPER_COREML=1
./main -m models/ggml-large-v3-encoder.mlmodelc -f recording.wav

faster-whisper – le port CTranslate2

• Support plateforme : CPU (quantification int8) et GPU NVIDIA CUDA. Pas de support Apple Metal — tourne uniquement sur CPU sur Mac.
• Avantage int8 : la quantification int8 CTranslate2 réduit le VRAM de ~40 % et augmente la vitesse d'inférence de ~2× vs float16, avec un impact WER négligeable (< 0.1 % absolu).
• Installation : pip install faster-whisper — aucune compilation requise. Le support CUDA nécessite CUDA 11.8+ et cuDNN 8.x.
• VAD intégré : faster-whisper inclut l'intégration Silero VAD, qui ignore automatiquement les segments audio silencieux — crucial pour les pipelines de transcription temps réel.
• Python natif : l'API Python directe facilite le chaînage avec des LLM, des bibliothèques de traitement audio et des frameworks web.
• Vitesse : large-v3 int8 sur RTX 4070 à ~12× le temps réel avec ~2.5 GB de VRAM. CPU int8 atteint ~20× le temps réel pour le modèle tiny.
• Traitement par lots : faster-whisper supporte l'inférence en batch pour traiter efficacement de grandes archives audio.
• Limitation : pas de support Metal sur Mac — tourne uniquement sur CPU sur Apple Silicon, à ~3× le temps réel pour large-v3 vs ~10× de whisper.cpp avec Metal.

from faster_whisper import WhisperModel

# Load model (downloads automatically on first run)
model = WhisperModel("large-v3", device="cuda", compute_type="int8")

# Transcribe
segments, info = model.transcribe("audio.wav", beam_size=5)

print(f"Detected language: {info.language} (probability: {info.language_probability:.2f})")
for segment in segments:
    print(f"[{segment.start:.2f}s → {segment.end:.2f}s] {segment.text}")

Comparaison directe : tableau de benchmarks

Configuration de la transcription en temps réel

• Mode stream whisper.cpp : exécuter ./stream -m models/ggml-small.bin --step 3000 --length 10000 -t 4. Traite des chunks de 3 secondes ; décalage ~0.5–1.5 seconde avec le modèle small. Aucun Python requis.
• Pipeline VAD faster-whisper : utiliser vad_filter=True dans model.transcribe(). Silero VAD segmente automatiquement l'audio aux silences — chunks plus naturels que les fenêtres à durée fixe.
• Latence pratique : 0.5–2 secondes derrière la parole en direct avec les modèles small ou medium. Utiliser tiny pour la latence minimale (< 0.5 seconde, mais WER plus élevé).
• Choix du modèle temps réel : small ou base est le meilleur compromis — assez rapide pour suivre la parole, assez précis sur audio propre. Éviter large-v3 en temps réel sans GPU dédié.
• Entrée microphone : whisper.cpp lit l'audio brut via SDL2 ou portaudio. faster-whisper lit des tableaux audio depuis n'importe quelle bibliothèque Python (sounddevice, pyaudio, soundfile).
• Stabilité : le mode stream de whisper.cpp peut produire des tokens répétés sur les silences. Supprimer avec --suppress-blank et --no-speech-threshold.

Apple Silicon : whisper.cpp gagne

• Export Core ML : exécuter ./models/generate-coreml-model.sh large-v3 pour exporter l'encodeur au format Core ML. Cela déporte l'inférence de l'encodeur vers l'Apple Neural Engine.
• Benchmark M5 Pro (large-v3, Metal) : ~10× le temps réel. 60 minutes d'audio transcrites en ~6 minutes. Note : le M5 Pro est sorti en mars 2026 — il s'agit de benchmarks communautaires préliminaires. Les performances pourront s'améliorer avec les mises à jour de whisper.cpp optimisant le Neural Engine M5.
• Benchmark M3 MacBook Air (large-v3, Metal) : ~7× le temps réel. 60 minutes en ~8.5 minutes.
• Mémoire : la mémoire unifiée signifie pas de VRAM séparée — un M5 Pro 16 GB peut exécuter large-v3 (~3 GB) confortablement en parallèle d'autres processus.
• faster-whisper sur Mac : CPU uniquement, int8. Large-v3 à ~3× le temps réel. Utilisable pour la transcription par lots de nuit, pas pour le temps réel.
• Recommandation : utiliser whisper.cpp pour tous les travaux STT sur Mac. Ajouter pywhispercpp si une intégration Python est nécessaire tout en conservant l'accélération Metal.

GPU NVIDIA : faster-whisper gagne

• Benchmark RTX 4070 (12 GB) (large-v3 int8) : ~12× le temps réel, ~2.5 GB VRAM.
• Benchmark RTX 3060 (12 GB) (large-v3 int8) : ~8× le temps réel, ~2.5 GB VRAM.
• Benchmark RTX 4060 (8 GB) (large-v3 int8) : ~7× le temps réel, ~2.5 GB VRAM — tient facilement.
• int8 vs float16 : int8 est ~2× plus rapide et utilise ~40 % de VRAM en moins avec une perte de précision négligeable. Toujours utiliser compute_type="int8" sur NVIDIA.
• Traitement par lots : le paramètre batched=True de faster-whisper permet le traitement parallèle de plusieurs fichiers audio, maximisant l'utilisation GPU pour les gros jobs de transcription.
• Intégration pipeline Python : faster-whisper s'intègre directement dans LangChain, Haystack et des pipelines Python personnalisés. Pas d'overhead subprocess comparé au wrapping de whisper.cpp.

Quel outil utiliser ?

Au-delà de whisper.cpp et faster-whisper

• WhisperX :** construit sur faster-whisper, ajoute des horodatages au niveau du mot et la diarisation des locuteurs — qui a dit quoi. Idéal pour : transcription de réunions avec identification des intervenants, montage de podcasts, transcription d'interviews. Installation avec pip install whisperx et token Hugging Face pour le modèle de diarisation.
• insanely-fast-whisper :** wrapper de pipeline Hugging Face Transformers avec support Flash Attention 2 pour une inférence GPU significativement plus rapide que faster-whisper standard sur NVIDIA. Idéal pour : traitement par lots de grandes archives audio sur GPU NVIDIA. Nécessite un GPU compatible Flash Attention 2 (Ampere ou plus récent : RTX 3000+, A100, H100).

Problèmes courants et solutions

• Incompatibilité de version CUDA : faster-whisper nécessite CUDA 11.8 ou supérieur. Vérifier avec nvcc --version. Si votre CUDA est plus ancien : mettre à jour le driver ou installer faster-whisper dans un environnement conda avec cudatoolkit=11.8.
• L'export du modèle Metal échoue : les Xcode Command Line Tools doivent être installés — exécuter xcode-select --install. Le script d'export Core ML nécessite le paquet Python coremltools : pip install coremltools.
• Hallucinations sur les silences : les deux outils peuvent générer des tokens répétés sur les segments silencieux. Utiliser --no-speech-threshold 0.6 en mode stream whisper.cpp, ou vad_filter=True dans model.transcribe() de faster-whisper pour ignorer automatiquement les silences.
• Mémoire insuffisante avec large-v3 : passer à la quantification int8 dans faster-whisper (compute_type="int8") — réduit le VRAM de ~5 GB (float16) à ~2.5 GB. Avec whisper.cpp : utiliser la variante GGML quantifiée (ex. ggml-large-v3-q5_0.bin), réduisant la mémoire à ~3–4 GB.
• Sortie illisible sur audio non anglais : ne pas utiliser les variantes .en (tiny.en, base.en) pour de l'audio non anglais — elles sont English-only. Utiliser les modèles multilingues (base, small, medium, large-v3) et spécifier la langue explicitement : -l fr dans whisper.cpp ou language="fr" dans faster-whisper.
• Inférence CPU lente : vérifier que le CPU supporte les instructions AVX2 (requises pour l'inférence CPU optimisée). Vérifier avec grep avx2 /proc/cpuinfo sous Linux ou sysctl machdep.cpu.features sur Mac. Les CPU sans AVX2 utilisent SIMD générique et seront 2–3× plus lents.

Foire aux questions

Sources

• whisper.cpp sur GitHub — Code source, instructions de build, scripts de téléchargement de modèles et guide Metal/Core ML.
• faster-whisper sur GitHub — Code source, documentation de l'API Python et résultats de benchmarks.
• distil-whisper/distil-large-v3 sur Hugging Face — Fiche modèle, résultats de benchmarks et instructions d'utilisation de la variante distillée.
• WhisperX sur GitHub — Horodatages au niveau du mot et diarisation des locuteurs, construit sur faster-whisper.
• insanely-fast-whisper sur GitHub — Pipeline Whisper Flash Attention 2 pour un débit GPU NVIDIA maximal.
• OpenAI Whisper sur GitHub — Modèle Whisper original, article de recherche et fiches modèles pour toutes les tailles.
• Article OpenAI Whisper (Radford et al., 2022) — « Robust Speech Recognition via Large-Scale Weak Supervision. » Source des valeurs WER.
• Documentation CTranslate2 — Détails de quantification, support matériel et bases de l'optimisation int8.

Lectures complémentaires

• TTS local et clonage vocal 2026 : Piper vs Coqui vs XTTS v2 — Le complément TTS : retransformer le texte transcrit en parole, hors ligne.
• Créer un assistant vocal entièrement hors ligne en 2026 — Connecter Whisper STT à un LLM local et Piper TTS pour un pipeline vocal complet.
• Pipeline IA multimodale locale 2026 — Ajouter des modèles de vision aux côtés de STT et TTS pour une stack locale complète.
• Guide matériel LLM local 2026 — Exigences GPU et RAM pour le pipeline vocal + LLM complet.
• Créer un assistant vocal local sur smartphone — Version mobile : WhisperKit sur iPhone, Layla sur Android.