NeuTTS Nano: 120M Parameter TTS for Raspberry Pi

from neutts import NeuTTSNano

model = NeuTTSNano.from_pretrained("neutts-nano-120m")
audio = model.synthesize("Running neural TTS on a Raspberry Pi 4")
audio.save("output.wav")

This three-line snippet generates natural-sounding speech on hardware that costs under $100. NeuTTS Nano represents a significant shift in text-to-speech deployment, compressing neural voice synthesis into 120 million parameters that run comfortably on ARM processors without requiring cloud connectivity or expensive GPUs.

Key Specs

NeuTTS Nano achieves real-time synthesis on Raspberry Pi 4 hardware through aggressive model compression and architectural optimizations. The 120M parameter count sits roughly 10x smaller than standard neural TTS models while maintaining naturalness scores above 4.0 on the Mean Opinion Score (MOS) scale.

The model supports 16kHz audio output with a synthesis speed of approximately 0.8x real-time on Raspberry Pi 4 (4GB RAM). This means generating one second of audio takes roughly 1.25 seconds of processing time. Memory footprint stays under 500MB during inference, leaving headroom for other applications.

Architecture-wise, NeuTTS Nano employs a lightweight transformer encoder paired with a modified WaveGRU vocoder. The team behind the model used knowledge distillation from larger TTS systems, then applied quantization to reduce model size without catastrophic quality loss. The result supports English text input with basic prosody control through SSML tags.

Installation requires Python 3.8+ and approximately 250MB of disk space for the model weights. The package includes ONNX runtime optimizations specifically tuned for ARM processors, bypassing the overhead of full PyTorch inference.

Who Benefits

Embedded developers building voice interfaces for IoT devices gain offline TTS capabilities without recurring API costs. Smart home projects, robotics applications, and accessibility tools can now include voice output without internet dependencies or privacy concerns about sending text to external services.

Educational institutions using Raspberry Pi for teaching AI concepts have a practical example of model optimization techniques. The codebase demonstrates quantization, distillation, and efficient inference patterns that students can examine and modify.

Hobbyists creating voice assistants or interactive projects benefit from the low barrier to entry. A single Raspberry Pi can handle both speech recognition (via Whisper.cpp or similar) and synthesis, creating complete voice interaction loops on device.

Edge computing scenarios where latency matters see advantages from local processing. Museum exhibits, kiosks, or industrial interfaces that need voice feedback can operate without network calls that introduce unpredictable delays.

Quick Start

Installation through pip brings all dependencies:

pip install neutts-nano

Basic synthesis requires minimal code:

from neutts import NeuTTSNano

# Load model (first run downloads weights)
tts = NeuTTSNano.from_pretrained("neutts-nano-120m")

# Generate speech
audio = tts.synthesize("Text to convert to speech")

# Save or play
audio.save("output.wav")
# Or play directly: audio.play()

For Raspberry Pi deployments, enabling hardware acceleration improves performance:

tts = NeuTTSNano.from_pretrained(
    "neutts-nano-120m",
    use_arm_neon=True,
    num_threads=4
)

The model accepts SSML for basic prosody control:

text = '<speak>This is <emphasis>important</emphasis>. <break time="500ms"/> Listen carefully.</speak>'
audio = tts.synthesize(text, ssml=True)

Batch processing multiple sentences improves throughput:

sentences = ["First sentence.", "Second sentence.", "Third sentence."]
audio_segments = tts.synthesize_batch(sentences)

The GitHub repository at https://github.com/neutts/neutts-nano contains additional examples for streaming synthesis and integration with common speech recognition frameworks.

Alternatives

Piper TTS offers similar edge-device capabilities with multiple voice options and slightly better quality at the cost of higher computational requirements. Running Piper on Raspberry Pi 4 typically achieves 0.5x real-time speed, making it slower but more natural-sounding.

Coqui TTS provides more flexibility and voice cloning features but demands significantly more resources. Even the smallest Coqui models struggle on Raspberry Pi without optimization, though they excel on more powerful edge devices like NVIDIA Jetson boards.

Festival and eSpeak represent traditional concatenative and formant synthesis approaches. Both run faster than neural models and require minimal resources, but produce robotic-sounding output that lacks the naturalness users expect from modern systems.

Cloud-based services like Amazon Polly or Google Cloud TTS deliver superior quality and support dozens of languages. They require internet connectivity, introduce latency, and incur per-character costs that accumulate in high-volume applications.

For developers prioritizing quality over edge deployment, models like VITS or YourTTS running on standard servers provide state-of-the-art synthesis. NeuTTS Nano trades some naturalness for the ability to run entirely on low-power hardware, filling a specific niche in the TTS ecosystem.