# Vergleich von TTS-Engines

Vergleichen Sie die führenden Open-Source-Text-zu-Sprache-Engines für die Bereitstellung auf Clore.ai GPU-Servern.

{% hint style="info" %}
**Text-zu-Sprache (TTS)** wandelt geschriebenen Text in natürlich klingendes Audio um. Dieser Leitfaden vergleicht fünf führende Open-Source-TTS‑Engines: XTTS v2, Bark, Kokoro, Fish Speech und MeloTTS — und behandelt Qualität, Geschwindigkeit, Sprachunterstützung und Fähigkeiten zur Stimmmodellierung.
{% endhint %}

***

## Schnelle Entscheidungsübersicht

|                     | XTTS v2                  | Bark                         | Kokoro            | Fish Speech  | MeloTTS            |
| ------------------- | ------------------------ | ---------------------------- | ----------------- | ------------ | ------------------ |
| **Entwickler**      | Coqui AI                 | Suno AI                      | Hexgrad           | Fish Audio   | MyShell AI         |
| **Qualität**        | ⭐⭐⭐⭐⭐                    | ⭐⭐⭐⭐                         | ⭐⭐⭐⭐              | ⭐⭐⭐⭐⭐        | ⭐⭐⭐                |
| **Geschwindigkeit** | Mittel                   | Langsam                      | **Schnell**       | **Schnell**  | **Am schnellsten** |
| **Stimmenklonen**   | ✅ (3s Clip)              | ✅ (Stimmen-Voreinstellungen) | ✅ (eingeschränkt) | ✅ (10s Clip) | ❌                  |
| **Sprachen**        | 17                       | 10+                          | Englisch          | 8+           | 8                  |
| **Min. VRAM**       | 4GB                      | 8GB                          | **CPU ok**        | 4GB          | **CPU ok**         |
| **Lizenz**          | CPML (nicht-kommerziell) | MIT                          | Apache 2.0        | CC BY-NC-SA  | MIT                |
| **GitHub-Sterne**   | 35K+ (Coqui TTS)         | 38K+                         | 12K+              | 14K+         | 15K+               |

***

## Übersicht

### XTTS v2

Coquis XTTS v2 ist der Goldstandard für Open-Source-Stimmenklon-TTS. Es kann jede Stimme aus einem 3‑sekündigen Audioclip mit außergewöhnlicher Genauigkeit klonen.

**Philosophie**: Maximale Ausdruckskraft und Qualität beim Stimmenklonen.

```python
from TTS.api import TTS

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

# Zero-shot-Stimmenklon aus 3s Referenz
tts.tts_to_file(
    text="Hello, this is a cloned voice speaking naturally.",
    speaker_wav="reference_voice.wav",
    language="en",
    file_path="output.wav"
)
```

### Bark

Sunos Bark ist ein transformerbasiertes TTS-Modell, das sehr ausdrucksstarke Sprache erzeugt, einschließlich Nicht-Sprach‑Geräuschen: Lachen, Seufzen, Musik und Soundeffekten.

**Philosophie**: Nicht nur Sprache — vollständige Audioerzeugung.

```python
from bark import SAMPLE_RATE, generate_audio, preload_models
from scipy.io.wavfile import write as write_wav

preload_models()

audio_array = generate_audio(
    "[laughs] Hello! [clears throat] This is Bark TTS. [sighs]"
)
write_wav("output.wav", SAMPLE_RATE, audio_array)
```

### Kokoro

Kokoro ist ein leichtgewichtiges, schnelles TTS-Modell, das für Englisch optimiert ist. Trotz seiner geringen Größe (\~82M Parameter) liefert es überraschend hohe Qualität.

**Philosophie**: Kleines Modell, große Qualität, läuft überall.

```python
from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='a')  # 'a' = American English

generator = pipeline(
    "The quick brown fox jumps over the lazy dog.",
    voice='af_heart',  # vorgefertigte Stimme
    speed=1.0,
)

for _, _, audio in generator:
    sf.write('output.wav', audio, 24000)
```

### Fish Speech

Fish Audios Fish Speech ist ein produktionsreifes TTS mit außergewöhnlichem Stimmenklonen aus kurzen Clips. Es verwendet eine neuartige Codec- + Sprachmodell‑Architektur.

**Philosophie**: Produktionsqualität, schnelle Inferenz, exzellentes Klonen.

```python
# Fish Speech via HTTP API
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Hello, this is Fish Speech generating audio.",
        "reference_id": "your-voice-id",
        "format": "wav",
    }
)

with open("output.wav", "wb") as f:
    f.write(response.content)
```

### MeloTTS

MyShells MeloTTS ist ultraschnelles, multi-akzentuiertes TTS, optimiert für Echtzeitanwendungen. Es läuft effizient auf der CPU und unterstützt mehrere englische Akzente sowie asiatische Sprachen.

**Philosophie**: Echtzeitgeschwindigkeit in beliebigem Maßstab.

```python
from melo.api import TTS

speed = 1.0
device = 'auto'

model = TTS(language='EN', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'output.wav'
model.tts_to_file(
    "Hello world! MeloTTS is very fast.",
    speaker_ids['EN-Default'],
    output_path,
    speed=speed
)
```

***

## Qualitätsvergleich

### Natürlichkeitswerte (MOS — Mean Opinion Score, 1–5)

{% hint style="info" %}
MOS-Werte sind ungefähre Angaben basierend auf veröffentlichten Papern und Community‑Bewertungen. Die tatsächliche Qualität hängt stark vom Textinhalt und der Stimmkonfiguration ab.
{% endhint %}

| Modell      | Englischer MOS | Multilingualer MOS | Ausdrucksstärke     |
| ----------- | -------------- | ------------------ | ------------------- |
| XTTS v2     | 4.3            | 4.1                | ⭐⭐⭐⭐⭐               |
| Bark        | 3.9            | 3.7                | ⭐⭐⭐⭐⭐ (einzigartig) |
| Kokoro      | 4.2            | N/V (nur EN)       | ⭐⭐⭐                 |
| Fish Speech | 4.4            | 4.2                | ⭐⭐⭐⭐                |
| MeloTTS     | 3.8            | 3.6                | ⭐⭐                  |

### Worin jedes Modell am besten ist

| Modell      | Besondere Qualitätsmerkmale                             |
| ----------- | ------------------------------------------------------- |
| XTTS v2     | Beinahe perfektes Stimmenklonen, emotionaler Umfang     |
| Bark        | Nicht-Sprachgeräusche, Lachen, Musik, Effekte           |
| Kokoro      | Bestes Qualitäts‑zu‑Größe‑Verhältnis, natürliche Kadenz |
| Fish Speech | Beste Gesamt‑Natürlichkeit + Klon‑Genauigkeit           |
| MeloTTS     | Konsistente, saubere Ausgabe für lange Texte            |

***

## Geschwindigkeitsbenchmarks

### Zeichen pro Sekunde (CPU vs GPU)

Test: "The quick brown fox jumps over the lazy dog. How are you today?" (60 Zeichen)

| Modell      | CPU-Geschwindigkeit | GPU-Geschwindigkeit (RTX 3080) | Echtzeitfaktor |
| ----------- | ------------------- | ------------------------------ | -------------- |
| XTTS v2     | \~15 Zeichen/s      | \~150 Zeichen/s                | 0.3× (GPU)     |
| Bark        | \~5 Zeichen/s       | \~40 Zeichen/s                 | 0.1× (GPU)     |
| Kokoro      | \~200 Zeichen/s     | \~800 Zeichen/s                | **5× (GPU)**   |
| Fish Speech | \~80 Zeichen/s      | \~500 Zeichen/s                | **3× (GPU)**   |
| MeloTTS     | **\~500 Zeichen/s** | \~2000 Zeichen/s               | **12× (GPU)**  |

*Echtzeitfaktor > 1.0 bedeutet schneller als Wiedergabegeschwindigkeit*

### Zeit zur Erzeugung von 1 Minute Audio

| Modell      | CPU      | RTX 3080 | A100    |
| ----------- | -------- | -------- | ------- |
| XTTS v2     | \~8 min  | \~30s    | \~10s   |
| Bark        | \~20 min | \~3 min  | \~45s   |
| Kokoro      | \~20s    | \~5s     | \~2s    |
| Fish Speech | \~45s    | \~8s     | \~3s    |
| MeloTTS     | **\~8s** | **\~2s** | **<1s** |

{% hint style="success" %}
**Für Echtzeitanwendungen**: MeloTTS und Kokoro sind die klaren Gewinner. Beide können Sprache schneller als die Wiedergabegeschwindigkeit erzeugen, sogar auf der CPU.
{% endhint %}

***

## Sprachunterstützung

### Unterstützte Sprachen

| Modell      | Sprachen | Bemerkenswert                                                      |
| ----------- | -------- | ------------------------------------------------------------------ |
| XTTS v2     | 17       | EN, ES, FR, DE, IT, PT, PL, TR, RU, NL, CS, AR, ZH, JA, HU, KO, HI |
| Bark        | 10+      | EN, ZH, FR, DE, HI, IT, JA, KO, PL, PT, RU, ES, TR                 |
| Kokoro      | 2        | Englisch (US/UK), Japanisch (eingeschränkt)                        |
| Fish Speech | 8        | EN, ZH, JA, KO, FR, DE, AR, ES                                     |
| MeloTTS     | 8        | EN (4 Akzente), ES, FR, ZH, JA, KO                                 |

### Anmerkungen zur Sprachqualität

| Modell      | Englisch      | Chinesisch | Japanisch | Europäisch    |
| ----------- | ------------- | ---------- | --------- | ------------- |
| XTTS v2     | Ausgezeichnet | Gut        | Gut       | Ausgezeichnet |
| Bark        | Gut           | Mäßig      | Mäßig     | Gut           |
| Kokoro      | Ausgezeichnet | ❌          | Begrenzt  | ❌             |
| Fish Speech | Ausgezeichnet | **Beste**  | Gut       | Gut           |
| MeloTTS     | Gut           | Gut        | Gut       | Gut           |

{% hint style="info" %}
**Für chinesisches TTS**: Fish Speech und MeloTTS sind die besten Open-Source‑Optionen. Beide handhaben Tonhöhen und Schriftzeichen natürlich.

**Für mehrsprachige Anwendungen**: XTTS v2 unterstützt die meisten Sprachen mit konsistenter Qualität in allen.
{% endhint %}

***

## Vergleich des Stimmenklonens

### Klon-Fähigkeiten

| Modell      | Referenzlänge                | Klon-Qualität | Zero-Shot |
| ----------- | ---------------------------- | ------------- | --------- |
| XTTS v2     | **3 Sekunden**               | ⭐⭐⭐⭐⭐         | ✅         |
| Bark        | Nur Stimmen‑Voreinstellungen | ⭐⭐⭐           | Teilweise |
| Kokoro      | Nicht unterstützt            | ❌             | ❌         |
| Fish Speech | 10 Sekunden                  | ⭐⭐⭐⭐⭐         | ✅         |
| MeloTTS     | Nicht unterstützt            | ❌             | ❌         |

### XTTS v2 Stimmenklonen

```python
from TTS.api import TTS
import torch

# Modell laden
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.to("cuda" if torch.cuda.is_available() else "cpu")

# Stimme aus Referenz klonen (minimum 3 Sekunden, ideal 10–30 Sekunden)
tts.tts_to_file(
    text="""
    Welcome to our podcast. Today we're discussing the future of AI 
    and its impact on society. I'm your host, and I'm excited to 
    share some fascinating insights with you.
    """,
    speaker_wav="speaker_sample.wav",  # Ihre Referenzaufnahme
    language="en",
    file_path="cloned_voice_output.wav"
)
```

### Fish Speech Stimmenklonen

```bash
# Vom Referenzaudio klonen
fish_speech_cli tts \
  --text "This is my cloned voice speaking a new sentence." \
  --reference-audio speaker_sample.wav \
  --reference-text "The original text spoken in the reference audio." \
  --output cloned_output.wav
```

### Bark Stimmen‑Voreinstellungen

```python
from bark import generate_audio, SAMPLE_RATE
from scipy.io.wavfile import write

# Bark verwendet vordefinierte Sprechercodes
voice_presets = {
    "male_US": "v2/en_speaker_6",
    "female_US": "v2/en_speaker_9",
    "male_UK": "v2/en_speaker_0",
    "announcer": "v2/en_speaker_2",
}

audio = generate_audio(
    "Welcome! [laughs] This is absolutely fascinating technology.",
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)
```

***

## XTTS v2: Tiefer Einblick

### Architektur

* **VITS + GPT** hybride Architektur
* Trainiert auf 16K+ Stunden über 17 Sprachen
* 3‑Sekunden‑Minimum für Zero‑Shot‑Kloning

### Installation auf Clore.ai

```bash
pip install TTS
# GPU-Version
pip install TTS[all]
```

### Docker‑Bereitstellung

```dockerfile
FROM nvidia/cuda:12.1.0-cudnn8-runtime-ubuntu22.04

RUN apt-get update && apt-get install -y python3 python3-pip git ffmpeg
RUN pip3 install TTS fastapi uvicorn

WORKDIR /app
COPY server.py .

EXPOSE 5002
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "5002"]
```

```python
# server.py — XTTS v2 REST API
from fastapi import FastAPI, UploadFile, Form
from fastapi.responses import FileResponse
from TTS.api import TTS
import tempfile, os

app = FastAPI()
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

@app.post("/tts")
async def synthesize(
    text: str = Form(...),
    language: str = Form("en"),
    speaker_file: UploadFile = None
):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out:
        output_path = out.name

    speaker_path = None
    if speaker_file:
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as ref:
            ref.write(await speaker_file.read())
            speaker_path = ref.name

    tts.tts_to_file(
        text=text,
        speaker_wav=speaker_path,
        language=language,
        file_path=output_path
    )
    return FileResponse(output_path, media_type="audio/wav")
```

```bash
docker build -t xtts-server .
docker run -d --gpus all -p 5002:5002 xtts-server
```

**Schwächen**: CPML-Lizenz (nicht-kommerziell ohne Erlaubnis), langsamer als Kokoro/MeloTTS

***

## Bark: Tiefer Einblick

### Architektur

* **GPT‑artiger Transformer** für Audio-Token‑Erzeugung
* Drei‑stufiger Prozess: Text → semantisch → grob → fein Token
* Erzeugt tatsächliche Audio‑Codec‑Token (EnCodec)

### Was Bark einzigartig macht

Bark ist das einzige Open‑Source‑TTS, das nativ erzeugt:

* 🎵 Hintergrundmusik innerhalb der Sprache
* 😂 Lachen, Seufzer, Halsräuspern
* 🎭 Mehrere Sprecher in einer Erzeugung
* 🌍 Mischsprachige Äußerungen

### Auszeichnungssprache

```python
from bark import generate_audio, SAMPLE_RATE
from scipy.io.wavfile import write

# Spezial‑Token für Ausdrucksstärke
text = """
[clears throat] Good morning everyone. [laughs] 
Die heutige Präsentation wird ... behandeln 
[sighs deeply] ...eigentlich ziemlich viel.
[music: upbeat jazz] Let's get started!
"""

audio = generate_audio(text, history_prompt="v2/en_speaker_6")
write("output.wav", SAMPLE_RATE, audio)
```

### Installation

```bash
pip install git+https://github.com/suno-ai/bark.git
```

**Schwächen**: Langsam (3‑stufige Pipeline), inkonsistent zwischen Läufen, kein echtes Stimmenklonen

***

## Kokoro: Tiefer Einblick

### Architektur

* **82M Parameter** StyleTTS2‑basiertes Modell
* Extrem klein, aber überraschend hohe Qualität
* Schnelle Inferenz auf CPU und GPU

### Verfügbare Stimmen

```python
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')  # 'a' = American English, 'b' = British

# Verfügbare Stimmen
voices = {
    'af_heart': 'American Female (warm)',
    'af_bella': 'American Female (bella)',
    'af_nicole': 'American Female (nicole)',
    'am_michael': 'American Male (michael)',
    'am_fenrir': 'American Male (fenrir)',
    'bf_emma': 'British Female (emma)',
    'bm_george': 'British Male (george)',
}

# Mit verschiedenen Stimmen erzeugen
for voice_name, description in voices.items():
    gen = pipeline("Hello, this is a test.", voice=voice_name)
    for _, _, audio in gen:
        print(f"Generated with {description}")
```

### Streaming‑Unterstützung

```python
import sounddevice as sd
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')

# Audio in Echtzeit streamen, während es erzeugt wird
text = "This is a very long text that will be streamed as it generates, providing low-latency audio output."

for _, _, audio in pipeline(text, voice='af_heart'):
    sd.play(audio, samplerate=24000)
    sd.wait()
```

**Schwächen**: Nur Englisch (vorwiegend), kein Stimmenklonen, begrenzte Ausdruckskraft

***

## Fish Speech: Tiefer Einblick

### Architektur

* **VQGAN + Sprachmodell** Architektur
* Trainiert auf 700K+ Stunden Audio
* Stark mehrsprachig mit Unterstützung für asiatische Sprachen

### Installation

```bash
pip install fish-speech

# Oder via Docker
docker run -d \
  --gpus all \
  -p 8080:8080 \
  fishaudio/fish-speech:latest \
  +api_server.workers_count=1
```

### Python‑API

```python
import httpx
import base64

# Via HTTP API
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "Hello from Fish Speech! This sounds very natural.",
            "format": "wav",
            "mp3_bitrate": 128,
            "normalize": True,
        }
    )
    
    with open("fish_output.wav", "wb") as f:
        f.write(response.content)
```

### Stimmenklonen

```python
# Referenz hochladen, Sprach‑ID zurückbekommen
with open("my_voice.wav", "rb") as f:
    response = httpx.post(
        "http://localhost:8080/v1/voices",
        files={"file": f},
        data={"text": "The text spoken in this recording."}
    )
    voice_id = response.json()["id"]

# Geklonnte Stimme verwenden
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Now speaking in the cloned voice.",
        "reference_id": voice_id,
    }
)
```

**Schwächen**: CC BY-NC-SA‑Lizenz (nicht-kommerziell), mehr VRAM für beste Qualität

***

## MeloTTS: Tiefer Einblick

### Architektur

* **VITS2‑basiert** Architektur
* Training mit mehreren englischen Akzenten
* Extrem optimiert für Inferenzgeschwindigkeit

### Akzente und Sprachen

```python
from melo.api import TTS

# Unterstützte Sprachcodes und Akzente
configs = {
    'EN':    ['EN-Default', 'EN-US', 'EN-BR', 'EN-INDIA', 'EN-AU'],
    'ES':    ['ES'],
    'FR':    ['FR'],
    'ZH':    ['ZH'],
    'JP':    ['JP'],
    'KR':    ['KR'],
}

model = TTS(language='EN', device='cuda')
speaker_ids = model.hps.data.spk2id

# Mit britischem Akzent erzeugen
model.tts_to_file(
    "Cheerio! Fancy a spot of tea?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# Mit indischem Akzent erzeugen
model.tts_to_file(
    "Namaste! Welcome to our company.",
    speaker_ids['EN-INDIA'],
    'indian.wav'
)
```

### Batch‑Verarbeitung (sehr schnell)

```python
from melo.api import TTS
import time

model = TTS(language='EN', device='cuda')
sid = model.hps.data.spk2id['EN-Default']

texts = [
    "First sentence to synthesize.",
    "Second sentence goes here.",
    "Third and final sentence.",
]

start = time.time()
for i, text in enumerate(texts):
    model.tts_to_file(text, sid, f'output_{i}.wav')
elapsed = time.time() - start
print(f"Generated {len(texts)} files in {elapsed:.2f}s")
```

**Schwächen**: Kein Stimmenklonen, bei hoher Geschwindigkeit robotisch, begrenzte Ausdruckskraft

***

## Bereitstellung auf Clore.ai

### All‑in‑One TTS‑Server

```yaml
# docker-compose.yml — TTS‑Service mit mehreren Backends
version: "3.8"

services:
  xtts:
    build:
      context: ./xtts
    ports:
      - "5002:5002"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    volumes:
      - ./voices:/app/voices

  kokoro:
    image: ghcr.io/remsky/kokoro-fastapi-cpu:latest
    ports:
      - "8880:8880"
    # Keine GPU benötigt!

  fish-speech:
    image: fishaudio/fish-speech:latest
    ports:
      - "8080:8080"
    command: +api_server.workers_count=2
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
```

### VRAM‑Anforderungen Zusammenfassung

| Modell      | CPU              | 4GB GPU | 8GB GPU | 16GB GPU |
| ----------- | ---------------- | ------- | ------- | -------- |
| XTTS v2     | Langsam          | ✅       | ✅       | ✅        |
| Bark        | Sehr langsam     | ❌       | ✅       | ✅        |
| Kokoro      | **Schnell**      | ✅       | ✅       | ✅        |
| Fish Speech | Mittel           | ✅       | ✅       | ✅        |
| MeloTTS     | **Sehr schnell** | ✅       | ✅       | ✅        |

***

## Integrationsbeispiele

### OpenAI‑kompatible API (als Drop‑in‑Ersatz)

```python
# Viele TTS‑Server bieten OpenAI‑kompatible Endpunkte
# Verwenden Sie Kokoro FastAPI oder ähnliches

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8880/v1",  # Ihr TTS‑Server
    api_key="not-needed"
)

response = client.audio.speech.create(
    model="kokoro",
    voice="af_heart",
    input="Hello world! This uses the OpenAI TTS API format.",
)
response.stream_to_file("output.mp3")
```

### LangChain‑Integration

```python
# Verwendung von TTS mit LangChain für Voice‑Agents
from langchain_community.tools import Tool
from TTS.api import TTS

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

def speak(text: str) -> str:
    tts.tts_to_file(text=text, language="en", file_path="/tmp/response.wav")
    return "/tmp/response.wav"

tts_tool = Tool(
    name="text_to_speech",
    func=speak,
    description="Konvertiere Text in Audiodatei"
)
```

***

## Wann welches verwenden

### Entscheidungsleitfaden

```
Benötigen Sie Stimmenklonen aus kurzem Clip?
  → XTTS v2 (3s Referenz) oder Fish Speech (10s Referenz)

Benötigen Sie Echtzeit/ die schnellste Erzeugung?
  → MeloTTS (CPU‑freundlich) oder Kokoro

Benötigen Sie ausdrucksstarke Sprache (Lachen, Emotion)?
  → Bark (einzigartige Nicht‑Sprach‑Geräusche) oder XTTS v2

Benötigen Sie Chinesisch/Japanisch/Koreanisch?
  → Fish Speech (beste CJK) oder MeloTTS

Nur Englisch, maximale Qualität?
  → Kokoro (bestes Größen-/Qualitätsverhältnis)

Brauchen Sie 17+ Sprachen?
  → XTTS v2

Kommerzielle Nutzung erlaubt?
  → Kokoro (Apache) oder MeloTTS (MIT) oder Bark (MIT)

Nicht-kommerzielle Forschung?
  → Beliebig (XTTS v2 CPML oder Fish Speech CC BY-NC-SA)
```

### Nach Anwendungstyp

| Anwendung               | Beste Wahl               | Warum                                       |
| ----------------------- | ------------------------ | ------------------------------------------- |
| Hörbucherzeugung        | XTTS v2                  | Natürlich, konsistente Stimme               |
| Echtzeit-Chatbot        | MeloTTS oder Kokoro      | Schnellste Inferenz                         |
| Podcast-Automatisierung | XTTS v2 oder Fish Speech | Beste Klonung                               |
| Spielcharaktere         | Bark                     | Ausdrucksstarke, abwechslungsreiche Stimmen |
| Kundendienst            | MeloTTS                  | Skalierbar, schnell                         |
| Barrierefreiheits-Tools | Kokoro                   | Leichtgewichtig, kostenlos                  |
| Sprach-Synchronisation  | Fish Speech              | Beste Klonungsqualität                      |
| Langform-Narration      | XTTS v2                  | Konstante Qualität                          |

***

## Lizenzübersicht

{% hint style="warning" %}
**Lizenzen sind wichtig für kommerzielle Nutzung!** Immer vor dem Einsatz in der Produktion prüfen.
{% endhint %}

| Modell      | Lizenz                     | Kommerziell? | Hinweise                                  |
| ----------- | -------------------------- | ------------ | ----------------------------------------- |
| XTTS v2     | Coqui Public Model License | ❌ Kostenlos  | Erfordert Lizenz für kommerzielle Nutzung |
| Bark        | MIT                        | ✅            | Für alle Nutzungen kostenlos              |
| Kokoro      | Apache 2.0                 | ✅            | Für alle Nutzungen kostenlos              |
| Fish Speech | CC BY-NC-SA 4.0            | ❌            | Nur nicht-kommerziell                     |
| MeloTTS     | MIT                        | ✅            | Für alle Nutzungen kostenlos              |

**Vollständig offen für kommerzielle Nutzung**: Bark, Kokoro, MeloTTS

***

## Kosten auf Clore.ai

```
Kokoro/MeloTTS (CPU oder günstige GPU):
  Günstigster Server bei ~0,05 $/Std → ~36 $/Monat
  Kann 100+ gleichzeitige Anfragen auf der CPU bewältigen

XTTS v2 (RTX 3080):
  ~0,30 $/Std → ~220 $/Monat
  ~500 Anfragen/Stunde Kapazität

Fish Speech (RTX 4090):
  ~0,60 $/Std → ~440 $/Monat  
  ~1000 Anfragen/Stunde Kapazität
```

***

## Nützliche Links

* [Coqui TTS (XTTS)](https://github.com/coqui-ai/TTS) — 35K+ Sterne
* [Bark GitHub](https://github.com/suno-ai/bark) — 38K+ Sterne
* [Kokoro GitHub](https://github.com/hexgrad/kokoro) — 12K+ Sterne
* [Fish Speech GitHub](https://github.com/fishaudio/fish-speech) — 14K+ Sterne
* [MeloTTS GitHub](https://github.com/myshell-ai/MeloTTS) — 15K+ Sterne
* [TTS Arena Rangliste](https://huggingface.co/spaces/TTS-AGI/TTS-Arena)

***

## Zusammenfassung

| Modell          | Verwenden wenn                                                    |
| --------------- | ----------------------------------------------------------------- |
| **XTTS v2**     | Beste Voice-Cloning (3s Referenz), 17 Sprachen, nicht-kommerziell |
| **Bark**        | Ausdrucksstark, Lachen/Effekte, MIT-Lizenz                        |
| **Kokoro**      | Schnell, hochwertige Englisch-Stimmen, Apache-Lizenz              |
| **Fish Speech** | Beste CJK, Produktions-Klonung, nicht-kommerziell                 |
| **MeloTTS**     | Schnellste, Echtzeit, multi-akzentuiertes Englisch, MIT-Lizenz    |

Für die meisten Produktions-Deployments von Clore.ai:

* **Echtzeit-Sprach-Apps** → MeloTTS oder Kokoro (kostenlos, schnell, MIT)
* **Voice-Cloning-Service** → XTTS v2 oder Fish Speech (Lizenz prüfen)
* **Ausdrucksvolle Erzählung** → Bark oder XTTS v2

***

## Clore.ai GPU-Empfehlungen

| Anwendungsfall    | Empfohlene GPU  | Geschätzte Kosten auf Clore.ai |
| ----------------- | --------------- | ------------------------------ |
| Entwicklung/Tests | RTX 3090 (24GB) | \~$0.12/gpu/hr                 |
| Produktion        | RTX 4090 (24GB) | \~$0.70/gpu/hr                 |
| Großmaßstab       | A100 80GB       | \~$1.20/gpu/hr                 |

> 💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf [Clore.ai](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/vergleiche/tts-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.