CrispASR : Un binaire C++ pour 53 modèles ASR et 51 modèles TTS
CrispASR est un moteur vocal C++ unifié basé sur ggml, prenant en charge 53 modèles ASR et 51 modèles TTS sans dépendance Python. Exécutez Cohere Transcribe, Parakeet, Voxtral, Qwen3 et bien d'autres à partir d'une seule interface en ligne de commande.
Qu'est-ce que CrispASR ?
CrispASR est un moteur vocal en C++ qui a commencé comme un fork de whisper.cpp et a évolué pour devenir quelque chose de bien plus vaste. C'est un hub d'exécution unifié pour 53 moteurs de reconnaissance automatique de la parole (ASR) et 51 moteurs de synthèse vocale (TTS), tous fonctionnant sur la bibliothèque de tenseurs ggml. L'idée centrale est simple : un seul binaire, une interface en ligne de commande cohérente, et aucune dépendance Python lors de l'exécution.
# Transcrire avec n'importe quel moteur
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 # Téléchargement automatique
# Synthèse vocale
crispasr --backend kokoro -m auto --tts "Bonjour le monde" --tts-output out.wav
Pas de Python, pas de PyTorch, pas de binaire séparé par modèle. Juste un binaire C++ et un fichier GGUF.
Pourquoi c'est important
La plupart des outils d'IA vocale sont fragmentés. Vous avez besoin d'une bibliothèque pour Whisper, d'une autre pour Parakeet, d'un environnement Python pour Cohere Transcribe, et encore d'une autre configuration pour la TTS. CrispASR élimine cela en fournissant une interface unique et cohérente pour des dizaines de modèles. Il se compile également en WebAssembly (4,3 Mo), fonctionne entièrement côté client dans le navigateur et prend en charge l'inférence multithread avec les en-têtes COOP/COEP.
Moteurs pris en charge
ASR (53 moteurs)
La liste des moteurs ASR est exhaustive. Voici les points forts :
| Moteur | Modèle | Architecture | Langues |
|---|---|---|---|
| whisper | Toutes les variantes OpenAI Whisper | Transformateur encodeur-décodeur | 99 |
| parakeet | NVIDIA Parakeet TDT 0.6b/1.1b | FastConformer + TDT | 25 UE |
| canary | NVIDIA Canary 1B v2 | FastConformer + décodeur Transformateur | 25 UE |
| cohere | Cohere Transcribe 03-2026 | Conformer + Transformateur | 13 |
| voxtral | Mistral Voxtral Mini 3B/4B | Encodeur Whisper + LLM Mistral | 8/13 |
| qwen3 | Qwen3-ASR 0.6B/1.7B | Encodeur Whisper + LLM Qwen3 | 30 + 22 dialectes chinois |
| granite | IBM Granite Speech 3.2/3.3/4.0 | Conformer + Q-Former + LLM Granite | 6 |
| wav2vec2 | Tout modèle Wav2Vec2ForCTC | CNN + Transformateur + CTC | Par modèle |
| omniasr | OmniASR CTC 1B/300M | CNN wav2vec2 + Transformateur + CTC | 1600+ |
| sensevoice | FunAudioLLM SenseVoiceSmall | Encodeur SANM + CTC | 50+ |
| gigaam | ai-sage/GigaAM-v3 | Conformer rotatif + CTC/RNN-T | Russe |
TTS (51 moteurs)
Les moteurs TTS incluent Kokoro, Qwen3-TTS, VibeVoice, Orpheus, Chatterbox, IndexTTS, CosyVoice3, CSM, Dia, Zonos, Bark, Piper, MeloTTS, et bien d'autres. Beaucoup prennent en charge le clonage vocal via un audio de référence.
Pour commencer
Compiler à partir des sources
git clone --recursive https://github.com/CrispStrobe/CrispASR
cd CrispASR
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j$(nproc)
Pour l'accélération GPU :
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 # Multi-fournisseur
Exemples rapides d'ASR
Whisper :
./models/download-ggml-model.sh base.en
./build/bin/crispasr -m models/ggml-base.en.bin -f samples/jfk.wav
Parakeet (multilingue, rapide) :
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 (LLM vocal avec téléchargement automatique) :
./build/bin/crispasr --backend voxtral -m auto -f samples/jfk.wav
Qwen3-ASR (30 langues + dialectes chinois) :
./build/bin/crispasr --backend qwen3 -m auto -f audio.zh.wav
Synthèse vocale
# VibeVoice (téléchargement automatique ~636 Mo)
crispasr --backend vibevoice-tts -m auto --tts "Bonjour le monde" --tts-output hello.wav
# CosyVoice3 sur GPU
crispasr --backend cosyvoice3-tts -m auto --tts "Bonjour le monde" --tts-output cosy.wav
Fonctionnalités clés
Streaming et transcription en direct
CrispASR prend en charge le streaming à partir de l'entrée microphone, le découpage par fenêtre glissante et la sortie de confiance par jeton. Utilisez les drapeaux --stream, --mic ou --live.
Mode serveur HTTP
Exécutez un serveur HTTP persistant avec une API compatible OpenAI :
crispasr --server -m model.gguf --port 8080
curl -F "[email protected]" http://localhost:8080/v1/audio/transcriptions
Alignement forcé
CrispASR inclut une fonctionnalité d'alignement forcé universel qui fonctionne sur tous les moteurs. Vous pouvez aligner du texte sur de l'audio sans exécuter l'ASR :
crispasr -m parakeet.gguf -f audio.wav --align-only -t transcript.txt
Détection d'activité vocale (VAD)
Quatre moteurs VAD sont disponibles : Silero (par défaut, ~885 Ko), FireRedVAD (recommandé), MarbleNet (439 Ko) et Whisper-VAD-EncDec (expérimental).
Identification de la langue
Pour les moteurs sans détection de langue native, CrispASR prend en charge -l auto avec plusieurs fournisseurs LID : Whisper (par défaut, 99 langues), Silero (95 langues), ECAPA-TDNN (recommandé, 107 langues) et FireRedLID (120 langues).
Post-traitement
CrispASR inclut la restauration de la ponctuation (FireRedPunc, fullstop-punc, punctuate-all), la mise en majuscules (statistique, CRF, BiLSTM) et l'identification de la langue du texte (CLD3, GlotLID-V3, LID-176).
Considérations de performance
- Les moteurs Audio-LLM (qwen3, voxtral, granite) exécutent des piles complètes de décodeurs transformateurs et sont plus lents sur CPU. Préférez moonshine (16× RT), fc-ctc (10× RT), parakeet (2,9× RT) ou whisper pour du matériel uniquement CPU.
- Quantifiez les modèles en Q4_K ou Q5_K pour réduire la mémoire et le calcul.
- Utilisez
--flush-after 1pour voir les résultats progressivement au lieu d'attendre la fin du fichier.
Architecture
CrispASR est structuré comme une ABI C stable dans src/ consommée par tous les wrappers de langage (Python, Rust, Dart, Go, Java, JavaScript, Ruby). Les exécutions par modèle vivent dans src/{whisper,parakeet,canary,...}.cpp, partageant des primitives de src/core/ (mel, FFN, attention, chargeur GGUF, blocs FastConformer).
Écosystème
CrispASR fait partie d'un écosystème plus large :
- CrisperWeaver — Application de transcription Flutter multiplateforme basée sur CrispASR
- CrispEmbed — Moteur d'intégration de texte avec la même philosophie
- Susurrus — Interface graphique ASR Python avec 9 moteurs
Conclusion
CrispASR est un projet remarquable qui unifie le paysage fragmenté des modèles d'IA vocale en un seul binaire C++ bien conçu. Avec 53 moteurs ASR, 51 moteurs TTS, un alignement forcé universel et zéro dépendance Python, c'est un outil puissant pour les développeurs créant des applications vocales. Le projet est sous licence MIT et activement maintenu avec 75 versions et 490 étoiles sur GitHub.