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

> Discover 11 ASR engines for live dictation in VoiceStudio. Explore the complete 2025 guide to find the best speech recognition solution for your needs and integrate seamlessly.

- Repository: [Palash Debnath/VoiceStudio](https://github.com/debpalash/VoiceStudio)
- Tags: how-to-guide
- Published: 2026-09-05

---

**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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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:

```python

# 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`](https://github.com/debpalash/VoiceStudio/blob/main/services/engines/mlx_whisper.py) and [`services/engines/parakeet_mlx.py`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/services/engines/mlx_whisper.py) and [`services/engines/parakeet_mlx.py`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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`](https://github.com/debpalash/VoiceStudio/blob/main/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.