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. Não é preciso acordo de processamento de dados para conformidade com a LGPD — o processamento acontece localmente.
• 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 (junho de 2026)

• 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): versão estável atual; pip install faster-whisper a instala. Não há versão de 2026 até esta atualização — o projeto está estável, não parado.
• Nenhum novo modelo Whisper base em 2026. large-v3 e distil-large-v3 continuam sendo os pesos mais recentes, então as «atualizações» de qualquer das ferramentas são mudanças de runtime e de tooling, 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. O suporte CUDA requer CUDA 11.8+ e cuDNN 8.x.
• 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

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.

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: faster-whisper requer CUDA 11.8 ou posterior. Verifique com nvcc --version. Se o seu CUDA for mais antigo, atualize o driver ou instale faster-whisper em um ambiente conda com cudatoolkit=11.8.
• 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.

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 2026 — 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.