Whisper.cpp vs faster-whisper 2026: Benchmarks de STT local, configuração e aceleração de GPU

Fatos rápidos

• Ambas as ferramentas: baseadas no modelo Whisper de código aberto da OpenAI (licença MIT). Mesma precisão — runtimes diferentes.
• whisper.cpp: escrito em C/C++ por Georgi Gerganov. Suporta CPU (AVX2/NEON), CUDA, Metal (Apple), Vulkan. Não requer Python.
• faster-whisper: biblioteca Python usando CTranslate2. Suporta CPU (int8) e CUDA. Sem suporte a Apple Metal.
• Tamanhos do modelo Whisper: tiny (39M), base (74M), small (244M), medium (769M), large-v3 (1,55B). Todos no formato ggml / CTranslate2.
• Melhor modelo para a maioria dos casos: Whisper small — 3,4% WER, roda em 2 GB de RAM, 6× tempo real em CPU moderna.
• Benchmark RTX 4070 (large-v3): faster-whisper ~12× tempo real; whisper.cpp CUDA ~8× tempo real. faster-whisper vence em NVIDIA.
• Benchmark M5 Pro (large-v3): whisper.cpp Metal ~10× tempo real; faster-whisper somente CPU ~3× tempo real. whisper.cpp vence em Apple.

Por que reconhecimento de voz local?

• Privacidade: o áudio nunca sai da sua máquina, então nenhum provedor de nuvem participa da transcrição. As obrigações de proteção de dados, como base legal e armazenamento seguro, continuam sendo suas.
• Custo: sem tarifas por minuto. Um desenvolvedor que transcreve 8 horas de reuniões por semana economiza US$ 120–480/mês em relação aos preços de STT na nuvem.
• Offline: funciona em aviões, em instalações seguras e em áreas sem internet confiável. Sem gerenciamento de chaves de API.
• Latência: sem ida e volta de upload/download. Para interfaces de voz em tempo real, o processamento local reduz a latência de STT de 300–800 ms (nuvem) para 50–300 ms.
• Personalização: ajuste fino com vocabulário específico do domínio. Rode qualquer tamanho de modelo que caiba no seu hardware.
• Integração com Home Assistant: O Whisper rodando localmente significa que palavras de ativação e comandos de voz nunca saem da sua rede doméstica. Veja Whisper local no Home Assistant → para a configuração do complemento que substitui completamente o STT na nuvem.

Tamanhos do modelo Whisper — base de ambas as ferramentas

Distil-Whisper: a alternativa mais rápida

• Parâmetros: ~756M — cerca de metade dos 1,55B do large-v3, cabendo em ~4 GB de VRAM em vez de ~10 GB.
• Velocidade: ~6× tempo real em RTX 4070 (vs. 1× de referência para large-v3) — comparável ao modelo medium em velocidade, com precisão próxima à do large-v3.
• WER: ~2,6% em inglês — apenas ~0,1% acima dos 2,5% do large-v3. Na prática, a diferença é imperceptível em fala típica.
• Compatibilidade: funciona com faster-whisper de forma nativa (WhisperModel("distil-large-v3", device="cuda", compute_type="int8")). Para whisper.cpp, converta para o formato GGML usando o script de conversão GGML do distil-whisper.
• Melhor para: trabalhos de transcrição em lote, implantações em servidor com VRAM limitada e qualquer caso de uso em que você queira qualidade de large-v3 na velocidade do modelo medium.
• Não recomendado para: transcrição multilíngue — distil-large-v3 é somente inglês. Para outros idiomas, use large-v3 ou medium.

whisper.cpp — o port C/C++

• Suporte de plataformas: CPU (AVX2, AVX512, ARM NEON), Apple Metal (Core ML), CUDA (NVIDIA), Vulkan (GPU AMD/Intel), OpenCL.
• Vantagem em Apple Silicon: whisper.cpp exporta modelos para o formato Core ML, habilitando inferência no Apple Neural Engine. O large-v3 roda a ~10× tempo real em M5 Pro via Metal — mais rápido que qualquer ida e volta à nuvem.
• Instalação: clone o repositório, execute make (ou cmake). Binários pré-compilados disponíveis para plataformas comuns. Sem dependência de Python.
• Download do modelo: bash ./models/download-ggml-model.sh base.en — baixa o arquivo de modelo no formato GGML (~142 MB para base).
• Exemplo de CLI: ./main -m models/ggml-base.bin -f audio.wav — transcreve um arquivo WAV para a saída padrão. Adicione -l pt para português.
• Modo stream em tempo real: ./stream -m models/ggml-base.bin --step 3000 --length 10000 — transcreve do microfone em chunks de 3 segundos.
• Wrapper Python: pywhispercpp fornece um binding Python para whisper.cpp, permitindo seu uso em pipelines Python sem sacrificar a aceleração Metal.
• Limitação: sem VAD (detecção de atividade de voz) nativo. O modo stream exige ajustar os parâmetros --step e --length conforme o 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

whisper.cpp: versão mais recente e novidades

• whisper.cpp v1.9.5 (6 de outubro de 2026): sincroniza o ggml com a v0.26.0 (atualizações dos kernels CUDA, Vulkan, Metal, SYCL, OpenCL, WebGPU e CPU), adiciona um callback de aborto durante a detecção de idioma, corrige um estouro de inteiros nos deslocamentos de chunks paralelos e faz a CLI retornar o código de erro correto quando um arquivo falha.
• whisper.cpp v1.9.4 (11 de setembro de 2026): o servidor agora retorna o idioma detectado, o callback do encoder roda antes da detecção automática de idioma e o Windows on ARM foi adicionado ao job de release.
• whisper.cpp v1.9.3 (20 de agosto de 2026): sincronização do ggml com a v0.20.2, melhorias de desempenho em todos os backends, quantização Metal TQ2_0, kernels CUDA/SYCL combinados e correções para ARM/WASI.
• whisper.cpp v1.9.0 a v1.9.2 (junho a agosto de 2026): versões intermediárias da mesma linha de sincronização do ggml antes da v1.9.3.
• whisper.cpp v1.8.6 (2 de junho de 2026): reimplementação do ffmpeg-transcode para uma decodificação opcional com FFmpeg mais clara de áudio comprimido (MP3, M4A), além de uma correção do caminho de exemplos no CI.
• whisper.cpp v1.8.5 (maio de 2026): melhorias no VAD por streaming (detecção de atividade de voz), correções de vazamento de parâmetros do servidor e de carimbos de tempo de tokens, e correções de vazamentos de memória nos bindings de Ruby e VAD.
• whisper.cpp v1.8.4 (19 de março de 2026): sincronização mais recente do ggml com amplos ganhos de desempenho, uma nova flag -g / --gpu-device (e seleção de dispositivo GGML_CUDA) para escolher uma GPU, e correções de quebra de segmentos UTF-8.
• O VAD nativo agora vem integrado ao whisper.cpp. Versões recentes adicionaram um caminho nativo de detecção de atividade de voz, reduzindo uma vantagem de longa data do faster-whisper — embora a integração do Silero VAD do faster-whisper continue mais pronta para uso.
• faster-whisper v1.2.1 (31 de outubro de 2025): última versão marcada; pip install faster-whisper a instala. Não há versão marcada em 2026, mas a branch principal está ativa: commits de 16 de outubro de 2026 adicionam validações de entrada, como um erro para idiomas que um modelo não suporta. A v1.2.0 (agosto de 2025) adicionou suporte ao distil-large-v3.5.
• CTranslate2 v4.8.3 (13 de outubro de 2026): o motor de inferência por baixo do faster-whisper continua sendo lançado. A série v4.8 trouxe correções de ROCm no Windows, reforço no carregamento de modelos e a correção de uma divisão por zero no Whisper align() quando uma janela não tem quadros.
• Nenhum modelo Whisper novo de classe superior em 2026. Os pesos multilíngues mais recentes da OpenAI continuam sendo o large-v3-turbo (outubro de 2024; 809M de parâmetros, decoder reduzido de 32 para 4 camadas, licença MIT), que troca uma pequena perda de qualidade por muito mais velocidade e roda nas duas ferramentas. O distil-large-v3 segue como a opção rápida só para inglês. As atualizações de ambos os runtimes são mudanças de runtime e de ferramentas, não de precisão.

faster-whisper — o port CTranslate2

• Suporte de plataformas: CPU (quantização int8) e GPU NVIDIA CUDA. Sem suporte a Apple Metal — roda somente em CPU no Mac.
• Vantagem do int8: a quantização int8 do CTranslate2 reduz a VRAM em ~40% e aumenta a velocidade de inferência em ~2× em relação ao float16, com impacto no WER negligível (< 0,1% absoluto).
• Instalação: pip install faster-whisper — sem compilação necessária (Python 3.9+). O uso de GPU exige NVIDIA cuBLAS para CUDA 12 e cuDNN 9; configurações antigas com CUDA 11 / cuDNN 8 precisam fixar um ctranslate2 mais antigo (3.24.0).
• VAD integrado: faster-whisper inclui integração com Silero VAD, que pula automaticamente segmentos de áudio silencioso — crítico para pipelines de transcrição em tempo real.
• Python nativo: a API Python direta facilita a integração com LLMs, bibliotecas de processamento de áudio e frameworks web.
• Velocidade: large-v3 int8 em RTX 4070 roda a ~12× tempo real usando ~2,5 GB de VRAM. CPU int8 atinge ~20× tempo real para o modelo tiny.
• Processamento em lote: faster-whisper suporta inferência em lote para processar grandes arquivos de áudio de forma eficiente.
• Limitação: sem suporte Metal no Mac — roda somente em CPU no Apple Silicon, atingindo ~3× tempo real com large-v3 vs. ~10× do whisper.cpp com 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}")

Obtenha ggml-base.bin via pip (configuração Python)

• Instale o binding: pip install pywhispercpp. Para aceleração NVIDIA CUDA, compile com GGML_CUDA=1 pip install git+https://github.com/absadiki/pywhispercpp.
• Download automático do ggml-base.bin: from pywhispercpp.model import Model e então model = Model("base") baixa ggml-base.bin do Hugging Face (ggerganov/whisper.cpp) na primeira execução e o armazena em cache. Use "base.en" para a variante somente em inglês.
• Download manual (via CLI, sem pip): a partir de um repositório whisper.cpp clonado, bash ./models/download-ggml-model.sh base salva o arquivo em models/ggml-base.bin — o mesmo arquivo que o pywhispercpp busca.
• Download direto: curl -L -o ggml-base.bin https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin obtém o modelo sem script. Troque base por tiny, small, medium ou large-v3.
• Não confunda os pacotes: pip install openai-whisper instala o Whisper PyTorch original da OpenAI (ele usa checkpoints .pt, não ggml-base.bin). pip install faster-whisper usa o formato CTranslate2. Apenas o pywhispercpp consome arquivos GGML ggml-*.bin.
• Onde o arquivo fica: o pywhispercpp armazena os modelos GGML baixados no cache do seu módulo (ou em um caminho que você passe via Model("base", models_dir="...")), de modo que o mesmo ggml-base.bin é reutilizado entre execuções — sem novo download.

# 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

Comparação direta: tabela de benchmarks

Benchmark de referência: tempos de GPU vs CPU do faster-whisper

Configuração de transcrição em tempo real

• Modo stream do whisper.cpp: execute ./stream -m models/ggml-small.bin --step 3000 --length 10000 -t 4. Processa chunks de 3 segundos; latência ~0,5–1,5 segundo com o modelo small. Sem Python necessário.
• Pipeline VAD do faster-whisper: use vad_filter=True em model.transcribe(). Silero VAD segmenta o áudio automaticamente nos limites de silêncio — chunks mais naturais do que janelas de comprimento fixo.
• Latência prática: 0,5–2 segundos atrás da fala ao vivo com modelos small ou medium. Use tiny para a menor latência (< 0,5 segundo, mas WER maior).
• Seleção de modelo para tempo real: small ou base é o ponto ideal prático — rápido o suficiente para acompanhar a fala, preciso o suficiente para áudio limpo. Evite large-v3 em tempo real a menos que você tenha uma GPU dedicada.
• Entrada de microfone: whisper.cpp lê áudio raw via SDL2 ou portaudio. faster-whisper lê arrays de áudio de qualquer biblioteca Python de áudio (sounddevice, pyaudio, soundfile).
• Estabilidade: o modo stream do whisper.cpp pode produzir tokens repetidos ("alucinações" de preenchimentos curtos) no silêncio. Suprima com --suppress-blank e --no-speech-threshold.

Apple Silicon: whisper.cpp vence

• Exportação para Core ML: execute ./models/generate-coreml-model.sh large-v3 para exportar o encoder para o formato Core ML. Isso descarrega a inferência do encoder no Apple Neural Engine.
• Benchmark M5 Pro (large-v3, Metal): ~10× tempo real. 60 minutos de áudio transcritos em ~6 minutos. Observação: o M5 Pro foi lançado em março de 2026 — estes são benchmarks iniciais da comunidade. O desempenho pode melhorar com atualizações do whisper.cpp otimizando o M5 Neural Engine.
• Benchmark M3 MacBook Air (large-v3, Metal): ~7× tempo real. 60 minutos em ~8,5 minutos.
• Memória: a memória unificada significa que não há VRAM separada — um M5 Pro de 16 GB pode rodar large-v3 (~3 GB) confortavelmente junto a outros processos.
• faster-whisper no Mac: somente CPU, int8. Large-v3 a ~3× tempo real. Utilizável para transcrição em lote noturna, mas não para tempo real ou fluxos de trabalho sensíveis ao tempo.
• Recomendação: use whisper.cpp para todo o trabalho de STT no Mac. Adicione pywhispercpp se você precisar de integração Python mantendo a aceleração Metal.

GPU NVIDIA: faster-whisper vence

• Benchmark RTX 4070 (12 GB) (large-v3 int8): ~12× tempo real, ~2,5 GB VRAM.
• Benchmark RTX 3060 (12 GB) (large-v3 int8): ~8× tempo real, ~2,5 GB VRAM.
• Benchmark RTX 4060 (8 GB) (large-v3 int8): ~7× tempo real, ~2,5 GB VRAM — cabe com folga.
• int8 vs float16: int8 é ~2× mais rápido e usa ~40% menos VRAM com perda de precisão negligível. Use sempre compute_type="int8" em NVIDIA.
• Processamento em lote: o parâmetro batched=True do faster-whisper permite o processamento paralelo de múltiplos arquivos de áudio, maximizando a utilização da GPU em grandes trabalhos de transcrição.
• Integração em pipeline Python: faster-whisper se integra diretamente ao LangChain, Haystack e pipelines Python personalizados. Sem overhead de subprocesso em comparação com envolver o whisper.cpp.

GPUs NVIDIA antigas (GTX 970): int8 recua para float32

• O que continua funcionando: os binários pré-compilados do CTranslate2 suportam GPUs NVIDIA com compute capability 3.5 ou superior, então uma GTX 970 (5.2) pode rodar o faster-whisper em CUDA, desde que as bibliotecas CUDA e cuDNN instaladas correspondam à versão (veja Problemas comuns).
• Onde o int8 em GPU funciona: o int8 exige compute capability 7.0 ou superior (Volta e série RTX 20 em diante) ou exatamente 6.1 (GTX 1050 a 1080 Ti, int8_float32). As compute capability 6.0, 6.2 e inferiores recuam para float32; o float16 exige 7.0 ou superior.
• Consequência na memória: o float32 usa 4 bytes por parâmetro contra 1 byte do int8; pela contagem de parâmetros, o large-v3 (1,55B) precisa de cerca de 6 GB só para os pesos, mais que os 4 GB da GTX 970. O small (244M, ~1 GB em float32) cabe com folga; o medium (769M, ~3 GB) fica no limite.
• Velocidade: não medimos uma GTX 970, então não há número medido aqui. Espere um desempenho em float32 bem abaixo dos números de RTX 4070 int8 deste guia e teste tiny, base e small com o seu próprio áudio.
• Veja o que a sua GPU suporta: ctranslate2.get_supported_compute_types("cuda") lista os tipos de computação que o CTranslate2 aceita na sua placa.
• Alternativas: int8 em CPU (device="cpu", compute_type="int8") funciona em qualquer CPU x86 moderna, e os modelos GGML quantizados do whisper.cpp (por exemplo ggml-large-v3-q5_0.bin, cerca de 3–4 GB) são o caminho usual para encaixar modelos maiores em 4 GB; verifique o build CUDA ou Vulkan na sua placa.

import ctranslate2
from faster_whisper import WhisperModel

# Which compute types does this GPU accept?
print(ctranslate2.get_supported_compute_types("cuda"))

# On compute capability < 6.1 (e.g. GTX 970), request float32 explicitly so nothing is converted silently
model = WhisperModel("small", device="cuda", compute_type="float32")

Whisper no Raspberry Pi 5: tiny, base e small

• Whisper small no Pi 5: cerca de 0,4–0,6× tempo real em CPU (um clipe de 10 minutos leva ~17–25 minutos). Preciso com 3,4% WER, mas lento demais para legendagem ao vivo — use-o para transcrição noturna/em lote.
• Whisper base no Pi 5: em torno do tempo real até ~2× com multithreading (-t 4). O ponto ideal prático para transcrição ao vivo no Pi, com WER aceitável de 5,0%.
• Whisper tiny no Pi 5: a opção mais rápida, confortavelmente mais rápida que o tempo real para uso ao vivo, ao custo de um WER mais alto de 7,6%. Ideal para reconhecimento de palavra de ativação e comandos curtos.
• Use modelos quantizados: bash ./models/download-ggml-model.sh small-q5_0 reduz a RAM e acelera a inferência com perda mínima de precisão — importante na memória compartilhada do Pi 5.
• faster-whisper no Pi 5: instalável (pip install faster-whisper, CPU int8) e competitivo para trabalhos em lote, mas o binário C mais leve do whisper.cpp é a escolha embarcada mais comum.
• Térmica: a transcrição sustentada exige muito da CPU do Pi 5 — use refrigeração ativa para evitar o throttling térmico que degrada esses números.

Quando usar cada um

Além do whisper.cpp e do faster-whisper

• WhisperX: construído sobre o faster-whisper, o WhisperX adiciona marcas de tempo em nível de palavra e diarização de falantes — identificando qual falante disse quais palavras. Melhor para: transcrição de reuniões com rótulos de falante, edição de podcasts e transcrição de entrevistas. Instale com pip install whisperx e forneça um token do Hugging Face para o modelo de diarização.
• insanely-fast-whisper: um wrapper de pipeline Hugging Face Transformers que adiciona suporte a Flash Attention 2 para inferência em GPU significativamente mais rápida que o faster-whisper padrão em hardware NVIDIA. Melhor para: processamento em lote de grandes arquivos de áudio em GPUs NVIDIA. Requer uma GPU compatível com Flash Attention 2 (Ampere ou mais recente: RTX 3000+, A100, H100).

Problemas comuns e soluções

• Incompatibilidade de versão do CUDA: as versões atuais do faster-whisper exigem cuBLAS para CUDA 12 e cuDNN 9. Se você está preso a bibliotecas antigas, fixe o ctranslate2: pip install --force-reinstall ctranslate2==4.4.0 (CUDA 12 com cuDNN 8) ou 3.24.0 (CUDA 11 com cuDNN 8). Verifique a versão do CUDA com nvcc --version.
• Falha na exportação do modelo Metal: garanta que as Xcode Command Line Tools estejam instaladas — execute xcode-select --install. O script de exportação Core ML requer o pacote Python coremltools: pip install coremltools.
• Alucinações no silêncio: ambas as ferramentas podem produzir tokens de preenchimento repetidos em segmentos de áudio silencioso. Use --no-speech-threshold 0.6 no modo stream do whisper.cpp, ou vad_filter=True em model.transcribe() do faster-whisper para pular automaticamente os segmentos silenciosos.
• Sem memória com large-v3: mude para quantização int8 no faster-whisper (compute_type="int8") — reduz a VRAM de ~5 GB (float16) para ~2,5 GB. No whisper.cpp, use a variante GGML quantizada (p. ex., ggml-large-v3-q5_0.bin) que reduz a memória para ~3–4 GB.
• Saída ilegível em áudio não inglês: não use variantes .en do modelo (tiny.en, base.en) para fala não inglesa — são somente inglês. Use os modelos multilíngues (base, small, medium, large-v3) e especifique o idioma explicitamente: -l pt no whisper.cpp ou language="pt" no faster-whisper.
• Inferência lenta em CPU: verifique se a sua CPU suporta instruções AVX2 (necessárias para inferência otimizada em CPU). Confira com grep avx2 /proc/cpuinfo no Linux ou sysctl machdep.cpu.features no Mac. CPUs sem AVX2 recorrem a SIMD genérico e serão 2–3× mais lentas.

Perguntas frequentes

Fontes

• whisper.cpp no GitHub — Código-fonte, instruções de compilação, scripts de download de modelos e guia de configuração Metal/Core ML.
• faster-whisper no GitHub — Código-fonte, documentação da API Python e resultados de benchmarks.
• distil-whisper/distil-large-v3 no Hugging Face — Ficha do modelo, resultados de benchmarks e instruções de uso da variante destilada do Whisper.
• WhisperX no GitHub — Marcas de tempo em nível de palavra e diarização de falantes construídas sobre o faster-whisper.
• insanely-fast-whisper no GitHub — Pipeline Whisper Flash Attention 2 para máximo throughput em GPU NVIDIA.
• OpenAI Whisper no GitHub — Modelo Whisper original, paper e fichas de modelo para todos os tamanhos.
• Paper do OpenAI Whisper (Radford et al., 2022) — "Robust Speech Recognition via Large-Scale Weak Supervision". Fonte dos valores de WER.
• Documentação do CTranslate2 — Detalhes de quantização, suporte de hardware e fundamentos da otimização int8.
• Documentação de quantização do CTranslate2 — Tipos de computação que cada compute capability de GPU suporta (base da seção sobre a GTX 970).
• Benchmarks do README do faster-whisper — Tempos de GPU e CPU em 13 minutos usados no benchmark de referência, e os requisitos atuais de CUDA 12 / cuDNN 9.
• openai/whisper-large-v3-turbo no Hugging Face — Model card: 809M de parâmetros, 4 camadas de decoder, licença MIT.
• Bill Mill: benchmark atualizado de mlx_whisper vs. whisper.cpp — Comparação independente de tempos do large-v3-turbo no Apple Silicon.
• Releases do whisper.cpp — Notas de versão da v1.9.4 e da v1.9.5.

Leitura relacionada

• TTS local e clonagem de voz 2026: Piper vs Coqui vs XTTS v2 — O complemento de TTS: converta o texto transcrito de volta em voz, offline.
• Construa um assistente de voz totalmente offline em 2026 — Conecte Whisper STT a um LLM local e Piper TTS em um pipeline de voz completo.
• Pipeline de IA multimodal local 2026 — Adicione modelos de visão junto a STT e TTS para um stack local multimodal completo.
• Guia de hardware para LLM local — Requisitos de GPU e RAM para o pipeline completo de voz + LLM.
• Construa um assistente de voz local no seu celular — Versão móvel: WhisperKit no iPhone, Layla no Android.