# Which TTS Engines Are Suitable for Low VRAM or CPU-Only Systems in VoiceStudio

> Discover TTS engines for low VRAM or CPU-only systems in VoiceStudio. Explore MOSS-TTS-Nano, KittenTTS, VoxCPM2, and MLX-Audio for efficient voice generation without high-end hardware.

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

---

**VoiceStudio provides four TTS engines optimized for low VRAM or CPU-only environments: MOSS-TTS-Nano, KittenTTS, VoxCPM2, and MLX-Audio, each with zero or minimal memory requirements and explicit CPU support.**

VoiceStudio abstracts every text-to-speech engine behind a unified protocol in `services.tts_backend.TTSBackend`, making hardware-aware selection straightforward. For developers running inference on laptops, edge devices, or servers without dedicated GPUs, the framework exposes explicit compatibility metadata—`gpu_compat` and `min_vram_gb`—that identifies which engines run efficiently on limited hardware. This guide examines the specific engines, their resource profiles, and how to configure them programmatically.

## How VoiceStudio Declares Hardware Compatibility

Every TTS backend registers its requirements in the central registry (`_REGISTRY`) defined in [`backend/services/tts_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/tts_backend.py). The `list_backends()` function (lines 298-306) returns structured metadata including:

- `gpu_compat`: A tuple of supported execution providers (`"cpu"`, `"cuda"`, `"mps"`, `"rocm"`)
- `min_vram_gb`: Minimum GPU memory required, or `None`/`0` for CPU-only operation

The routing logic (lines 2437-2467) compares these values against host capabilities. Engines with `min_vram_gb == 0` and `"cpu"` in `gpu_compat` are automatically surfaced as viable options for constrained environments.

## Recommended TTS Engines for Low-VRAM and CPU-Only Systems

### MOSS-TTS-Nano: Zero-VRAM Realtime Synthesis

**MOSS-TTS-Nano** is VoiceStudio's purpose-built low-resource engine. With a **VRAM floor of 0 GB** and `gpu_compat = ("cuda", "cpu")`, it runs entirely on CPU without performance degradation.

- **Architecture**: ~100M parameter model optimized for 4-core CPUs
- **Output**: 48 kHz stereo, 20 languages supported
- **Use case**: Real-time narration on fanless laptops and embedded systems

The engine definition appears in [`backend/services/tts_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/tts_backend.py) at lines 1181-1190:

```python
class MossTTSNanoBackend(TTSBackend):
    gpu_compat = ("cuda", "cpu")
    min_vram_gb = 0
    # Realtime inference without GPU acceleration

```

MOSS-TTS-Nano achieves realtime performance through aggressive quantization and a streamlined vocoder, making it the default recommendation for CPU-only deployments.

### KittenTTS: Ultra-Lightweight English Engine

**KittenTTS** is the smallest available option—a pure CPU engine with `gpu_compat = ("cpu",)` exclusively. Its ONNX model weighs 25-80 MB and requires no CUDA, MPS, or ROCm runtime.

- **VRAM floor**: 0 GB (CPU-only, no GPU path exists)
- **Output**: 24 kHz mono, 8 preset voices
- **Use case**: Fast English voice-over on any platform, including ARM edge devices

Defined in [`backend/services/tts_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/tts_backend.py) at lines 1294-1305, KittenTTS loads instantly and generates 10-second utterances in under 2 seconds on modern laptop CPUs. The absence of GPU support is intentional: elimination of device transfer overhead reduces latency for short-form content.

### VoxCPM2: GPU-Optional with CPU Fallback

**VoxCPM2** offers higher fidelity with graceful degradation. While it prefers GPU execution, its **~2 GB VRAM floor** is optional—`gpu_compat = ("cuda", "mps", "cpu")` permits full CPU operation when accelerators are unavailable.

- **Capability**: 30 languages, studio-grade 48 kHz, voice design from text description
- **Trade-off**: 3-5x slower generation on CPU versus GPU
- **Use case**: Quality-critical production when GPU access is intermittent

The implementation in [`backend/services/tts_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/tts_backend.py) (lines 1009-1016) automatically detects available hardware and falls back to CPU tensors when CUDA/MPS initialization fails.

### MLX-Audio: Apple Silicon Optimized with CPU Escape Hatch

**MLX-Audio** targets Apple Silicon via the MLX framework but includes explicit CPU support through `gpu_compat = ("rocm", "cuda", "mps", "cpu")`. With approximately **1 GB VRAM** recommended for accelerated paths, it remains functional on CPU-only Macs when the MLX runtime is unavailable.

- **Languages**: 7+ with MLX-native optimizations
- **Fallback behavior**: PyTorch CPU backend when MLX device unavailable
- **Use case**: Cross-platform deployment including Intel Macs and containerized environments

See lines 1537-1544 in [`backend/services/tts_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/tts_backend.py) for the engine definition.

## Programmatic Engine Selection

### Filter for CPU-Compatible Backends

```python
from services.tts_backend import list_backends

cpu_backends = [
    b for b in list_backends()
    if "cpu" in b["gpu_compat"] and (b["min_vram_gb"] or 0) == 0
]

print("CPU-friendly TTS engines:", [b["id"] for b in cpu_backends])

# Output: ['moss-tts-nano', 'kittentts', 'voxcpm2', ...]

```

### Instantiate MOSS-TTS-Nano Directly

```python
from services.tts_backend import MossTTSNanoBackend

backend = MossTTSNanoBackend()
audio_tensor = backend.generate("Hello world!", lang="en")

# Returns 48kHz stereo tensor, no GPU memory allocated

```

### Force CPU Fallback with VoxCPM2

```python
import os

# Optional: suppress GPU detection

os.environ["CUDA_VISIBLE_DEVICES"] = ""

os.environ["OMNIVOICE_TTS_BACKEND"] = "voxcpm2"

from services.tts_backend import get_active_tts_backend

tts = get_active_tts_backend()

# VoxCPM2Backend loads on CPU, slower but functional

wave = tts.generate(
    "Low-VRAM test",
    description="young female voice, warm tone"
)

```

## Engine Comparison Summary

| Engine | VRAM Required | CPU Support | Best For |
|--------|-------------|-------------|----------|
| MOSS-TTS-Nano | 0 GB | Native | Multilingual realtime, edge devices |
| KittenTTS | 0 GB | Exclusive | Fast English, minimal footprint |
| VoxCPM2 | ~2 GB (optional) | Fallback | Studio quality, flexible deployment |
| MLX-Audio | ~1 GB (optional) | Fallback | Apple Silicon, cross-platform MLX |

## Summary

- **MOSS-TTS-Nano** and **KittenTTS** require zero VRAM and run natively on CPU—choose these for resource-constrained environments.
- **VoxCPM2** and **MLX-Audio** accept CPU execution as fallback when GPU memory is unavailable, at reduced speed.
- All compatibility metadata resides in [`backend/services/tts_backend.py`](https://github.com/debpalash/VoiceStudio/blob/main/backend/services/tts_backend.py); inspect `gpu_compat` and `min_vram_gb` to validate any engine's hardware requirements.
- Use `list_backends()` to filter programmatically, or set environment variables to force specific engine selection.

## Frequently Asked Questions

### How much RAM does MOSS-TTS-Nano need on CPU?

MOSS-TTS-Nano operates within **4 GB system RAM** on a 4-core CPU, with no GPU memory required. Peak RAM usage during inference stays below 800 MB for typical utterances under 30 seconds.

### Can I use VoxCPM2 on a machine with no GPU at all?

Yes. VoxCPM2's `gpu_compat` tuple includes `"cpu"`, and the backend initializes CPU tensors when CUDA or MPS devices are absent. Generation latency increases proportionally with text length—expect 10-20 seconds for 30-second audio versus 2-4 seconds on GPU.

### Why does KittenTTS not support GPU acceleration?

KittenTTS uses a highly optimized ONNX Runtime graph designed for CPU cache efficiency. GPU execution would require memory transfers that outweigh compute benefits for its small model size (under 100 MB). The CPU-only constraint minimizes deployment dependencies.

### How do I check which engines my VoiceStudio installation has registered?

Query the runtime registry: `from services.tts_backend import list_backends; print([b["id"] for b in list_backends()])`. This returns all available engines with their `gpu_compat` and `min_vram_gb` values, filtered by which backend packages are installed in your environment.