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

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 and enumerated in 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 (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. 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—to present a unified model selection panel. The 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:

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:

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 – 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 – Implements the _REGISTRY dictionary, defines the ASRBackend interface contract, and provides runtime backend selection logic.
• 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 – 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, implementing the ASRBackend interface pattern.
• The canonical engine list resides in 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, serving as the primary offline transcription backend for standard speech-to-text operations. The 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 (lines 64-86), while the runtime implementation mapping resides in backend/services/asr_backend.py within the _REGISTRY dictionary. This separation ensures that documentation remains synchronized with the actual code implementation.

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