ASR Engines Available for Live Dictation in VoiceStudio: The Complete 2025 Guide

VoiceStudio ships with 11 automatic speech recognition (ASR) engines for live dictation, managed through a registry-based plugin architecture centered in services/asr_backend.py and accessible via the Dictation Widget.

VoiceStudio is an open-source dictation toolkit that provides modular ASR engines available for live dictation through a centralized backend system. The repository implements a plugin architecture where each speech recognition model registers itself via the engine acceptance API, allowing users to select optimal ASR backends based on hardware constraints and latency requirements.

Complete List of ASR Engines in VoiceStudio

VoiceStudio distributes 11 distinct ASR backends as plugin modules under services/engines/. Each implementation registers through the central dispatcher in services/asr_backend.py and is selectable from the Model Catalogue UI or via the Ctrl/Cmd + E hotkey.

The available engines include:

• MLX Whisper — Low-latency transcription optimized for Apple Silicon (M1-M4) using the MLX framework. Implementation resides in services/engines/mlx_whisper.py.

• Parakeet MLX — High-speed on-device inference specifically tuned for Apple Silicon Macs. Found in services/engines/parakeet_mlx.py.

• WhisperX — Full-featured backend supporting word-level timestamps and speaker diarization, requiring NVIDIA CUDA GPUs. Located in services/engines/whisperx.py.

• Moonshine — Integer-quantized (int8) model optimized for CPU-only environments with minimal VRAM requirements.

• Faster-Whisper — Optimized int8 implementation supporting both CPU and GPU streaming with enhanced speed over standard Whisper variants.

• Sherpa-ONNX — Lightweight ONNX runtime backend ideal for low-VRAM devices and edge deployment. Source in services/engines/sherpa_onnx.py.

• Silero — Streamlined lightweight model designed specifically for real-time dictation scenarios with minimal resource overhead.

• Vosk — Offline-capable recognizer requiring no internet connectivity with robust multilingual support.

• DeepSpeech — Mozilla's legacy engine providing CPU-friendly inference for older hardware compatibility.

• OpenAI-Whisper (CPU mode) — Original PyTorch implementation offering high accuracy when GPU acceleration is unavailable.

• Custom ASR — User-extensible backend accepting any HuggingFace-compatible transformer pipeline through the engine registry interface described in docs/engine-acceptance.md.

How the Dictation Widget Integrates ASR Engines

The Dictation Widget interacts with ASR engines available for live dictation through a three-phase initialization process defined in services/asr_backend.py.

When a user initiates dictation, the system executes:

1. Backend Resolution — The widget calls load_active_asr_backend() to instantiate the selected engine from the Model Catalogue registry.

2. Audio Streaming — Real-time audio buffers enter the backend's transcribe() method, which processes chunks incrementally.

3. Output Generation — The method returns transcription text with optional word_timestamps metadata for advanced formatting and diarization.

The central dispatcher exposes run_transcribe_guarded(), which provides exception handling and resource cleanup around raw transcription calls:

# services/asr_backend.py

def run_transcribe_guarded(audio_stream, config):
    backend = load_active_asr_backend(config.engine_id)
    return backend.transcribe(
        audio_stream, 
        word_timestamps=config.timestamps_enabled
    )

Platform-Specific Engine Recommendations

Selecting the optimal ASR engine depends on your hardware profile and latency requirements.

Apple Silicon Optimization

For M1-M4 Macs, prioritize the MLX-based implementations in services/engines/mlx_whisper.py and services/engines/parakeet_mlx.py. These engines leverage Metal Performance Shaders (MPS) for GPU-accelerated inference without CUDA dependencies, delivering the lowest latency for live dictation on macOS.

NVIDIA GPU Workflows

Systems with CUDA-capable GPUs should default to WhisperX. This engine, implemented in services/engines/whisperx.py, supports speaker diarization and precise word-level timestamps unavailable in CPU-only alternatives, making it ideal for high-fidelity transcription workflows.

CPU and Low-VRAM Deployment

For resource-constrained environments, configure one of the quantized backends:

• Moonshine (int8 quantization)
• Faster-Whisper (int8 optimized)
• Sherpa-ONNX (ONNX runtime)

These engines maintain real-time performance without GPU acceleration, functioning efficiently on devices with limited VRAM or processing power.

Extending VoiceStudio with Custom ASR Engines

The registry-based architecture allows developers to implement new ASR engines available for live dictation without modifying core widget code.

To add a custom backend:

1. Create a Python module in services/engines/ implementing the required interface: load(), transcribe(), and optional word_timestamps().

2. Register the engine via the acceptance API specified in docs/engine-acceptance.md.

3. The Model Catalogue automatically detects compliant modules, exposing them in the UI alongside built-in options.

This extensibility enables integration of proprietary models or research ASR transformers while maintaining compatibility with the Dictation Widget's streaming interface.

Summary

• VoiceStudio provides 11 built-in ASR engines ranging from MLX-optimized Apple Silicon implementations to lightweight CPU models like Moonshine and Sherpa-ONNX.

• The Dictation Widget accesses these through services/asr_backend.py, specifically via load_active_asr_backend() and the protected execution wrapper run_transcribe_guarded().

• Platform optimization is critical: use MLX Whisper or Parakeet MLX for macOS, WhisperX for CUDA GPUs, and quantized engines (Moonshine, Faster-Whisper) for CPU-only inference.

• The registry-based plugin system documented in docs/engine-acceptance.md supports custom HuggingFace-compatible transformers without core code modifications.

• All engines expose a consistent transcribe() interface supporting real-time streaming and optional timestamp metadata for downstream processing.

Frequently Asked Questions

How many ASR engines are built into VoiceStudio?

VoiceStudio ships with 11 automatic speech recognition engines available for live dictation. This count includes MLX Whisper, Parakeet MLX, WhisperX, Moonshine, Faster-Whisper, Sherpa-ONNX, Silero, Vosk, DeepSpeech, OpenAI-Whisper CPU mode, and the Custom ASR extensibility layer.

Which ASR engine is best for Apple Silicon Macs?

MLX Whisper and Parakeet MLX deliver optimal performance on Apple Silicon (M1-M4) by leveraging the MLX framework and Metal Performance Shaders (MPS). These engines reside in services/engines/mlx_whisper.py and services/engines/parakeet_mlx.py respectively, offering significantly lower latency than CUDA-dependent alternatives on macOS hardware.

Can I add my own ASR engine to VoiceStudio?

Yes. VoiceStudio implements a registry-based plugin system defined in docs/engine-acceptance.md. Create a module in services/engines/ implementing the load(), transcribe(), and optional word_timestamps() interface methods, then register it through the engine acceptance API. The Dictation Widget automatically detects compliant backends and displays them in the Model Catalogue UI.

What file handles the ASR backend selection?

The central dispatcher is services/asr_backend.py. This module contains load_active_asr_backend(), which instantiates the user-selected engine from the Model Catalogue, and run_transcribe_guarded(), which manages the transcription lifecycle, error handling, and resource cleanup for the Dictation Widget.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}