# Which ASR Engines Are Supported by VoiceStudio? Complete List and Registry Guide

> Discover the ten ASR engines supported by VoiceStudio including WhisperX NeMo and more. Explore the complete list and registry guide for seamless integration.

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

---

**VoiceStudio supports ten distinct ASR engines including WhisperX (default), Faster-Whisper, MLX Whisper, NVIDIA NeMo Parakeet, Moonshine, FunASR, sherpa-onnx, and OpenAI-compatible servers, all registered in [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py) and enumerated in [`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml).**

VoiceStudio is an open-source audio processing framework that unifies multiple Automatic Speech Recognition (ASR) backends through a pluggable registry architecture. Understanding which ASR engines are supported by VoiceStudio enables developers to optimize transcription pipelines for specific hardware constraints and latency requirements. The project maintains a canonical list of supported engines in its feature manifest while implementing runtime discovery via the backend registry pattern.

## Complete List of Supported ASR Engines

VoiceStudio provides ten distinct ASR implementations, each registered in the `asr_engines` section of [`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml) (lines 64-86) and mapped to concrete classes in the runtime registry. These engines range from optimized local models to external service bridges:

- **`whisperx`** – **WhisperX**: The default offline ASR engine serving as the primary speech-to-text backend for most transcription tasks.
- **`faster-whisper`** – **Faster-Whisper**: A performance-optimized Whisper variant delivering faster inference speeds with reduced memory footprint.
- **`mlx-whisper`** – **MLX Whisper**: A Whisper implementation leveraging Apple's MLX framework for hardware acceleration on macOS devices.
- **`pytorch-whisper`** – **PyTorch Whisper**: The standard PyTorch-based Whisper implementation providing broad compatibility across platforms.
- **`nemo-parakeet`** – **Parakeet TDT**: NVIDIA's NeMo-based ASR model optimized for GPU-accelerated transcription workflows.
- **`parakeet-mlx`** – **Parakeet TDT v3 (MLX)**: An Apple Silicon-optimized variant of the Parakeet model using MLX acceleration.
- **`moonshine`** – **Moonshine**: A lightweight ASR architecture designed for resource-constrained environments and edge deployment.
- **`funasr`** – **FunASR**: An open-source engine featuring integrated speaker diarization capabilities for multi-speaker audio.
- **`sherpa-onnx-asr`** – **sherpa-onnx**: An ONNX-based runtime engine optimized for low-latency live dictation scenarios.
- **`openai-compat-asr`** – **OpenAI-compatible**: A bridge engine enabling connection to external OpenAI-compatible transcription endpoints via user configuration.

## ASR Backend Architecture and Registry System

The underlying architecture relies on the `_REGISTRY` dictionary defined in [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py). This registry maps string engine IDs to concrete classes implementing the `ASRBackend` interface, enabling polymorphic transcription behavior across disparate implementations.

When VoiceStudio initializes, the system discovers available engines by inspecting `_REGISTRY`, allowing the frontend—referencing `"role_asr": "ASR"` in [`frontend/src/i18n/locales/en.json`](https://github.com/debpalash/VoiceStudio/blob/main/frontend/src/i18n/locales/en.json)—to present a unified model selection panel. The [`model_lifecycle.py`](https://github.com/debpalash/VoiceStudio/blob/main/model_lifecycle.py) file subsequently manages the active ASR instance, displaying device allocation and checkpoint information in the loaded-models panel.

## Accessing ASR Engines Programmatically

Developers can interact directly with the registry to enumerate or instantiate specific backends. The following examples demonstrate runtime interaction with the `asr_backend` module.

To retrieve all available ASR engine identifiers:

```python
from backend.services import asr_backend

# The registry maps engine_id to BackendClass implementations

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

```

To instantiate and activate a specific engine such as FunASR:

```python
from backend.services import asr_backend

engine_id = "funasr"
backend = asr_backend._REGISTRY[engine_id]()
asr_backend.set_active_backend(backend)  # hypothetical API

print(f"Activated ASR engine: {engine_id}")

```

## Key Files Managing ASR Support

Several critical files coordinate the definition, implementation, and presentation of ASR capabilities:

- **[`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml)** – Contains the canonical `asr_engines` enumeration (lines 64-86), serving as the source of truth for documentation and feature validation.
- **[`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py)** – Implements the `_REGISTRY` dictionary, defines the `ASRBackend` interface contract, and provides runtime backend selection logic.
- **[`frontend/src/i18n/locales/en.json`](https://github.com/debpalash/VoiceStudio/blob/main/frontend/src/i18n/locales/en.json)** – Stores UI localization strings including the `"role_asr"` label used in the model management interface.
- **[`backend/services/model_lifecycle.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/model_lifecycle.py)** – Integrates the active ASR engine into the application's model panel, tracking device placement and loading status.

## Summary

- VoiceStudio supports **ten ASR engines**, from WhisperX variants to specialized implementations like sherpa-onnx and Moonshine.
- Engine discovery occurs through the `_REGISTRY` dictionary in [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py), implementing the `ASRBackend` interface pattern.
- The canonical engine list resides in [`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml) (lines 64-86), ensuring documentation consistency.
- **WhisperX** operates as the default engine, while **sherpa-onnx** provides optimized low-latency dictation.
- External ASR services integrate via the `openai-compat-asr` engine with configurable endpoints.

## Frequently Asked Questions

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

**WhisperX** is designated as the default ASR engine in [`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml), serving as the primary offline transcription backend for standard speech-to-text operations. The [`model_lifecycle.py`](https://github.com/debpalash/VoiceStudio/blob/main/model_lifecycle.py) file references this engine when displaying active model information in the UI panel.

### Which ASR engine should I use for live dictation?

The **`sherpa-onnx-asr`** engine is specifically implemented for low-latency live dictation using the ONNX runtime. This configuration minimizes inference delay, making it optimal for real-time transcription scenarios requiring immediate text output.

### Can I connect VoiceStudio to external ASR providers?

Yes, VoiceStudio supports external ASR services through the **`openai-compat-asr`** engine, which acts as a client for OpenAI-compatible transcription endpoints. This integration requires manual configuration of the server URL and authentication credentials in your VoiceStudio environment.

### Where are supported ASR engines defined in the source code?

The authoritative list exists in [`docs/features.yaml`](https://github.com/debpalash/VoiceStudio/blob/main/docs/features.yaml) (lines 64-86), while the runtime implementation mapping resides in [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py) within the `_REGISTRY` dictionary. This separation ensures that documentation remains synchronized with the actual code implementation.