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.
• Intégration Home Assistant : Whisper en local signifie que les mots de réveil et les commandes vocales ne quittent jamais votre réseau domestique. Voir Whisper local dans Home Assistant → pour la configuration du module qui remplace entièrement le STT cloud.

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

whisper.cpp : dernière version & mises à jour (juin 2026)

• whisper.cpp v1.8.6 (2 juin 2026) : réimplémentation de ffmpeg-transcode pour un décodage FFmpeg optionnel plus clair des fichiers audio compressés (MP3, M4A), plus une correction du chemin des exemples CI.
• whisper.cpp v1.8.5 (mai 2026) : améliorations du VAD en streaming (détection d'activité vocale), corrections de fuites de paramètres serveur et d'horodatages de tokens, ainsi que des corrections de fuites mémoire dans les bindings Ruby et VAD.
• whisper.cpp v1.8.4 (19 mars 2026) : dernière synchronisation ggml avec de larges gains de performance, un nouveau flag -g / --gpu-device (et sélection de périphérique GGML_CUDA) pour choisir un GPU, et des corrections de retour à la ligne des segments UTF-8.
• Le VAD natif est désormais intégré à whisper.cpp. Les versions récentes ont ajouté un chemin natif de détection d'activité vocale, réduisant un avantage de longue date de faster-whisper — même si l'intégration Silero VAD de faster-whisper reste plus clé en main.
• faster-whisper v1.2.1 (31 octobre 2025) : version stable actuelle ; pip install faster-whisper l'installe. Aucune version 2026 à la date de cette mise à jour — le projet est stable, pas à l'arrêt.
• Aucun nouveau modèle Whisper de base en 2026. large-v3 et distil-large-v3 restent les poids les plus récents, donc les « mises à jour » de chaque outil sont des changements de runtime et d'outillage, pas de précision.

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}")

Obtenir ggml-base.bin via pip (configuration Python)

• Installer le binding : pip install pywhispercpp. Pour l'accélération NVIDIA CUDA, compilez avec GGML_CUDA=1 pip install git+https://github.com/absadiki/pywhispercpp.
• Téléchargement auto de ggml-base.bin : from pywhispercpp.model import Model puis model = Model("base") télécharge ggml-base.bin depuis Hugging Face (ggerganov/whisper.cpp) au premier lancement et le met en cache. Utilisez "base.en" pour la variante anglaise uniquement.
• Téléchargement manuel (voie CLI, sans pip) : depuis un dépôt whisper.cpp cloné, bash ./models/download-ggml-model.sh base enregistre le fichier dans models/ggml-base.bin — le même fichier que pywhispercpp récupère.
• Téléchargement direct : curl -L -o ggml-base.bin https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin récupère le modèle sans script. Remplacez base par tiny, small, medium ou large-v3.
• Ne confondez pas les paquets : pip install openai-whisper installe le Whisper PyTorch original d'OpenAI (il utilise des checkpoints .pt, pas ggml-base.bin). pip install faster-whisper utilise le format CTranslate2. Seul pywhispercpp consomme les fichiers GGML ggml-*.bin.
• Où réside le fichier : pywhispercpp stocke les modèles GGML téléchargés dans son cache de module (ou un chemin passé via Model("base", models_dir="...")), de sorte que le même ggml-base.bin est réutilisé d'un lancement à l'autre — aucun re-téléchargement.

# 1. Install the pip binding for whisper.cpp
pip install pywhispercpp

# 2. ggml-base.bin downloads automatically on first use
#    from pywhispercpp.model import Model
#    model = Model("base")          # fetches & caches ggml-base.bin (~142 MB)
#    for seg in model.transcribe("audio.wav"):
#        print(seg.text)

# --- Or get ggml-base.bin manually (no pip) ---
# From a cloned whisper.cpp checkout:
bash ./models/download-ggml-model.sh base       # -> models/ggml-base.bin

# Or download the file directly from Hugging Face:
curl -L -o ggml-base.bin \
  https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin

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.

Whisper sur Raspberry Pi 5 : tiny, base & small

• Whisper small sur Pi 5 : environ 0.4–0.6× le temps réel sur CPU (un clip de 10 minutes prend ~17–25 minutes). Précis à 3.4 % WER mais trop lent pour le sous-titrage en direct — à utiliser pour la transcription de nuit/par lots.
• Whisper base sur Pi 5 : autour du temps réel jusqu'à ~2× avec le multithreading (-t 4). Le compromis pratique idéal pour la transcription en direct sur le Pi, avec un WER acceptable de 5.0 %.
• Whisper tiny sur Pi 5 : l'option la plus rapide, confortablement plus rapide que le temps réel pour l'usage en direct, au prix d'un WER plus élevé de 7.6 %. Idéal pour la reconnaissance de mots de réveil et de commandes courtes.
• Utilisez des modèles quantifiés : bash ./models/download-ggml-model.sh small-q5_0 réduit la RAM et accélère l'inférence avec une perte de précision minimale — important sur la mémoire partagée du Pi 5.
• faster-whisper sur Pi 5 : installable (pip install faster-whisper, CPU int8) et compétitif pour les jobs par lots, mais le binaire C plus léger de whisper.cpp reste le choix embarqué le plus courant.
• Thermique : une transcription soutenue sollicite fortement le CPU du Pi 5 — utilisez un refroidissement actif pour éviter le throttling thermique qui dégrade ces chiffres.

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.