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

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. 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 at lines 1181-1190:

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 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 (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 for the engine definition.

Programmatic Engine Selection

Filter for CPU-Compatible Backends

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

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

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; 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.

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