# How to Configure ASR Compute Type in VoiceStudio: Environment Variable Guide

> Configure ASR compute type in VoiceStudio by setting the ASR_COMPUTE_TYPE environment variable. Choose float16, int8, or float32 for precise ASR control.

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

---

**Set the `ASR_COMPUTE_TYPE` environment variable to `float16`, `int8`, or `float32` before launching VoiceStudio to force a specific numeric precision for Automatic Speech Recognition and override automatic hardware detection.**

VoiceStudio determines which numeric precision to use for ASR engines at runtime through automatic hardware detection. While the application defaults to efficient half-precision mode when possible, you can manually configure the ASR compute type to ensure compatibility with older GPUs or achieve reproducible benchmarking results.

## Automatic ASR Compute Type Detection

VoiceStudio attempts to use **float16** (FP16) mode first for optimal performance on modern GPUs. If the GPU or underlying CTranslate2/cuDNN stack cannot execute FP16 operations, the engine automatically falls back to **int8** quantization or **float32** on CPU hardware.

This fallback mechanism is implemented in [`backend/core/failure.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/core/failure.py), which logs a `COMPUTE_TYPE_UNSUPPORTED` error when the primary precision fails and triggers the downgrade sequence. The automatic detection runs at runtime without requiring configuration, but may fail on certain hardware configurations that lack support for intermediate formats.

## Override ASR Compute Type with Environment Variables

To bypass automatic detection, set the **`ASR_COMPUTE_TYPE`** environment variable before starting the application. This variable is read during backend initialization by [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py) and the sidecar process defined in [`backend/engines/_asr_sidecar/main.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/engines/_asr_sidecar/main.py).

Accepted values include:

- **`float16`** – Half-precision mode offering fastest inference on supported NVIDIA GPUs (RTX 20 series and newer).
- **`int8`** – 8-bit quantization providing compatibility with older GPUs lacking FP16 support.
- **`float32`** – Full-precision CPU mode used when no GPU is available or for maximum accuracy.

## Implementation Examples

**Linux and macOS (Bash):**

```bash
export ASR_COMPUTE_TYPE=int8

# Restart VoiceStudio to apply the new setting

./scripts/run.sh

```

**Windows (PowerShell):**

```powershell
$env:ASR_COMPUTE_TYPE = "float16"
.\VoiceStudio.exe

```

**Python (Programmatic Configuration):**

```python
import os
os.environ["ASR_COMPUTE_TYPE"] = "float32"
from backend.services import asr_backend

```

## When to Configure ASR Compute Type Manually

Override the default behavior in these specific scenarios:

- **Legacy Hardware**: Maxwell or Pascal GPUs (GTX 900/10 series) lack native FP16 support and require `int8` or `float32` to prevent initialization failures.
- **Stability Issues**: When the engine crashes after automatic fallback attempts, pin to a supported compute type to eliminate the `COMPUTE_TYPE_UNSUPPORTED` error loop.
- **Reproducible Benchmarking**: Fix the precision level to remove nondeterministic hardware detection and ensure consistent performance measurements across test runs.

## Summary

- VoiceStudio auto-detects optimal precision via [`backend/core/failure.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/core/failure.py), falling back from float16 to int8 or float32 when hardware constraints are encountered.
- Force specific modes by setting the `ASR_COMPUTE_TYPE` environment variable to `float16`, `int8`, or `float32` before startup.
- Both [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py) and [`backend/engines/_asr_sidecar/main.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/engines/_asr_sidecar/main.py) read this variable during initialization.
- Configuration changes require a full application restart to take effect.

## Frequently Asked Questions

### What are the valid values for ASR_COMPUTE_TYPE?

VoiceStudio accepts three precision modes: `float16` for half-precision GPU inference, `int8` for quantized inference on older GPUs, and `float32` for full-precision CPU processing. These values are case-sensitive and validated at startup by the ASR service implementation.

### Why does VoiceStudio show a COMPUTE_TYPE_UNSUPPORTED error?

This error appears when the automatically selected precision (typically float16) is incompatible with your GPU architecture. The engine logs this via [`backend/core/failure.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/core/failure.py) before attempting fallback. Set `ASR_COMPUTE_TYPE=int8` to force compatible quantization and bypass the error.

### Do I need to restart VoiceStudio after changing ASR_COMPUTE_TYPE?

Yes. VoiceStudio reads this environment variable only during backend initialization in [`backend/services/asr_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/asr_backend.py) and the sidecar process. Changes take effect only after fully restarting the application or the backend service.

### Can I configure ASR compute type without environment variables?

Currently, VoiceStudio only supports configuration via the `ASR_COMPUTE_TYPE` environment variable. There is no runtime API or configuration file option; the sidecar process at [`backend/engines/_asr_sidecar/main.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/engines/_asr_sidecar/main.py) exclusively checks this variable at startup according to the source code.