Quem já tentou colocar reconhecimento de fala pra funcionar em produção sabe: é um inferno. Whisper precisa de Python, ONNX trava em certas GPUs, modelos MLX só rodam no Mac, e no fim você acaba pagando API da OpenAI ou do Google porque “pelo menos funciona”. O transcribe.cpp chegou pra acabar com essa palhaçada.

O projeto, que explodiu no Hacker News esta semana com mais de 500 upvotes, é basicamente o que o llama.cpp fez pelos LLMs, só que para modelos de fala. Uma biblioteca C/C++ que roda 16 famílias de modelos (mais de 60 variantes) usando o runtime ggml, com aceleração GPU via Metal, Vulkan e CUDA. Tudo local, sem cloud, sem API key, sem surpresa na fatura.

Por que mais um projeto de STT?

Eu sei o que você está pensando: “já não existe o whisper.cpp pra isso?”. Existe. E ele é bom. Mas o whisper.cpp faz uma coisa: roda modelos Whisper (e a Apple já lançou o SpeechAnalyzer que é 3x mais rápido). Ponto. Se você quer testar o Parakeet da NVIDIA, o Moonshine da Useful Sensors, o SenseVoice da Alibaba ou o novo Qwen3-ASR, precisa de ferramentas completamente diferentes pra cada um. Bibliotecas diferentes, dependências diferentes, bugs diferentes.

O CJ Pais, criador do transcribe.cpp (e ex-contribuidor do llamafile da Mozilla), identificou esse problema na prática enquanto desenvolvia o Handy, um app de transcrição que chegou a ser destaque na WIRED. Cada modelo de fala vive numa bolha isolada: seu próprio framework, suas próprias dependências, e quase sempre sem aceleração GPU decente fora do ecossistema original.

A solução? Unificar tudo no formato GGUF (o mesmo que o llama.cpp popularizou) e rodar sobre o ggml, que já resolve aceleração em praticamente qualquer hardware. Mesma ideia que o Georgi Gerganov teve com o llama.cpp: pega os pesos do modelo, converte pra um formato eficiente, e roda nativo em C++ sem precisar de todo o ecossistema Python/PyTorch/ONNX. Só que agora pra voz.

16 Famílias de Modelos: O Catálogo Completo

Aqui é onde a coisa fica interessante. O transcribe.cpp não suporta “uns modelinhos”: são 16 famílias inteiras com mais de 60 variantes. Veja o que já funciona:

A parte mais bacana: todos esses modelos passam por validação numérica e testes de WER (Word Error Rate) contra suas implementações de referência. Ou seja, não é “confia que funciona”. Cada modelo publicado pelo time do handy-computer tem a mesma qualidade da implementação original, comprovada por testes automatizados.

Instalação em 2 Comandos

Sem pip, sem conda, sem Docker. Só CMake:

cmake -B build
cmake --build build

Quer GPU? Adiciona a flag:

# Metal (Apple Silicon, já automático)
cmake -B build

# Vulkan (Linux/Windows)
cmake -B build -DTRANSCRIBE_VULKAN=ON

# CUDA (NVIDIA)
cmake -B build -DTRANSCRIBE_CUDA=ON

E pra usar:

build/bin/transcribe-cli -m modelo.gguf samples/jfk.wav

O áudio precisa estar em WAV 16kHz mono. Se o seu arquivo está em outro formato, um ffmpeg resolve:

ffmpeg -i audio.mp3 -ar 16000 -ac 1 audio.wav

A API C que Qualquer Linguagem Entende

Um dos pontos mais fortes do projeto é a API. É um único header C (transcribe.h), o que significa que qualquer linguagem com FFI consegue usar. Já existem bindings oficiais pra:

• Python (pip install transcribe-cpp)
• TypeScript/JavaScript (npm)
• Rust (crate)
• Swift/Objective-C (pra quem quer colocar em apps iOS/macOS)

Pra quem vem do whisper.cpp, a migração é quase transparente: o transcribe.cpp aceita os mesmos arquivos .bin do whisper.cpp. Você pode literalmente trocar a biblioteca sem baixar modelos novamente.

Quantização: Modelos Menores, Mesma Qualidade

Assim como no mundo dos LLMs, você pode quantizar os modelos de fala pra reduzir o tamanho e aumentar a velocidade. O transcribe.cpp vem com uma ferramenta de quantização integrada:

cmake -B build -DTRANSCRIBE_BUILD_TOOLS=ON
cmake --build build
build/bin/transcribe-quantize modelo-f16.gguf modelo-q4.gguf Q4_K_M

Os presets disponíveis:

Na prática, um modelo Whisper large-v3 que ocupa 3GB em F16 cabe em menos de 1GB com Q4_K_M, e a diferença no WER é mínima. Pra quem roda em hardware limitado, isso é ouro.

Streaming: Transcrição em Tempo Real

O transcribe.cpp suporta tanto processamento em batch (arquivo inteiro) quanto streaming (em tempo real, enquanto o áudio está sendo capturado). E não é streaming “fake” onde ele processa chunks de 30 segundos e concatena. É streaming de verdade, com modelos desenhados pra isso como o Moonshine Streaming e o FunASR Nano.

Isso abre portas pra aplicações que até pouco tempo exigiam serviços pagos:

• Legendas ao vivo em videoconferências, sem depender do Google Meet ou Zoom
• Assistentes de voz que rodam 100% local, sem latência de rede
• Transcrição de reuniões sem mandar áudio pra nenhum servidor (perfeito pra empresas com dados sensíveis)
• Apps de acessibilidade que funcionam offline, em qualquer lugar
• Monitoramento de call center em tempo real, sem custos de API por minuto

Com modelos como o Moonshine Streaming (27M de parâmetros), dá pra rodar transcrição em tempo real até num Raspberry Pi ou num RK3566 (aquelas placas ARM de US$ 20). Sem exagero. O criador testou em hardware desse nível e funciona.

Pra quem já tentou montar um sistema de transcrição em tempo real com Python + Whisper, sabe que a latência mata. São 2, 3, às vezes 5 segundos de atraso. Com o transcribe.cpp rodando C++ nativo com aceleração GPU, a latência cai pra frações de segundo. A diferença na experiência do usuário é absurda.

whisper.cpp vs. transcribe.cpp: Quando Usar Cada Um

Vou ser direto: se você só precisa rodar Whisper e nada mais, o whisper.cpp continua sendo uma opção sólida. É maduro, estável, e a comunidade é enorme.

Mas se você precisa de qualquer uma dessas coisas, o transcribe.cpp é a escolha certa:

• Testar vários modelos pra encontrar o melhor pro seu caso de uso
• Rodar modelos especializados (médico, multilíngue, diarização)
• Suporte a Vulkan (o whisper.cpp historicamente tem suporte GPU mais limitado)
• Uma API unificada que funciona igual independente do modelo
• Quantização integrada com presets otimizados

Na prática, o transcribe.cpp é um superset do whisper.cpp. Ele faz tudo que o whisper.cpp faz (inclusive lê os mesmos arquivos de modelo) e muito mais.

Quem Está por Trás

O projeto não é um hobby de fim de semana. Tem apoio real:

• Mozilla AI: O transcribe.cpp é o primeiro projeto independente do programa Builders in Residence da Mozilla AI
• Hugging Face: Hospeda os modelos GGUF no hub
• Modal: Fornece créditos GPU pra testes contínuos de validação
• Blacksmith: Infraestrutura de CI/CD

O criador, CJ Pais, é o mesmo desenvolvedor do Handy (app de transcrição local que foi destaque na WIRED) e contribuiu pro llamafile da Mozilla. Não é alguém que caiu de paraquedas no assunto.

Casos de Uso Práticos

Vou listar alguns cenários onde o transcribe.cpp brilha, com exemplos reais de como implementar cada um:

1. Podcast com transcrição automática

Você tem um podcast semanal e quer gerar transcrições pra SEO (Google indexa texto, não áudio). Com o Parakeet 1.1B da NVIDIA, que tem um dos melhores WER do mercado, o fluxo fica assim:

# Converte o episódio pra formato esperado
ffmpeg -i episodio-42.mp3 -ar 16000 -ac 1 episodio-42.wav

# Transcreve com o Parakeet (melhor accuracy em inglês)
build/bin/transcribe-cli -m parakeet-tdt-1.1b-q8.gguf episodio-42.wav > transcricao.txt

Num Mac M2, um episódio de 1 hora processa em poucos minutos. Sem Python, sem venv, sem dependências quebradas.

2. App mobile com reconhecimento de voz offline

Com os bindings Swift e o modelo Moonshine tiny (27M parâmetros), você consegue embedding direto num app iOS que funciona sem internet. O modelo inteiro cabe em menos de 30MB quantizado. Pra contexto: o app de teclado do seu celular provavelmente é maior que isso.

Isso é perfeito pra apps de anotação por voz, tradução offline ou qualquer coisa que precise funcionar em avião, metrô ou áreas sem sinal.

3. Pipeline de legendas pra YouTube

Quem produz conteúdo em vídeo sabe: legendas aumentam retenção em 40% e são obrigatórias pra acessibilidade. Com o transcribe.cpp, você automatiza isso sem pagar nenhum serviço:

# Converte vídeo pra áudio
ffmpeg -i video.mp4 -ar 16000 -ac 1 audio.wav

# Transcreve com timestamps em formato SRT
build/bin/transcribe-cli -m whisper-large-v3-turbo-q5.gguf audio.wav --output-srt

# Resultado: arquivo .srt pronto pra importar no editor de vídeo

4. Transcrição médica local (HIPAA-compliant)

Com o MedASR, você roda transcrição de consultas médicas sem mandar áudio pra cloud nenhuma. O modelo entende terminologia médica (nomes de medicamentos, procedimentos, diagnósticos) e tudo roda na máquina local. Compliance de graça, sem contratos de DPA com provedores de cloud.

5. Diarização: quem falou o quê

O MOSS Transcribe-Diarize não faz só transcrição. Ele identifica diferentes falantes no áudio. Perfeito pra atas de reunião automatizadas, onde você precisa saber que “Speaker 1 disse X” e “Speaker 2 respondeu Y”. Até pouco tempo, isso exigia APIs caras como a do Assembly AI ou do Deepgram.

O Ecossistema GGML Está Engolindo Tudo

Se você parar pra pensar, o padrão é claro. O llama.cpp democratizou LLMs locais. O stable-diffusion.cpp fez o mesmo pra geração de imagem. O whisper.cpp abriu o caminho pra fala. E agora o transcribe.cpp pega o bastão e leva pra outro nível, suportando dezenas de modelos de múltiplos fornecedores. Tudo roda no mesmo runtime (ggml), no mesmo formato de modelo (GGUF), com as mesmas otimizações de hardware.

O que está acontecendo é uma padronização silenciosa. Assim como o Docker padronizou containers e o ONNX tentou (sem muito sucesso) padronizar modelos de ML, o GGUF está se tornando o formato universal pra rodar modelos de IA em hardware de consumo. E o ggml é o runtime que faz tudo funcionar, abstraindo Metal, Vulkan, CUDA e CPU de forma transparente.

Daqui a pouco, rodar toda a stack de IA localmente (texto, imagem, voz, vídeo) vai ser tão comum quanto rodar um banco de dados local. E o mais importante: vai ser acessível pra qualquer dev com um PC gamer ou um Mac M-qualquer-coisa (aliás, já viu que dá pra rodar modelos de 27B no celular?). Sem doutorado em CUDA, sem 8 GPUs A100, sem fatura de US$ 10 mil por mês na AWS.

Pra quem está construindo produtos hoje, a dica é clara: aprenda o ecossistema ggml. Não importa se você trabalha com texto, voz, imagem ou vídeo. O runtime é o mesmo, os padrões são os mesmos, e a curva de aprendizado de um se transfere pros outros. Quem dominar isso vai ter uma vantagem absurda nos próximos anos.

A pergunta não é mais “preciso de cloud pra rodar IA?”. É “por que eu ainda estou pagando API se posso rodar tudo aqui?”.

O repositório está no GitHub sob licença MIT: handy-computer/transcribe.cpp. Se você trabalha com áudio, fala, ou acessibilidade, vale muito a pena dar uma olhada.

—

Fonte de inspiração: transcribe.cpp no Hacker News e anúncio oficial no blog da Mozilla AI