🎙️ KugelAudio

Open-source text-to-speech for European languages with voice cloning capabilities
Powered by an AR + Diffusion architecture

---

Motivation

Open-source text-to-speech models for European languages are significantly lagging behind. While English TTS has seen remarkable progress, speakers of German, French, Spanish, Polish, and dozens of other European languages have been underserved by the open-source community.

KugelAudio aims to change this. Building on the excellent foundation laid by the VibeVoice team at Microsoft, we've trained a model specifically focused on European language coverage, using approximately 200,000 hours of highly pre-processed and enhanced speech data from the YODAS2 dataset.

🏆 Benchmark Results: Outperforming ElevenLabs

KugelAudio achieves state-of-the-art performance, beating industry leaders including ElevenLabs in rigorous human preference testing. This breakthrough demonstrates that open-source models can now rival - and surpass - the best commercial TTS systems.

Human Preference Benchmark (A/B Testing)

We conducted extensive A/B testing with 339 human evaluations to compare KugelAudio against leading TTS models. Participants listened to a reference voice sample, then compared outputs from two models and selected which sounded more human and closer to the original voice.

German Language Evaluation

The evaluation specifically focused on German language samples with diverse emotional expressions and speaking styles:

• Neutral Speech: Standard conversational tones
• Shouting: High-intensity, elevated volume speech
• Singing: Melodic and rhythmic speech patterns
• Drunken Voice: Slurred and irregular speech characteristics

These diverse test cases demonstrate the model's capability to handle a wide range of speaking styles beyond standard narration.

OpenSkill Ranking Results

Based on 339 evaluations using Bayesian skill-rating system (OpenSkill)

Audio Samples

Listen to KugelAudio's diverse voice capabilities across different speaking styles and languages:

German Voice Samples

All samples are generated with zero-shot voice cloning from reference audio.

Training Details

• Base Model: Microsoft VibeVoice
• Training Data: ~200,000 hours from YODAS2
• Hardware: 8x NVIDIA H100 GPUs
• Training Duration: 5 days

Supported Languages

KugelAudio supports 24 major European languages with varying levels of quality based on dataset representation:

📊 Language Coverage Disclaimer: Quality varies significantly by language. Spanish, French, English, and German have the strongest representation in our training data (~200,000 hours from YODAS2). Other languages may have reduced quality, prosody, or vocabulary coverage depending on their availability in the training dataset.

📖 Start Here

Get started with KugelAudio quickly using our documentation:

| ☁️ Hosted API | Use our cloud API for zero-setup inference | | 🔒 Watermarking | Verify AI-generated audio | | 📦 Models | Available model variants and benchmarks |

---

Features

• 🏆 State-of-the-Art Performance: Outperforms ElevenLabs and other leading TTS models in human evaluations

• 🌍 European Language Focus: Trained specifically for 24 major European languages

• High-Quality TTS: State-of-the-art speech synthesis using AR + Diffusion

• Audio Watermarking: All generated audio is watermarked using Facebook's AudioSeal

• 🎭 Emotional Range: Supports various speaking styles including shouting, singing, and expressive speech

• Web Interface: Easy-to-use Gradio UI for non-technical users

• HuggingFace Integration: Seamless loading from HuggingFace Hub

Quick Start

Installation

Prerequisites

• Python 3.10 or higher
• PyTorch 2.0 or higher
• CUDA (recommended for GPU acceleration)
• uv (recommended package manager)

Install uv

# macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Or via pip
pip install uv

Installation

# Clone the repository
git clone https://github.com/Kugelaudio/kugelaudio-open.git
cd kugelaudio-open

# Run directly with uv (recommended - handles all dependencies automatically)
uv run python start.py

That's it! The uv run command will automatically create a virtual environment and install all dependencies.

Launch Web Interface

# Quick start with uv (recommended)
uv run python start.py

# With a public share link
uv run python start.py ui --share

# Custom host and port
uv run python start.py ui --host 0.0.0.0 --port 8080

Then open http://127.0.0.1:7860 in your browser.

Command Line Usage

# Generate speech from text
uv run python start.py generate "Hello, this is KugelAudio!" -o hello.wav



# Using the default model for higher quality
uv run python start.py generate "Premium quality speech" --model kugelaudio/kugelaudio-0-open -o premium.wav

# Check if audio contains watermark
uv run python start.py verify audio.wav

Python API

from kugelaudio_open import (
    KugelAudioForConditionalGenerationInference,
    KugelAudioProcessor,
)
import torch

# Load model
device = "cuda" if torch.cuda.is_available() else "cpu"
model = KugelAudioForConditionalGenerationInference.from_pretrained(
    "kugelaudio/kugelaudio-0-open",
    torch_dtype=torch.bfloat16,
).to(device)
model.eval()

processor = KugelAudioProcessor.from_pretrained("kugelaudio/kugelaudio-0-open")

# Generate speech (watermark is automatically applied)
inputs = processor(text="Hello world!", return_tensors="pt")
inputs = {k: v.to(device) if isinstance(v, torch.Tensor) else v for k, v in inputs.items()}

with torch.no_grad():
    outputs = model.generate(**inputs, cfg_scale=3.0)

# Save audio
processor.save_audio(outputs.speech_outputs[0], "output.wav")

Hosted API

Don't want to run your own infrastructure? Use our hosted API at kugelaudio.com:

• ⚡ Ultra-low latency: Inference as fast as 39ms, end-to-end latency <100ms including network
• 🌍 Global edge deployment: Low latency worldwide
• 🔧 Zero setup: No GPU required, just API calls
• 📈 Auto-scaling: Handle any traffic volume

Python SDK

uv pip install kugelaudio

from kugelaudio import KugelAudio

# Initialize the client
client = KugelAudio(api_key="your_api_key")

# Generate speech
audio = client.tts.generate(
    text="Hello from KugelAudio!",
    model="kugel-1-turbo",
)

# Save to file
audio.save("output.wav")
print(f"Generated {audio.duration_seconds:.2f}s in {audio.generation_ms:.0f}ms")

📚 Full SDK Documentation →

Audio Watermarking

All audio generated by KugelAudio contains an imperceptible watermark using Facebook's AudioSeal technology. This helps identify AI-generated content and prevent misuse.

Verify Watermark

from kugelaudio_open.watermark import AudioWatermark

watermark = AudioWatermark()

# Check if audio is watermarked
result = watermark.detect(audio, sample_rate=24000)

print(f"Detected: {result.detected}")
print(f"Confidence: {result.confidence:.1%}")

Watermark Features

• Imperceptible: No audible difference in audio quality
• Robust: Survives compression, resampling, and editing
• Fast Detection: Real-time capable detection
• Sample-Level: 1/16k second resolution

Models

RTF = Real-Time Factor (generation time / audio duration). Lower is faster.

Architecture

KugelAudio uses a hybrid AR + Diffusion architecture:

1. Text Encoder: Qwen2-based language model encodes input text
2. TTS Backbone: Upper transformer layers generate speech representations
3. Diffusion Head: Predicts speech latents using denoising diffusion
4. Acoustic Decoder: Converts latents to audio waveforms

Configuration

Environment Variables

# Use specific GPU
export CUDA_VISIBLE_DEVICES=0

# Enable TF32 for faster computation on Ampere GPUs
export TORCH_ALLOW_TF32=1

Advanced Generation Parameters

outputs = model.generate(
    **inputs,
    voice_prompt=voice_prompt,      # Reference audio for voice cloning
    cfg_scale=3.0,                  # Guidance scale (1.0-10.0)
    max_new_tokens=4096,            # Maximum generation length
)

Responsible Use

This technology is intended for legitimate purposes:

✅ Appropriate Uses:

• Accessibility (TTS for visually impaired)
• Content creation (podcasts, videos, audiobooks)
• Voice assistants and chatbots
• Language learning applications
• Creative projects with consent

❌ Prohibited Uses:

• Creating deepfakes or misleading content
• Impersonating individuals without consent
• Fraud or deception
• Any illegal activities

All generated audio is watermarked to enable detection of AI-generated content.

License

MIT License - see LICENSE for details.

Acknowledgments

This model would not have been possible without the contributions of many individuals and organizations:

• Microsoft VibeVoice Team: For the excellent foundation architecture that this model builds upon
• YODAS2 Dataset: For providing the large-scale multilingual speech data
• Qwen Team: For the powerful language model backbone
• Facebook AudioSeal: For the audio watermarking technology
• HuggingFace: For model hosting and the transformers library

Special Thanks

• Carlos Menke: For his invaluable efforts in gathering the first datasets and extensive work benchmarking the model
• AI Service Center Berlin-Brandenburg (KI-Servicezentrum): For providing the GPU resources (8x H100) that made training this model possible

Authors

Kajo Kratzenstein
📧 kajo@kugelaudio.com
🌐 kugelaudio.com

Carlos Menke

Citation

@software{kugelaudio2026,
  title = {KugelAudio: Open-Source Text-to-Speech for European Languages with Voice Cloning},
  author = {Kratzenstein, Kajo and Menke, Carlos},
  year = {2026},
  institution = {Hasso-Plattner-Institut},
  url = {https://github.com/kugelaudio/kugelaudio}
}

---

Funding Notice

Das zugrunde liegende Vorhaben wurde mit Mitteln des Bundesministeriums für Forschung, Technologie und Raumfahrt unter dem Förderkennzeichen »KI-Servicezentrum Berlin-Brandenburg« 16IS22092 gefördert. Die Verantwortung für den Inhalt dieser Seite liegt bei der Autorin/beim Autor.

This project was funded by the German Federal Ministry of Research, Technology and Space under the funding code "AI Service Center Berlin-Brandenburg" 16IS22092. The responsibility for the content of this publication lies with the author.

---