uncloseai-speech/docs/models/silero-tts.md

Silero TTS

Project: snakers4/silero-models Status: ✅ INTEGRATED as tts-1-silero License: Apache 2.0 Maintenance: ✨ ACTIVELY MAINTAINED

Overview

Silero TTS is a collection of fast, small, and high-quality speech synthesis models maintained by Silero AI. Unlike many TTS projects that have been abandoned, Silero is actively maintained and continues to receive updates.

Why Silero?

• Active Project - Regular updates, responsive maintainers
• Commercial-Friendly - Apache 2.0 license
• CPU Efficient - Real-time synthesis without GPU
• Small Models - 50-100MB per language
• High Quality - Excellent quality for model size
• Multilingual - 5 languages with 148 total voices

Integration Status

Integrated: November 2025 Endpoint: tts-1-silero API Compatibility: OpenAI TTS API compatible

Supported Languages

Language	Speakers	Model Version	Voice IDs
English	118 voices	v3_en	en_0 to en_117 + random
Russian	6 voices	ru_v3	ru_aidar, ru_baya, ru_kseniya, ru_xenia, ru_eugene, ru_random
German	6 voices	v3_de	de_eva_k, de_karlsson, de_friedrich, de_hokuspokus, de_bernd_ungerer, de_random
Spanish	4 voices	v3_es	es_0, es_1, es_2, es_random
French	7 voices	v3_fr	fr_0 to fr_5 + fr_random

Total: 148 voices across 5 languages

Technical Specifications

Architecture: Neural TTS based on PyTorch Sample Rate: 48kHz Model Size: ~50-100MB per language Inference Speed: Real-time on CPU (RTF ~0.1x) Memory Usage: ~500MB RAM during inference

Model Loading

Models are loaded via PyTorch Hub:

import torch

model, example_text = torch.hub.load(
    repo_or_dir='snakers4/silero-models',
    model='silero_tts',
    language='en',
    speaker='v3_en',
    verbose=False
)

# Generate speech
audio = model.apply_tts(
    text="Hello from Silero TTS!",
    speaker='en_0',
    sample_rate=48000
)

Integration Details

Voice Configuration

Example configuration in voice_to_speaker.yaml:

tts-1-silero:
  # OpenAI-compatible aliases
  alloy:
    language: en
    speaker: en_0
    silero_speaker: v3_en

  # English voices (118 total)
  en_0:
    language: en
    speaker: en_0
    silero_speaker: v3_en

  en_1:
    language: en
    speaker: en_1
    silero_speaker: v3_en

  # Russian voices
  ru_aidar:
    language: ru
    speaker: aidar
    silero_speaker: ru_v3

  # German voices
  de_eva_k:
    language: de
    speaker: eva_k
    silero_speaker: v3_de

  # Spanish voices
  es_0:
    language: es
    speaker: es_0
    silero_speaker: v3_es

  # French voices
  fr_0:
    language: fr
    speaker: fr_0
    silero_speaker: v3_fr

Makefile Targets

# Download all Silero models (en, ru, de, es, fr)
make voices-silero

# Test Silero TTS endpoint
make test-silero

API Usage

# English voice
curl -X POST http://localhost:8000/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tts-1-silero",
    "voice": "en_0",
    "input": "Hello from Silero TTS!"
  }' \
  -o output.mp3

# Russian voice
curl -X POST http://localhost:8000/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tts-1-silero",
    "voice": "ru_aidar",
    "input": "Привет от Silero TTS!"
  }' \
  -o output_ru.mp3

# German voice
curl -X POST http://localhost:8000/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tts-1-silero",
    "voice": "de_eva_k",
    "input": "Hallo von Silero TTS!"
  }' \
  -o output_de.mp3

Wrapper Implementation

The Silero wrapper in speech.py:

class silero_wrapper():
    """Wrapper for Silero TTS models

    Silero torch.hub.load returns: (model, example_text)
    The model has a method apply_tts(text, speaker, sample_rate)
    """
    def __init__(self, language='en', speaker='v3_en', device='cpu'):
        self.language = language
        self.speaker = speaker
        self.device = device

        logger.info(f"Loading Silero model for {language} with speaker {speaker} on {device}")

        import torch
        try:
            # torch.hub.load returns (model, example_text)
            self.model, example_text = torch.hub.load(
                repo_or_dir='snakers4/silero-models',
                model='silero_tts',
                language=language,
                speaker=speaker,
                verbose=False
            )

            self.model.to(device)  # Move to device (in-place for Silero)
            self.sample_rate = 48000  # Silero uses 48kHz
            logger.info(f"Successfully loaded Silero {language}/{speaker}, example: {example_text}")
        except Exception as e:
            logger.error(f"Failed to load Silero model: {e}")
            raise

    def tts(self, text, speaker_id='en_0'):
        """Generate speech from text"""
        import torch

        with torch.no_grad():
            # Use model's apply_tts method
            audio = self.model.apply_tts(
                text=text,
                speaker=speaker_id,
                sample_rate=self.sample_rate
            )
            # audio is a tensor, convert to numpy float32
            return audio.cpu().numpy().tobytes()

Performance Characteristics

Speed: Real-time on CPU Quality: Good - excellent for model size Latency: Low (~100-200ms for short phrases) Memory: Efficient - models stay loaded in RAM

Benchmarks (Approximate)

Text Length	Generation Time (CPU)	RTF
10 words	~0.5s	0.15x
50 words	~2.0s	0.10x
100 words	~4.0s	0.08x

RTF = Real-time factor (lower is faster)

Voice Quality

Silero voices are optimized for:

• Clarity - Clean, intelligible speech
• Naturalness - Good prosody for synthesized speech
• Consistency - Stable quality across different texts
• Speed - Fast enough for real-time applications

Not optimized for:

• Emotional expression (limited)
• Voice cloning (not supported)
• Singing or non-speech audio

Known Issues

Russian and Spanish Voice Formats

Issue: Some Russian and Spanish voices return error responses Affected: ru_* and es_* voices Status: Under investigation Workaround: Use English, German, or French voices

Tracking: See GitHub issue or docs/MODELS.md for updates

Raccoon Mission Notes

Rescue Status: ⭐⭐⭐⭐⭐ EXCELLENT

Why Silero is a Perfect Raccoon Rescue:

1. Active Maintenance - Regular updates, no abandonment risk
2. Open License - Apache 2.0, commercial-friendly
3. High Quality/Size Ratio - Best bang for buck
4. Multi-language - 5 languages with more planned
5. CPU Friendly - No GPU required
6. Easy Integration - PyTorch Hub makes it simple

Integration Success:

• ✅ All 5 languages configured
• ✅ 148 voices mapped
• ✅ OpenAI API compatibility
• ✅ Makefile automation
• ⚠️ Russian/Spanish voices need debugging

Future Enhancements

Planned:

1. Fix Russian and Spanish voice issues
2. Add emotion control (Silero supports this)
3. Implement voice caching for faster switching
4. Add streaming support
5. Create voice sample gallery

Possible:

• Additional languages (Ukrainian, Uzbek, Tatar available)
• Fine-tuning for specific use cases
• Model quantization for even smaller sizes

Resources

Official Links:

• GitHub: https://github.com/snakers4/silero-models
• Documentation: https://github.com/snakers4/silero-models/wiki
• PyTorch Hub: https://pytorch.org/hub/snakers4_silero-models_tts/
• Models: https://models.silero.ai/

Community:

• Actively maintained by Silero AI team
• Responsive to issues and pull requests
• Growing user base

Papers:

• No formal academic paper (production-focused)
• Extensive documentation and examples

License

Apache License 2.0 - Commercial use permitted

Copyright (c) 2020-2025 Silero AI

Licensed under the Apache License, Version 2.0

---

Integration Date: November 2025 Raccoon Rating: 🦝🦝🦝🦝🦝 (5/5 - Perfect rescue!) Maintenance: ✅ Active Recommendation: Highly Recommended - Best quality/performance/license combo