# ASR Engines Supported by VoiceStudio: Complete Registry Guide

> Discover the 10 ASR engines supported by VoiceStudio, including WhisperX, Faster-Whisper, NVIDIA NeMo, and more. Explore the complete registry guide now.

- Repository: [Palash Debnath/VoiceStudio](https://github.com/debpalash/VoiceStudio)
- Tags: api-reference
- Published: 2026-09-10

---

**VoiceStudio supports 10 distinct ASR engines including WhisperX (default), Faster-Whisper, MLX Whisper, PyTorch Whisper, NVIDIA NeMo Parakeet, Moonshine, FunASR, sherpa-onnx, and OpenAI-compatible endpoints.**

VoiceStudio is an open-source audio processing platform that abstracts multiple Automatic Speech Recognition backends behind a unified interface. Understanding which ASR engines are supported by VoiceStudio enables developers to select optimal implementations for offline transcription, hardware-accelerated inference, or low-latency live dictation.

## Complete List of ASR Engines Supported by VoiceStudio

The canonical registry resides in [`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml) (lines 64-86), which serves as the source of truth for documentation and UI generation. At runtime, these engines are discovered via the `_REGISTRY` dictionary in [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py).

VoiceStudio supports the following engine IDs:

- **`whisperx`** — **WhisperX** (default): The primary offline ASR engine used for standard speech-to-text tasks.
- **`faster-whisper`** — **Faster-Whisper**: An optimized Whisper variant engineered for faster inference speeds.
- **`mlx-whisper`** — **MLX Whisper**: Implementation utilizing Apple's MLX framework for hardware acceleration on Apple Silicon.
- **`pytorch-whisper`** — **PyTorch Whisper**: The standard PyTorch-based Whisper model implementation.
- **`nemo-parakeet`** — **Parakeet TDT**: NVIDIA NeMo-based ASR delivering high-accuracy transcription.
- **`parakeet-mlx`** — **Parakeet TDT v3 (MLX)**: MLX-accelerated variant of the Parakeet model for Apple hardware.
- **`moonshine`** — **Moonshine**: Lightweight ASR model designed for resource-constrained environments.
- **`funasr`** — **FunASR**: Open-source ASR with integrated speaker diarization support.
- **`sherpa-onnx-asr`** — **sherpa-onnx**: ONNX-based engine specifically optimized for low-latency live dictation.
- **`openai-compat-asr`** — **OpenAI-compatible**: Connector for external OpenAI-compatible ASR services requiring user configuration.

Each engine ID maps to a concrete implementation class conforming to the `ASRBackend` interface, allowing the frontend to present a single unified "ASR" model entry regardless of the underlying provider.

## ASR Engine Registration Architecture

VoiceStudio implements a registry pattern to manage its supported ASR engines. The [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py) file defines a `_REGISTRY` dictionary that maps string identifiers to backend classes.

During initialization, the application reads the `asr_engines` section from [`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml) to populate the user interface. This manifest-based approach decouples feature documentation from implementation code. The `ASRBackend` abstract interface standardizes initialization, inference, and device management methods across all implementations, ensuring consistent behavior whether using local WhisperX or remote OpenAI-compatible endpoints.

The UI localization strings in [`frontend/src/i18n/locales/en.json`](https://github.com/debpalash/VoiceStudio/blob/main/frontend/src/i18n/locales/en.json) define `"role_asr": "ASR"` for the model panel, while [`backend/services/model_lifecycle.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/model_lifecycle.py) adds specific entries like "WhisperX ASR" to the loaded-models panel with device and checkpoint information.

## Accessing ASR Engines Programmatically

Developers can query available engines and initialize specific backends at runtime using the public API exposed in [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py).

List all supported engine IDs:

```python
from backend.services import asr_backend

# The registry maps engine_id to BackendClass

available_asr_ids = list(asr_backend._REGISTRY.keys())
print("Supported ASR engines:", available_asr_ids)

```

Initialize a specific backend:

```python
from backend.services import asr_backend

engine_id = "funasr"
BackendClass = asr_backend._REGISTRY[engine_id]
backend = BackendClass()

print(f"Initialized {engine_id}")

```

Refer to the `ASRBackend` class definition for specific public methods regarding model loading and transcription.

## Summary

VoiceStudio provides comprehensive ASR integration through its registry-based architecture:

- **Ten supported engines** ranging from local Whisper variants to remote OpenAI-compatible endpoints
- **Manifest-driven configuration** maintained in [`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml) (lines 64-86)
- **Runtime discovery** via `_REGISTRY` in [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py)
- **Unified abstraction** through the `ASRBackend` interface contract
- **Hardware-specific optimizations** including MLX support for Apple Silicon and ONNX for low-latency dictation

## Frequently Asked Questions

### What is the default ASR engine in VoiceStudio?

**WhisperX** (`whisperx`) serves as the default offline ASR engine, automatically selected for standard speech-to-text tasks according to the feature manifest in [`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml).

### How does VoiceStudio switch between ASR engines?

The UI model selection panel reads from the `_REGISTRY` dictionary in [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py). Each engine appears as a unified "ASR" entry in the interface, with the specific implementation class instantiated based on the selected engine ID.

### Can VoiceStudio connect to external ASR services?

Yes. The `openai-compat-asr` engine ID enables connections to external OpenAI-compatible ASR endpoints. Configure your server URL and authentication details in the application settings to route transcription requests remotely.

### Which ASR engine is recommended for live dictation?

Use **sherpa-onnx** (`sherpa-onnx-asr`). This ONNX-based engine is specifically optimized for low-latency live dictation scenarios, providing significantly faster response times than offline-focused alternatives like standard WhisperX.