CrispASR: One C++ Binary for 53 ASR and 51 TTS Models
CrispASR is a unified C++ speech engine built on ggml, supporting 53 ASR and 51 TTS models with zero Python dependencies. Run Cohere Transcribe, Parakeet, Voxtral, Qwen3, and more from a single CLI.
What Is CrispASR?
CrispASR is a C++ speech engine that started as a fork of whisper.cpp and evolved into something much larger. It's a unified runtime hub for 53 automatic speech recognition (ASR) backends and 51 text-to-speech (TTS) engines, all running on the ggml tensor library. The core idea is simple: one binary, one consistent CLI, and zero Python dependencies at runtime.
# Transcribe with any backend
crispasr -m ggml-base.en.bin -f samples/jfk.wav # OpenAI Whisper
crispasr -m parakeet-tdt-0.6b.gguf -f samples/jfk.wav # NVIDIA Parakeet
crispasr -m canary-1b-v2.gguf -f samples/jfk.wav # NVIDIA Canary
crispasr -m voxtral-mini-3b-2507.gguf -f samples/jfk.wav # Mistral Voxtral
crispasr --backend qwen3 -m auto -f samples/jfk.wav # Auto-download
# Text-to-speech
crispasr --backend kokoro -m auto --tts "Hello world" --tts-output out.wav
No Python, no PyTorch, no separate per-model binary. Just a C++ binary and a GGUF file.
Why This Matters
Most speech AI tooling is fragmented. You need one library for Whisper, another for Parakeet, a Python environment for Cohere Transcribe, and yet another setup for TTS. CrispASR eliminates this by providing a single, consistent interface to dozens of models. It also compiles to WebAssembly (4.3 MB), runs entirely client-side in the browser, and supports multithreaded inference with COOP/COEP headers.
Supported Backends
ASR (53 Backends)
The ASR backend list is extensive. Here are the highlights:
| Backend | Model | Architecture | Languages |
|---|---|---|---|
| whisper | All OpenAI Whisper variants | Encoder-decoder transformer | 99 |
| parakeet | NVIDIA Parakeet TDT 0.6b/1.1b | FastConformer + TDT | 25 EU |
| canary | NVIDIA Canary 1B v2 | FastConformer + Transformer decoder | 25 EU |
| cohere | Cohere Transcribe 03-2026 | Conformer + Transformer | 13 |
| voxtral | Mistral Voxtral Mini 3B/4B | Whisper encoder + Mistral LLM | 8/13 |
| qwen3 | Qwen3-ASR 0.6B/1.7B | Whisper encoder + Qwen3 LLM | 30 + 22 Chinese dialects |
| granite | IBM Granite Speech 3.2/3.3/4.0 | Conformer + Q-Former + Granite LLM | 6 |
| wav2vec2 | Any Wav2Vec2ForCTC model | CNN + Transformer + CTC | Per-model |
| omniasr | OmniASR CTC 1B/300M | wav2vec2 CNN + Transformer + CTC | 1600+ |
| sensevoice | FunAudioLLM SenseVoiceSmall | SANM encoder + CTC | 50+ |
| gigaam | ai-sage/GigaAM-v3 | Rotary Conformer + CTC/RNN-T | Russian |
TTS (51 Engines)
TTS backends include Kokoro, Qwen3-TTS, VibeVoice, Orpheus, Chatterbox, IndexTTS, CosyVoice3, CSM, Dia, Zonos, Bark, Piper, MeloTTS, and more. Many support voice cloning via reference audio.
Getting Started
Build from Source
git clone --recursive https://github.com/CrispStrobe/CrispASR
cd CrispASR
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j$(nproc)
For GPU acceleration:
cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=ON # NVIDIA
cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_METAL=ON # Apple Silicon
cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_VULKAN=ON # Cross-vendor
Quick ASR Examples
Whisper:
./models/download-ggml-model.sh base.en
./build/bin/crispasr -m models/ggml-base.en.bin -f samples/jfk.wav
Parakeet (multilingual, fast):
curl -L -o parakeet.gguf https://huggingface.co/cstr/parakeet-tdt-0.6b-v3-GGUF/resolve/main/parakeet-tdt-0.6b-v3-q4_k.gguf
./build/bin/crispasr -m parakeet.gguf -f samples/jfk.wav
Voxtral (speech-LLM with auto-download):
./build/bin/crispasr --backend voxtral -m auto -f samples/jfk.wav
Qwen3-ASR (30 languages + Chinese dialects):
./build/bin/crispasr --backend qwen3 -m auto -f audio.zh.wav
Text-to-Speech
# VibeVoice (auto-downloads ~636 MB)
crispasr --backend vibevoice-tts -m auto --tts "Hello world" --tts-output hello.wav
# CosyVoice3 on GPU
crispasr --backend cosyvoice3-tts -m auto --tts "Hello world" --tts-output cosy.wav
Key Features
Streaming & Live Transcription
CrispASR supports streaming from microphone input, sliding-window chunking, and per-token confidence output. Use --stream, --mic, or --live flags.
HTTP Server Mode
Run a persistent HTTP server with an OpenAI-compatible API:
crispasr --server -m model.gguf --port 8080
curl -F "[email protected]" http://localhost:8080/v1/audio/transcriptions
Forced Alignment
CrispASR includes a universal forced alignment feature that works across all backends. You can align text to audio without running ASR:
crispasr -m parakeet.gguf -f audio.wav --align-only -t transcript.txt
Voice Activity Detection (VAD)
Four VAD backends are available: Silero (default, ~885 KB), FireRedVAD (recommended), MarbleNet (439 KB), and Whisper-VAD-EncDec (experimental).
Language Identification
For backends without native language detection, CrispASR supports -l auto with multiple LID providers: Whisper (default, 99 languages), Silero (95 languages), ECAPA-TDNN (recommended, 107 languages), and FireRedLID (120 languages).
Post-Processing
CrispASR includes punctuation restoration (FireRedPunc, fullstop-punc, punctuate-all), truecasing (statistical, CRF, BiLSTM), and text language identification (CLD3, GlotLID-V3, LID-176).
Performance Considerations
- Audio-LLM backends (qwen3, voxtral, granite) run full transformer decoder stacks and are slower on CPU. Prefer moonshine (16× RT), fc-ctc (10× RT), parakeet (2.9× RT), or whisper for CPU-only hardware.
- Quantize models to Q4_K or Q5_K to reduce memory and compute.
- Use
--flush-after 1to see results progressively instead of waiting for the entire file.
Architecture
CrispASR is structured as a stable C-ABI in src/ consumed by all language wrappers (Python, Rust, Dart, Go, Java, JavaScript, Ruby). Per-model runtimes live in src/{whisper,parakeet,canary,...}.cpp, sharing primitives from src/core/ (mel, FFN, attention, GGUF loader, FastConformer blocks).
Ecosystem
CrispASR is part of a larger ecosystem:
- CrisperWeaver — Cross-platform Flutter transcription app built on CrispASR
- CrispEmbed — Text embedding engine with the same philosophy
- Susurrus — Python ASR GUI with 9 backends
Conclusion
CrispASR is a remarkable project that unifies the fragmented landscape of speech AI models into a single, well-engineered C++ binary. With 53 ASR backends, 51 TTS engines, universal forced alignment, and zero Python dependencies, it's a powerful tool for developers building speech applications. The project is MIT-licensed and actively maintained with 75 releases and 490 stars on GitHub.