# How to Configure Voicebox for the Intel XPU GPU Backend

> Effortlessly configure Voicebox with Intel XPU GPUs. Learn how IPEX enables automatic detection and utilization for a faster, hassle-free workflow. Get started now.

- Repository: [Jamie Pine/voicebox](https://github.com/jamiepine/voicebox)
- Tags: how-to-guide
- Published: 2026-04-14

---

**Voicebox automatically detects and utilizes Intel XPU GPUs when the Intel Extension for PyTorch (IPEX) is installed, requiring no manual configuration beyond ensuring the extension is available to the Python environment.**

The `jamiepine/voicebox` repository implements seamless Intel XPU support through automatic device discovery in its PyTorch backend, enabling high-performance text-to-speech generation on Intel Arc and Data Center GPU Flex Series hardware. When the Intel oneAPI Deep Learning Toolkit components are present, Voicebox prioritizes the XPU device during model initialization and runtime execution.

## How Voicebox Automatically Detects XPU GPUs

Voicebox determines the compute device through a cascading detection pipeline defined in [`backend/utils/platform_detect.py`](https://github.com/jamiepine/voicebox/blob/main/backend/utils/platform_detect.py) and [`backend/backends/base.py`](https://github.com/jamiepine/voicebox/blob/main/backend/backends/base.py). 

First, [`backend/utils/platform_detect.py`](https://github.com/jamiepine/voicebox/blob/main/backend/utils/platform_detect.py) (lines 19-35) selects the backend type. On non-Apple Silicon platforms, it returns `"pytorch"`, which activates the PyTorch device selection logic.

Next, [`backend/backends/base.py`](https://github.com/jamiepine/voicebox/blob/main/backend/backends/base.py) (lines 80-108) implements the `get_torch_device()` function. When called with `allow_xpu=True`, the function executes the following priority chain:

1. Check for NVIDIA CUDA availability
2. If `allow_xpu` is enabled, import `intel_extension_for_pytorch` and verify `torch.xpu.is_available()`
3. Fall back to DirectML, MPS (Apple Silicon), or CPU

When `torch.xpu.is_available()` returns `True`, the function returns the string `"xpu"`, which propagates throughout the backend systems.

## Prerequisites: Installing Intel Extension for PyTorch

For XPU detection to succeed, you must install the Intel Extension for PyTorch (IPEX) that matches your PyTorch version. This extension registers the `torch.xpu` module that Voicebox interrogates during startup.

Install the matching versions using pip:

```bash

# Example for PyTorch 2.3 – adjust versions to match Voicebox requirements

pip install torch==2.3.0 intel-extension-for-pytorch==2.3.0

```

*IPEX* exposes the `torch.xpu` namespace, enabling `torch.xpu.is_available()` to return `True` when Intel XPU hardware is present and drivers are correctly installed.

## Verifying XPU Detection Programmatically

You can confirm that Voicebox will select the XPU device by calling the same helper function used internally during model loading:

```python
from voicebox.backend.backends.base import get_torch_device

# Allow XPU and DirectML as fallbacks

device = get_torch_device(allow_xpu=True, allow_directml=True)
print(f"Voicebox will run on: {device}")

```

Expected output on a machine with XPU support:

```text
xpu

```

If IPEX is not installed or no XPU is present, the function silently catches the `ImportError` and returns the next available device (CUDA, DirectML, MPS, or CPU).

## Runtime Device Propagation and Model Loading

Once detected, the `"xpu"` device string flows through the backend architecture. In [`backend/backends/pytorch_backend.py`](https://github.com/jamiepine/voicebox/blob/main/backend/backends/pytorch_backend.py) (lines 36-40), the concrete backend class initializes `self.device` by calling `get_torch_device(allow_xpu=True, ...)`.

This device value is then passed to model loading functions via the `device_map=self.device` parameter. When `load_model_async()` executes, it places the TTS model directly on the XPU. During generation, all tensor operations execute on the XPU device, with memory management routines in [`backend/backends/base.py`](https://github.com/jamiepine/voicebox/blob/main/backend/backends/base.py) (lines 140-157) handling `torch.xpu.empty_device_cache()` and `torch.xpu.manual_seed()` calls.

## Monitoring XPU Status via the Health Endpoint

The `/health` endpoint defined in [`backend/routes/health.py`](https://github.com/jamiepine/voicebox/blob/main/backend/routes/health.py) (lines 68-78) exposes XPU runtime status. When XPU is active, the endpoint interrogates `torch.xpu` to retrieve the GPU name via `torch.xpu.get_device_name(0)` and reports XPU-specific VRAM statistics.

Example JSON response when XPU is present:

```json
{
  "version": "v1.5.2",
  "backend": "PYTORCH",
  "gpu_available": true,
  "gpu_type": "XPU (Intel Arc A770)",
  "vram_used_mb": 1024,
  "model_loaded": true,
  "model_size": "1.7B"
}

```

## Summary

- **Automatic detection**: Voicebox detects XPU via `get_torch_device(allow_xpu=True)` in [`backend/backends/base.py`](https://github.com/jamiepine/voicebox/blob/main/backend/backends/base.py) without configuration files.
- **IPEX requirement**: Install `intel-extension-for-pytorch` matching your PyTorch version to enable `torch.xpu` support.
- **Device propagation**: The `"xpu"` string flows from base detection through [`pytorch_backend.py`](https://github.com/jamiepine/voicebox/blob/main/pytorch_backend.py) to model loading via `device_map`.
- **Health monitoring**: The `/health` endpoint reports XPU device names and VRAM usage when active.
- **Graceful fallback**: If IPEX is missing, Voicebox automatically selects CUDA, DirectML, MPS, or CPU.

## Frequently Asked Questions

### Do I need to manually edit configuration files to enable XPU support?

No. Voicebox does not require manual configuration flags or JSON edits to utilize XPU hardware. Simply install the Intel Extension for PyTorch before starting the server. The `get_torch_device()` function in [`backend/backends/base.py`](https://github.com/jamiepine/voicebox/blob/main/backend/backends/base.py) automatically detects XPU availability when `allow_xpu=True` is passed during backend initialization.

### What happens if I install Voicebox but forget to install IPEX?

If `intel_extension_for_pytorch` is not importable, Voicebox catches the `ImportError` in [`backend/backends/base.py`](https://github.com/jamiepine/voicebox/blob/main/backend/backends/base.py) and skips the XPU detection branch. The system falls back through the device priority chain: NVIDIA CUDA, DirectML, Apple MPS, or CPU. No errors are thrown; the server simply operates on the next available compute device.

### Which Intel GPUs are compatible with Voicebox?

Voicebox supports any Intel GPU compatible with the Intel Extension for PyTorch, including Intel Arc A-Series graphics (A770, A750) and Intel Data Center GPU Flex Series. The specific hardware name is retrieved at runtime via `torch.xpu.get_device_name(0)` and reported in the health endpoint JSON payload.

### How can I verify that my generation request is actually running on XPU?

Check the `/health` endpoint response for `"gpu_type": "XPU (...)"` or monitor the server logs during model loading. You can also programmatically verify the device selection by importing `from voicebox.backend.backends.base import get_torch_device` and printing the result before initializing the `TTSService`. When XPU is active, `torch.xpu` memory management functions handle cache clearing between generations.