CrispStrobe/CrispASR

C++ ggml runtime hub for multilingual ASR and TTS models: Cohere Transcribe, Parakeet TDT, Voxtral, Canary 1B v2, etc, plus universal forced alignment, and more

What it solves

CrispASR provides a unified, high-performance C++ engine for Automatic Speech Recognition (ASR) and Text-to-Speech (TTS). It eliminates the need for complex Python environments, PyTorch, or multiple separate binaries for different models, allowing users to run dozens of state-of-the-art open-weights speech models in a single, portable executable.

How it works

Built as an extension of whisper.cpp, CrispASR uses ggml C++ runtimes to execute a vast array of ASR and TTS architectures. It supports a wide range of backends (including OpenAI Whisper, NVIDIA Parakeet, and Mistral Voxtral) and can auto-detect the required backend from GGUF model files. The engine is highly portable, compiling to WebAssembly for client-side browser execution and offering bindings for multiple languages including Python, Rust, Dart, and Go.

Who it’s for

It is designed for developers and users who need efficient, offline speech-to-text and text-to-speech capabilities without the overhead of Python dependencies. It is particularly useful for those building cross-platform applications (like the companion Flutter app CrisperWeaver) or deploying speech services via HTTP API.

Highlights

  • Massive Model Support: Includes 54 ASR backends and 52 TTS engines in one binary.
  • Zero Python Dependencies: Runs as a standalone C++ binary, removing the need for pip install or PyTorch.
  • High Portability: Supports Windows, macOS, Linux, and WebAssembly for browser-based usage.
  • Flexible Deployment: Offers a CLI, an integrated HTTP server, and language bindings for various programming environments.
  • Hardware Acceleration: Built-in support for CUDA, HIP, Vulkan, and Metal GPU acceleration.

Related

  • Project
    handy-computer/transcribe.cpp

    transcribe.cpp is a native C/C++ library for fast speech‑to‑text inference. It runs dozens of modern STT models (Parakeet, Whisper, Qwen3‑ASR, Voxtral, etc.) using the GGUF format on ggml, with Metal, Vulkan, CUDA, ROCm, or a tinyBLAS‑accelerated CPU backend. The repo provides a CLI, a quantization tool, and official Python, TypeScript, Rust, and Swift bindings, all under an MIT license.

  • Project
    openai/whisper

    Whisper is OpenAI’s open‑source, transformer‑based speech‑to‑text system that handles transcription, language identification, and translation across many languages. It ships as a pip‑installable package with six model sizes (tiny → large, plus a fast “turbo” variant). The CLI (`whisper …`) and a simple Python API (`whisper.load_model(...).transcribe(...)`) let you turn audio files into text with just a few commands. The project runs on Python 3.8‑3.11, PyTorch, and requires ffmpeg (and optionally Rust for the tokenizer). All code and model weights are MIT‑licensed.

  • Project
    ggml-org/whisper.cpp

    A high-performance C/C++ port of OpenAI's Whisper model for efficient, offline, on-device automatic speech recognition across multiple platforms.

  • Project
    ahmetoner/whisper-asr-webservice

    A general-purpose speech recognition toolkit that wraps Whisper models into a REST API for easy deployment and integration.

  • Project
    collabora/WhisperLive

    WhisperLive is an open‑source, near‑real‑time transcription server built around OpenAI’s Whisper model. It supports multiple inference back‑ends (faster‑whisper, NVIDIA TensorRT, Intel OpenVINO, AMD ROCm), offers word‑level timestamps, hot‑word boosting, speaker diarization and optional translation, and provides both simple command‑line clients and a Python streaming API. Docker images are provided for GPU and CPU deployments, and browser/iOS extensions let you transcribe audio directly from a web page or mobile device.