⏱️ Lectura: 9 min
transcribe.cpp has just reached version 0.1.0 with support for 16 families of speech recognition models, more than 60 individual models, and GPU acceleration via Vulkan, Metal, CUDA, and TinyBLAS. The library, written in C/C++ on top of ggml, aims to become the direct replacement for whisper.cpp that the local transcription ecosystem has been needing.
📑 En este artículo
Behind the project is cjpais, author and maintainer of Handy, a cross-platform voice dictation app. transcribe.cpp was born from a very specific problem: distributing a reliable transcription engine on Windows, macOS, and Linux without depending on a patchwork of libraries with uncertain maintenance.
TL;DR
- transcribe.cpp launched as version 0.1.0 in April 2026, created by cjpais, author and maintainer of the Handy app.
- It supports 16 ASR model families and more than 60 individual models from the handy-computer organization on Hugging Face.
- It accelerates inference via Vulkan, Metal, CUDA, and TinyBLAS, with benchmarks published on a Ryzen 4750U and a Mac M4 Max.
- Each model goes through numerical validation and WER testing against the reference implementation before being published.
- It works as a direct replacement for whisper.cpp, including compatibility with existing .bin files.
- It offers officially maintained bindings in Python, JavaScript/TypeScript, Rust, and ObjC/Swift.
- It supports both streaming and batch transcription modes.
- It’s a v0.1.0 release: the author himself asks users to report the rough edges it still has.
Introduction to transcribe.cpp
The inference stack for local ASR (automatic speech recognition) is, in the author’s own words, complicated terrain. Until now, the real options were basically two: whisper.cpp and ONNX. Adding MLX for Apple devices means maintaining a third engine and porting models to each one separately.
ONNX allowed Handy to add model support quickly, but it left a lot of performance on the table, staying limited in several scenarios without a GPU. Other libraries claim to support many models, but with anonymous authors and no documented testing: it’s unclear whether they’re still maintained, whether they have real bindings, or whether they ever compared their output against the official reference.
transcribe.cpp aims to close that gap: a library with a single embeddable binary, that runs on GPU across the three major desktop platforms, and whose output is verified model by model.
What Happened with transcribe.cpp
The announcement was published in April 2026 on cjpais’s blog, alongside the library’s launch. transcribe.cpp is positioned as the inference engine behind the next version of Handy, which until now ran on whisper.cpp.
Version 0.1.0 already supports 16 ASR model families, more than 60 models in total, published under the handy-computer organization on Hugging Face. The author himself notes that some models are still missing and that, being a first release, there will be rough edges: he asks the community to report them so they can be fixed together.
Context and History
ggml is the C inference library that Georgi Gerganov popularized with llama.cpp and whisper.cpp: quantized tensors, no Python or PyTorch dependencies, designed to run on CPU and GPU with a lightweight binary. That same approach is what transcribe.cpp adopts to solve the distribution problem its author describes.
whisper.cpp has been the most popular entry point for running OpenAI’s Whisper models locally for years, which is why much of the ecosystem, including Handy, built its integrations around its .bin files. transcribe.cpp maintains compatibility with that format to avoid breaking existing installations, while adding support for model families whisper.cpp never covered.
The decision to build on ggml instead of maintaining a whisper.cpp fork or adopting ONNX responds directly to the experience of maintaining Handy: cjpais needed a single engine with a solid track record for cross-platform distribution, and ggml already had a mature community and tooling around it.
Technical Details and Performance
Acceleration support covers four backends: Vulkan, Metal, CUDA, and TinyBLAS. Each model published in the handy-computer organization comes with benchmarks run on two reference machines: a laptop with a Ryzen 4750U using CPU and Vulkan on Fedora, and a Mac with an M4 Max chip.
| Backend | Target Hardware | When to Use It | Limitation |
|---|---|---|---|
| Vulkan | AMD, Intel, or NVIDIA GPU | Linux and Windows without relying on proprietary CUDA | Performance varies by driver |
| Metal | Apple Silicon (M1 to M4) | macOS with Apple’s own chips | macOS-exclusive |
| CUDA | NVIDIA GPU | Servers or workstations with NVIDIA cards | Requires proprietary drivers and toolkit |
| TinyBLAS | CPU without a dedicated GPU | Machines without a compatible GPU, as a fallback | Slower than GPU paths |
The project’s central criterion is numerical validation: each model is mathematically compared against the reference implementation before being published, and it’s also run against WER (word error rate, the standard metric for measuring transcription errors) sweeps with thousands of test audio files. The results of those runs are published both in the transcribe.cpp repository and on each model’s page on Hugging Face.
flowchart TD
A["Audio file"] --> B["transcribe.cpp (ggml engine)"]
B --> C{"Available backend"}
C --> D["Vulkan, Metal, or CUDA"]
C --> E["TinyBLAS (CPU only)"]
B --> F["Bindings: Python, JS/TS, Rust, Swift"]
F --> G["Handy and other apps"]💭 Key point: validation isn’t just functional. Each model is compared number by number against the reference implementation before being published, not just tested to see if it produces readable text.
That double verification, numerical and WER, is the direct answer to the problem cjpais describes with the loose ONNX models circulating on Hugging Face: without that process, there’s no way to know whether a conversion to another format introduced silent errors into the output.
Getting Started with transcribe.cpp
The project’s official repository, linked in References, follows the same CMake build flow as the rest of the ggml ecosystem (llama.cpp, whisper.cpp). The steps are equivalent on Windows, macOS, and Linux; only the acceleration backend flag you enable changes.
# Linux / macOS, with Vulkan support
cd transcribe.cpp
cmake -B build -DGGML_VULKAN=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
./build/bin/transcribe -m modelo.bin -f audio.wav# Windows (PowerShell), with CUDA support
cd transcribe.cpp
cmake -B build -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release
.\build\bin\Release\transcribe.exe -m modelo.bin -f audio.wavThe resulting binary accepts a .bin model compatible with whisper.cpp or one of the verified handy-computer models, plus an audio file. To integrate it into an app instead of using the CLI, the official bindings expose the same functionality:
from transcribe_cpp import Transcriber
modelo = Transcriber.from_pretrained("handy-computer/whisper-large-v3-turbo-ggml")
resultado = modelo.transcribe("reunion.wav", language="es")
print(resultado.text)That snippet loads a model published by handy-computer and transcribes a Spanish-language audio file, returning the plain text. The same pattern repeats across the JavaScript/TypeScript, Rust, and ObjC/Swift bindings, with the signature adapted to each language.
⚠️ Heads up: being v0.1.0, transcribe.cpp doesn’t yet support some advanced flags that whisper.cpp has. For most use cases, the author considers it equivalent in performance, but check the list of supported flags before migrating a complex integration.
Impact and Analysis
For anyone distributing a desktop app with local transcription, the problem transcribe.cpp solves is real and well known: supporting Windows, macOS, and Linux with GPU acceleration currently forces a choice between whisper.cpp (fast but limited in models), ONNX (broad but weak on GPU), or maintaining two engines in parallel.
The bindings maintained by the team itself in Python, JavaScript/TypeScript, Rust, and ObjC/Swift are the other key piece. cjpais chose those four languages because, as he explains, they reasonably represent where this type of library ends up being used: scripts and notebooks in Python, web and desktop apps in JS/TS, backends and CLIs in Rust, and native Apple apps in Swift.
Handy’s backing gives the project something the alternative ASR libraries mentioned by the author himself don’t have: a maintainer with a direct incentive to keep sustaining the code, because his own application depends on it in production.
What’s Next
The immediate plan is to close out the list of ASR models still missing support. The announcement itself leaves the door open for the community to contribute additional bindings, as long as they take charge of maintaining that integration.
In the medium term, cjpais states that his intention is to sustain transcribe.cpp with the same continuity he maintains Handy with: he doesn’t frame it as a weekend experiment, but as the foundation for building accessible local transcription for more applications, not just his own.
📖 Summary on Telegram: View summary
Try it yourself: clone the transcribe.cpp repository linked in References and run your first audio file against a handy-computer model today.
Frequently Asked Questions
What is transcribe.cpp?
It’s a speech-to-text transcription library written in C/C++ on top of ggml, supporting more than 60 ASR models with GPU acceleration on Windows, macOS, and Linux.
Does it completely replace whisper.cpp?
It works as a direct replacement in most cases, including compatibility with existing .bin files, though it doesn’t yet cover some of whisper.cpp’s advanced flags since it’s a 0.1.0 release.
What acceleration backends does it support?
Vulkan, Metal, CUDA, and TinyBLAS, covering AMD, Intel, NVIDIA, and Apple Silicon GPUs, plus an optimized path for CPUs without a dedicated GPU.
What languages have official bindings?
Python, JavaScript/TypeScript, Rust, and ObjC/Swift, all maintained directly by the project team.
How is model accuracy validated?
Each model is numerically compared against the reference implementation and subjected to WER testing with thousands of audio files, with results published in the repository and on Hugging Face.
Who maintains the project?
cjpais, author and maintainer of Handy, the voice dictation app that motivated the creation of transcribe.cpp.
References
- Original source: cjpais’s announcement with the motivation, features, and roadmap of transcribe.cpp.
- Hugging Face: handy-computer: the organization where numerically verified ASR models are published.
- GitHub: whisper.cpp: the reference project with which transcribe.cpp maintains .bin file compatibility.
- GitHub: ggml: the C inference library transcribe.cpp is built on.
- Wikipedia: Word error rate: definition of the WER metric used to validate each model.
📱 Like this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
0 Comments