AIBit-Descubre proyectos de código abierto AIBit-Descubre proyectos de código abierto

CrispASR: Un solo binario C++ para 53 modelos ASR y 51 modelos TTS

CrispASR es un motor de voz unificado en C++ construido sobre ggml, compatible con 53 modelos ASR y 51 modelos TTS sin dependencias de Python. Ejecuta Cohere Transcribe, Parakeet, Voxtral, Qwen3 y más desde una única CLI.

¿Qué es CrispASR?

CrispASR es un motor de voz en C++ que comenzó como un fork de whisper.cpp y evolucionó hasta convertirse en algo mucho más grande. Es un centro de ejecución unificado para 53 backends de reconocimiento automático del habla (ASR) y 51 motores de texto a voz (TTS), todos funcionando sobre la biblioteca de tensores ggml. La idea central es simple: un solo binario, una CLI consistente y cero dependencias de Python en tiempo de ejecución.

# Transcribe con cualquier 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       # Descarga automática

# Texto a voz
crispasr --backend kokoro -m auto --tts "Hola mundo" --tts-output out.wav

Sin Python, sin PyTorch, sin binarios separados por modelo. Solo un binario C++ y un archivo GGUF.

Por qué esto es importante

La mayoría de las herramientas de IA de voz están fragmentadas. Necesitas una biblioteca para Whisper, otra para Parakeet, un entorno Python para Cohere Transcribe y otra configuración para TTS. CrispASR elimina esto proporcionando una interfaz única y consistente para docenas de modelos. También se compila a WebAssembly (4.3 MB), se ejecuta completamente del lado del cliente en el navegador y admite inferencia multihilo con cabeceras COOP/COEP.

Backends compatibles

ASR (53 backends)

La lista de backends ASR es extensa. Aquí están los más destacados:

Backend Modelo Arquitectura Idiomas
whisper Todas las variantes de OpenAI Whisper Transformer codificador-decodificador 99
parakeet NVIDIA Parakeet TDT 0.6b/1.1b FastConformer + TDT 25 UE
canary NVIDIA Canary 1B v2 FastConformer + decodificador Transformer 25 UE
cohere Cohere Transcribe 03-2026 Conformer + Transformer 13
voxtral Mistral Voxtral Mini 3B/4B Codificador Whisper + Mistral LLM 8/13
qwen3 Qwen3-ASR 0.6B/1.7B Codificador Whisper + Qwen3 LLM 30 + 22 dialectos chinos
granite IBM Granite Speech 3.2/3.3/4.0 Conformer + Q-Former + Granite LLM 6
wav2vec2 Cualquier modelo Wav2Vec2ForCTC CNN + Transformer + CTC Por modelo
omniasr OmniASR CTC 1B/300M wav2vec2 CNN + Transformer + CTC 1600+
sensevoice FunAudioLLM SenseVoiceSmall Codificador SANM + CTC 50+
gigaam ai-sage/GigaAM-v3 Conformer rotatorio + CTC/RNN-T Ruso

TTS (51 motores)

Los backends TTS incluyen Kokoro, Qwen3-TTS, VibeVoice, Orpheus, Chatterbox, IndexTTS, CosyVoice3, CSM, Dia, Zonos, Bark, Piper, MeloTTS y más. Muchos admiten clonación de voz mediante audio de referencia.

Primeros pasos

Compilar desde el código fuente

git clone --recursive https://github.com/CrispStrobe/CrispASR
cd CrispASR
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j$(nproc)

Para aceleración por 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-proveedor

Ejemplos rápidos de ASR

Whisper:

./models/download-ggml-model.sh base.en
./build/bin/crispasr -m models/ggml-base.en.bin -f samples/jfk.wav

Parakeet (multilingüe, rápido):

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 con descarga automática):

./build/bin/crispasr --backend voxtral -m auto -f samples/jfk.wav

Qwen3-ASR (30 idiomas + dialectos chinos):

./build/bin/crispasr --backend qwen3 -m auto -f audio.zh.wav

Texto a voz

# VibeVoice (descarga automática ~636 MB)
crispasr --backend vibevoice-tts -m auto --tts "Hola mundo" --tts-output hello.wav

# CosyVoice3 en GPU
crispasr --backend cosyvoice3-tts -m auto --tts "Hola mundo" --tts-output cosy.wav

Características clave

Streaming y transcripción en vivo

CrispASR admite streaming desde entrada de micrófono, fragmentación por ventana deslizante y salida de confianza por token. Usa los flags --stream, --mic o --live.

Modo servidor HTTP

Ejecuta un servidor HTTP persistente con una API compatible con OpenAI:

crispasr --server -m model.gguf --port 8080
curl -F "[email protected]" http://localhost:8080/v1/audio/transcriptions

Alineación forzada

CrispASR incluye una función universal de alineación forzada que funciona en todos los backends. Puedes alinear texto con audio sin ejecutar ASR:

crispasr -m parakeet.gguf -f audio.wav --align-only -t transcript.txt

Detección de actividad de voz (VAD)

Hay cuatro backends VAD disponibles: Silero (predeterminado, ~885 KB), FireRedVAD (recomendado), MarbleNet (439 KB) y Whisper-VAD-EncDec (experimental).

Identificación de idioma

Para backends sin detección nativa de idioma, CrispASR admite -l auto con múltiples proveedores LID: Whisper (predeterminado, 99 idiomas), Silero (95 idiomas), ECAPA-TDNN (recomendado, 107 idiomas) y FireRedLID (120 idiomas).

Postprocesamiento

CrispASR incluye restauración de puntuación (FireRedPunc, fullstop-punc, punctuate-all), corrección de mayúsculas (estadístico, CRF, BiLSTM) e identificación de idioma de texto (CLD3, GlotLID-V3, LID-176).

Consideraciones de rendimiento

  • Backends Audio-LLM (qwen3, voxtral, granite) ejecutan pilas completas de decodificador Transformer y son más lentos en CPU. Prefiere moonshine (16× RT), fc-ctc (10× RT), parakeet (2.9× RT) o whisper para hardware solo con CPU.
  • Cuantifica modelos a Q4_K o Q5_K para reducir memoria y cómputo.
  • Usa --flush-after 1 para ver resultados progresivamente en lugar de esperar el archivo completo.

Arquitectura

CrispASR está estructurado como una C-ABI estable en src/ consumida por todos los wrappers de lenguaje (Python, Rust, Dart, Go, Java, JavaScript, Ruby). Los tiempos de ejecución por modelo residen en src/{whisper,parakeet,canary,...}.cpp, compartiendo primitivas de src/core/ (mel, FFN, atención, cargador GGUF, bloques FastConformer).

Ecosistema

CrispASR es parte de un ecosistema más grande:

  • CrisperWeaver — Aplicación de transcripción Flutter multiplataforma construida sobre CrispASR
  • CrispEmbed — Motor de incrustación de texto con la misma filosofía
  • Susurrus — GUI de ASR en Python con 9 backends

Conclusión

CrispASR es un proyecto notable que unifica el panorama fragmentado de los modelos de IA de voz en un único binario C++ bien diseñado. Con 53 backends ASR, 51 motores TTS, alineación forzada universal y cero dependencias de Python, es una herramienta poderosa para desarrolladores que construyen aplicaciones de voz. El proyecto tiene licencia MIT y se mantiene activamente con 75 versiones y 490 estrellas en GitHub.

Fuente

CrispStrobe/CrispASR: Centro de ejecución ggml en C++ para modelos ASR y TTS multilingües: Cohere Transcribe, Parakeet TDT, Voxtral, Canary 1B v2, etc., además de alineación forzada universal y más