Whisper.cpp vs faster-whisper 2026: Benchmarks STT local, configuración y aceleración GPU

Datos rápidos

• Ambas herramientas: basadas en el modelo Whisper de código abierto de OpenAI (licencia MIT). Misma precisión — runtimes diferentes.
• whisper.cpp: escrito en C/C++ por Georgi Gerganov. Admite CPU (AVX2/NEON), CUDA, Metal (Apple), Vulkan. No requiere Python.
• faster-whisper: librería Python usando CTranslate2. Admite CPU (int8) y CUDA. Sin soporte para Apple Metal.
• Tamaños del modelo Whisper: tiny (39M), base (74M), small (244M), medium (769M), large-v3 (1,55B). Todos en formato ggml / CTranslate2.
• Mejor modelo para la mayoría de casos: Whisper small — 3,4% WER, funciona en 2 GB de RAM, 6× tiempo real en CPU moderno.
• Benchmark RTX 4070 (large-v3): faster-whisper ~12× tiempo real; whisper.cpp CUDA ~8× tiempo real. faster-whisper gana en NVIDIA.
• Benchmark M5 Pro (large-v3): whisper.cpp Metal ~10× tiempo real; faster-whisper solo-CPU ~3× tiempo real. whisper.cpp gana en Apple.

¿Por qué reconocimiento de voz local?

• Privacidad: el audio nunca sale de tu equipo. No se necesita acuerdo de procesamiento de datos para cumplimiento — el procesamiento ocurre localmente.
• Costo: sin tarifas por minuto. Un desarrollador que transcribe 8 horas de reuniones por semana ahorra $120–480/mes respecto a precios STT en la nube.
• Offline: funciona en aviones, instalaciones seguras y zonas sin internet estable. Sin gestión de API keys.
• Latencia: sin ida y vuelta de subida/descarga. Para interfaces de voz en tiempo real, el procesamiento local reduce la latencia STT de 300–800 ms (nube) a 50–300 ms.
• Personalización: ajusta el modelo con vocabulario específico del dominio. Ejecuta el tamaño de modelo que quepa en tu hardware.

Tamaños del modelo Whisper — base de ambas herramientas

Distil-Whisper: la alternativa más rápida

• Parámetros: ~756M — aproximadamente la mitad de los 1,55B de large-v3, cabe en ~4 GB de VRAM en lugar de ~10 GB.
• Velocidad: ~6× tiempo real en RTX 4070 (vs. 1× de referencia para large-v3) — comparable al modelo medium en velocidad, con precisión cercana a large-v3.
• WER: ~2,6% en inglés — solo ~0,1% superior al 2,5% de large-v3. En la práctica, la diferencia es imperceptible en habla típica.
• Compatibilidad: funciona con faster-whisper de forma nativa (WhisperModel("distil-large-v3", device="cuda", compute_type="int8")). Para whisper.cpp, convierte al formato GGML usando el script de conversión GGML de distil-whisper.
• Mejor para: trabajos de transcripción por lotes, despliegues en servidor con VRAM limitada y cualquier caso de uso donde quieras calidad de large-v3 a velocidad del modelo medium.
• No recomendado para: transcripción multilingüe — distil-large-v3 es solo inglés. Para otros idiomas, usa large-v3 o medium.

whisper.cpp — el port C/C++

• Soporte de plataformas: CPU (AVX2, AVX512, ARM NEON), Apple Metal (Core ML), CUDA (NVIDIA), Vulkan (GPU AMD/Intel), OpenCL.
• Ventaja en Apple Silicon: whisper.cpp exporta modelos al formato Core ML, habilitando inferencia en el Apple Neural Engine. Large-v3 funciona a ~10× tiempo real en M5 Pro mediante Metal — más rápido que cualquier ida y vuelta a la nube.
• Instalación: clona el repositorio, ejecuta make (o cmake). Binarios precompilados disponibles para plataformas comunes. Sin dependencia de Python.
• Descarga de modelo: bash ./models/download-ggml-model.sh base.en — descarga el archivo de modelo en formato GGML (~142 MB para base).
• Ejemplo de CLI: ./main -m models/ggml-base.bin -f audio.wav — transcribe un archivo WAV a la salida estándar. Añade -l es para español.
• Modo stream en tiempo real: ./stream -m models/ggml-base.bin --step 3000 --length 10000 — transcribe desde el micrófono en chunks de 3 segundos.
• Wrapper Python: pywhispercpp proporciona un binding Python para whisper.cpp, permitiendo su uso en pipelines Python sin sacrificar la aceleración Metal.
• Limitación: sin VAD (detección de actividad de voz) nativo. El modo stream requiere ajustar los parámetros --step y --length según el caso de uso.

# 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 — el port CTranslate2

• Soporte de plataformas: CPU (cuantización int8) y GPU NVIDIA CUDA. Sin soporte para Apple Metal — funciona solo en CPU en Mac.
• Ventaja de int8: la cuantización int8 de CTranslate2 reduce el VRAM en ~40% y aumenta la velocidad de inferencia ~2× respecto a float16, con impacto WER negligible (< 0,1% absoluto).
• Instalación: pip install faster-whisper — sin compilación necesaria. El soporte CUDA requiere CUDA 11.8+ y cuDNN 8.x.
• VAD integrado: faster-whisper incluye integración con Silero VAD, que omite automáticamente segmentos de audio silencioso — crítico para pipelines de transcripción en tiempo real.
• Python nativo: la API Python directa facilita la integración con LLMs, librerías de procesamiento de audio y frameworks web.
• Velocidad: large-v3 int8 en RTX 4070 funciona a ~12× tiempo real usando ~2,5 GB de VRAM. CPU int8 alcanza ~20× tiempo real para el modelo tiny.
• Procesamiento por lotes: faster-whisper admite inferencia en lotes para procesar grandes archivos de audio de forma eficiente.
• Limitación: sin soporte Metal en Mac — funciona solo en CPU en Apple Silicon, logrando ~3× tiempo real con large-v3 vs. ~10× de whisper.cpp con 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}")

Comparativa directa: tabla de benchmarks

Configuración de transcripción en tiempo real

• Modo stream de whisper.cpp: ejecuta ./stream -m models/ggml-small.bin --step 3000 --length 10000 -t 4. Procesa chunks de 3 segundos; latencia ~0,5–1,5 segundos con el modelo small. Sin Python necesario.
• Pipeline VAD de faster-whisper: usa vad_filter=True en model.transcribe(). Silero VAD segmenta el audio automáticamente en los límites de silencio — chunks más naturales que ventanas de longitud fija.
• Latencia práctica: 0,5–2 segundos detrás del habla en vivo con modelos small o medium. Usa tiny para la menor latencia (< 0,5 segundos, pero mayor WER).
• Selección de modelo para tiempo real: small o base es el punto óptimo práctico — suficientemente rápido para seguir el habla, suficientemente preciso para audio limpio. Evita large-v3 en tiempo real salvo que tengas una GPU dedicada.
• Entrada de micrófono: whisper.cpp lee audio raw mediante SDL2 o portaudio. faster-whisper lee arrays de audio desde cualquier librería Python de audio (sounddevice, pyaudio, soundfile).
• Estabilidad: el modo stream de whisper.cpp puede producir tokens repetidos ("alucinaciones" de rellenos cortos) en silencio. Suprime con --suppress-blank y --no-speech-threshold.

Apple Silicon: gana whisper.cpp

• Exportación a Core ML: ejecuta ./models/generate-coreml-model.sh large-v3 para exportar el encoder al formato Core ML. Esto descarga la inferencia del encoder al Apple Neural Engine.
• Benchmark M5 Pro (large-v3, Metal): ~10× tiempo real. 60 minutos de audio transcritos en ~6 minutos. Nota: el M5 Pro salió en marzo de 2026 — estos son benchmarks tempranos de la comunidad. El rendimiento puede mejorar con actualizaciones de whisper.cpp optimizando el M5 Neural Engine.
• Benchmark M3 MacBook Air (large-v3, Metal): ~7× tiempo real. 60 minutos en ~8,5 minutos.
• Memoria: la memoria unificada significa que no hay VRAM separada — un M5 Pro de 16 GB puede ejecutar large-v3 (~3 GB) cómodamente junto a otros procesos.
• faster-whisper en Mac: solo CPU, int8. Large-v3 a ~3× tiempo real. Usable para transcripción por lotes nocturna, pero no para tiempo real o flujos de trabajo sensibles al tiempo.
• Recomendación: usa whisper.cpp para todo el trabajo STT en Mac. Añade pywhispercpp si necesitas integración Python manteniendo la aceleración Metal.

GPU NVIDIA: gana faster-whisper

• Benchmark RTX 4070 (12 GB) (large-v3 int8): ~12× tiempo real, ~2,5 GB VRAM.
• Benchmark RTX 3060 (12 GB) (large-v3 int8): ~8× tiempo real, ~2,5 GB VRAM.
• Benchmark RTX 4060 (8 GB) (large-v3 int8): ~7× tiempo real, ~2,5 GB VRAM — cabe con margen.
• int8 vs float16: int8 es ~2× más rápido y usa ~40% menos VRAM con pérdida de precisión negligible. Usa siempre compute_type="int8" en NVIDIA.
• Procesamiento por lotes: el parámetro batched=True de faster-whisper permite el procesamiento paralelo de múltiples archivos de audio, maximizando la utilización GPU en trabajos grandes de transcripción.
• Integración en pipeline Python: faster-whisper se integra directamente en LangChain, Haystack y pipelines Python personalizados. Sin overhead de subproceso comparado con envolver whisper.cpp.

Cuándo usar cuál

Más allá de whisper.cpp y faster-whisper

• WhisperX:** construido sobre faster-whisper, WhisperX añade marcas de tiempo a nivel de palabra y diarización de hablantes — identificando qué hablante dijo qué palabras. Mejor para: transcripción de reuniones con etiquetas de hablante, edición de podcasts y transcripción de entrevistas. Instala con pip install whisperx y proporciona un token de Hugging Face para el modelo de diarización.
• insanely-fast-whisper:** un wrapper de pipeline Hugging Face Transformers que añade soporte de Flash Attention 2 para inferencia GPU significativamente más rápida que faster-whisper estándar en hardware NVIDIA. Mejor para: procesamiento por lotes de grandes archivos de audio en GPUs NVIDIA. Requiere una GPU compatible con Flash Attention 2 (Ampere o más reciente: RTX 3000+, A100, H100).

Problemas comunes y soluciones

• Incompatibilidad de versión CUDA: faster-whisper requiere CUDA 11.8 o posterior. Verifica con nvcc --version. Si tu CUDA es más antigua, actualiza el driver o instala faster-whisper en un entorno conda con cudatoolkit=11.8.
• Falla la exportación del modelo Metal: asegúrate de tener instaladas las Xcode Command Line Tools — ejecuta xcode-select --install. El script de exportación Core ML requiere el paquete Python coremltools: pip install coremltools.
• Alucinaciones en el silencio: ambas herramientas pueden producir tokens de relleno repetidos en segmentos de audio silencioso. Usa --no-speech-threshold 0.6 en el modo stream de whisper.cpp, o vad_filter=True en model.transcribe() de faster-whisper para omitir automáticamente los segmentos silenciosos.
• Sin memoria con large-v3: cambia a cuantización int8 en faster-whisper (compute_type="int8") — reduce el VRAM de ~5 GB (float16) a ~2,5 GB. En whisper.cpp, usa la variante GGML cuantizada (p. ej., ggml-large-v3-q5_0.bin) que reduce la memoria a ~3–4 GB.
• Salida ilegible en audio no inglés: no uses variantes .en del modelo (tiny.en, base.en) para habla no inglesa — son solo inglés. Usa los modelos multilingüe (base, small, medium, large-v3) y especifica el idioma explícitamente: -l es en whisper.cpp o language="es" en faster-whisper.
• Inferencia CPU lenta: verifica que tu CPU admita instrucciones AVX2 (necesarias para inferencia CPU optimizada). Comprueba con grep avx2 /proc/cpuinfo en Linux o sysctl machdep.cpu.features en Mac. Las CPUs sin AVX2 recurren a SIMD genérico y serán 2–3× más lentas.

Preguntas frecuentes

Fuentes

• whisper.cpp en GitHub — Código fuente, instrucciones de compilación, scripts de descarga de modelos y guía de configuración Metal/Core ML.
• faster-whisper en GitHub — Código fuente, documentación de la API Python y resultados de benchmarks.
• distil-whisper/distil-large-v3 en Hugging Face — Ficha del modelo, resultados de benchmarks e instrucciones de uso de la variante destilada de Whisper.
• WhisperX en GitHub — Marcas de tiempo a nivel de palabra y diarización de hablantes construidas sobre faster-whisper.
• insanely-fast-whisper en GitHub — Pipeline Whisper Flash Attention 2 para máximo rendimiento en GPU NVIDIA.
• OpenAI Whisper en GitHub — Modelo Whisper original, paper y fichas de modelo para todos los tamaños.
• Paper de OpenAI Whisper (Radford et al., 2022) — "Robust Speech Recognition via Large-Scale Weak Supervision". Fuente de los valores WER.
• Documentación de CTranslate2 — Detalles de cuantización, soporte de hardware y fundamentos de optimización int8.

Lectura relacionada

• TTS local y clonación de voz 2026: Piper vs Coqui vs XTTS v2 — El complemento TTS: convierte el texto transcrito de nuevo en voz, offline.
• Construye un asistente de voz completamente offline en 2026 — Conecta Whisper STT a un LLM local y Piper TTS en un pipeline de voz completo.
• Pipeline de IA multimodal local 2026 — Añade modelos de visión junto a STT y TTS para un stack local multimodal completo.
• Guía de hardware para LLM local 2026 — Requisitos de GPU y RAM para el pipeline completo de voz + LLM.
• Construye un asistente de voz local en tu teléfono — Versión móvil: WhisperKit en iPhone, Layla en Android.