> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/vergleiche/tts-comparison.md).

# Vergleich der TTS-Engines

Vergleichen Sie die führenden Open-Source-Text-to-Speech-Engines für den Einsatz auf Clore.ai-GPU-Servern.

{% hint style="info" %}
**Text-to-Speech (TTS)** wandelt geschriebenen Text in natürlich klingende Audiodateien 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 Sprachklonungsfunktionen.
{% 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** |
| **Stimmklonung**    | ✅ (3s-Clip)              | ✅ (Sprachvoreinstellungen) | ✅ (eingeschränkt)  | ✅ (10s-Clip) | ❌                  |
| **Sprachen**        | 17                       | 10+                        | Englisch           | 8+           | 8                  |
| **Min. VRAM**       | 4 GB                     | 8 GB                       | **CPU in Ordnung** | 4 GB         | **CPU in Ordnung** |
| **Lizenz**          | CPML (nicht kommerziell) | MIT                        | Apache 2.0         | CC BY-NC-SA  | MIT                |
| **GitHub-Stars**    | 35K+ (Coqui TTS)         | 38K+                       | 12K+               | 14K+         | 15K+               |

***

## Überblick

### XTTS v2

Coquis XTTS v2 ist der Goldstandard für Open-Source-Voice-Cloning-TTS. Es kann jede Stimme aus einem 3-Sekunden-Audioclip mit außergewöhnlicher Treue klonen.

**Philosophie**: Maximale Ausdrucksstärke und Qualität beim Sprachklonen.

```python
from TTS.api import TTS

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

# Zero-Shot-Sprachklonen aus einer 3s-Referenz
tts.tts_to_file(
    text="Hallo, dies ist eine geklonte Stimme, die natürlich spricht.",
    speaker_wav="reference_voice.wav",
    language="en",
    file_path="output.wav"
)
```

### Bark

Sunos Bark ist ein auf Transformern basierendes TTS-Modell, das hoch ausdrucksstarke Sprache erzeugt, einschließlich Nicht-Sprachlauten: Lachen, Seufzen, Musik und Soundeffekte.

**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(
    [lacht] Hallo! [räuspert sich] Das ist Bark TTS. [seufzt]
)
write_wav("output.wav", SAMPLE_RATE, audio_array)
```

### Kokoro

Kokoro ist ein leichtgewichtiges, schnelles TTS-Modell, optimiert für Englisch. 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' = Amerikanisches Englisch

generator = pipeline(
    "Der flinke braune Fuchs springt über den faulen Hund.",
    voice='af_heart',  # vorgefertigte Stimme
    speed=1.0,
)

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

### Fish Speech

Fish Speech von Fish Audio ist ein TTS-System in Produktionsqualität mit außergewöhnlichem Sprachklonen aus kurzen Clips. Es verwendet eine neuartige Codec- + Sprachmodell-Architektur.

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

```python
# Fish Speech über HTTP-API
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Hallo, hier erzeugt Fish Speech Audio.",
        "reference_id": "your-voice-id",
        "format": "wav",
    }
)

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

### MeloTTS

MeloTTS von MyShell ist ein ultraschnelles, mehrakzentiges TTS, optimiert für Echtzeitanwendungen. Es läuft effizient auf der CPU und unterstützt mehrere englische Akzente sowie asiatische Sprachen.

**Philosophie**: Echtzeitgeschwindigkeit in jeder Größenordnung.

```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(
    "Hallo Welt! MeloTTS ist sehr schnell.",
    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 Werte auf Basis veröffentlichter Arbeiten und Community-Bewertungen. Die tatsächliche Qualität hängt stark vom Textinhalt und der Sprachkonfiguration ab.
{% endhint %}

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

### Worin jedes Modell am besten ist

| Modell      | Herausragendes Qualitätsmerkmal                               |
| ----------- | ------------------------------------------------------------- |
| XTTS v2     | Nahezu perfektes Sprachklonen, emotionaler Spielraum          |
| Bark        | Nicht-sprachliche Laute, Lachen, Musik, Effekte               |
| Kokoro      | Bestes Verhältnis von Qualität zu Größe, natürlicher Rhythmus |
| Fish Speech | Beste allgemeine Natürlichkeit + Klonungsgenauigkeit          |
| MeloTTS     | Konsistente, saubere Ausgabe für lange Texte                  |

***

## Geschwindigkeits-Benchmarks

### Zeichen pro Sekunde (CPU vs. GPU)

Test: "Der flinke braune Fuchs springt über den faulen Hund. Wie geht es dir heute?" (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)**  |

*Ein Real-Time-Faktor > 1,0 bedeutet schneller als die Wiedergabegeschwindigkeit*

### Zeit zum Erzeugen von 1 Minute Audio

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

{% hint style="success" %}
**Für Echtzeitanwendungen**: MeloTTS und Kokoro sind die klaren Gewinner. Beide können Sprache selbst auf der CPU schneller als die Wiedergabegeschwindigkeit erzeugen.
{% 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                                 |

### Hinweise zur Sprachqualität

| Modell      | Englisch     | Chinesisch    | Japanisch | Europäisch   |
| ----------- | ------------ | ------------- | --------- | ------------ |
| XTTS v2     | Hervorragend | Gut           | Gut       | Hervorragend |
| Bark        | Gut          | Gut           | Gut       | Gut          |
| Kokoro      | Hervorragend | ❌             | Begrenzt  | ❌            |
| Fish Speech | Hervorragend | **Am besten** | Gut       | Gut          |
| MeloTTS     | Gut          | Gut           | Gut       | Gut          |

{% hint style="info" %}
**Für chinesische TTS**: Fish Speech und MeloTTS sind die besten Open-Source-Optionen. Beide behandeln Töne und Zeichen natürlich.

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

***

## Vergleich des Sprachklonens

### Klonungsfähigkeiten

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

### XTTS v2 Sprachklonen

```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 (mindestens 3 Sekunden, ideal 10–30 Sekunden)
tts.tts_to_file(
    text="""
    Willkommen zu unserem Podcast. Heute sprechen wir über die Zukunft der KI 
    und ihre Auswirkungen auf die Gesellschaft. Ich bin Ihr Gastgeber und freue mich darauf, 
    einige faszinierende Einblicke mit Ihnen zu teilen.
    """,
    speaker_wav="speaker_sample.wav",  # Ihr Referenzaudio
    language="en",
    file_path="cloned_voice_output.wav"
)
```

### Fish Speech Sprachklonen

```bash
# Aus Referenzaudio klonen
fish_speech_cli tts \\
  --text "Dies ist meine geklonte Stimme, die einen neuen Satz spricht." \\
  --reference-audio speaker_sample.wav \\
  --reference-text "Der ursprüngliche Text, der im Referenzaudio gesprochen wurde." \\
  --output cloned_output.wav
```

### Bark-Stimmvorgaben

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

# Bark verwendet vordefinierte Sprecher-Codes
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(
    Willkommen! [lacht] Das ist absolut faszinierende Technologie.
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)
```

***

## XTTS v2: Tiefgehende Analyse

### Architektur

* **VITS + GPT** Hybridarchitektur
* Trainiert auf über 16K Stunden in 17 Sprachen
* 3-Sekunden-Mindestdauer für Zero-Shot-Klonen

### Installation auf Clore.ai

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

### Docker-Bereitstellung

```dockerfile
FROM nvidia/cuda:12.8.1-cudnn-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 Genehmigung), langsamer als Kokoro/MeloTTS

***

## Bark: Tiefgehende Analyse

### Architektur

* **GPT-artiger Transformer** für die Generierung von Audiotokens
* Dreistufiger 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, Seufzen, Räuspern
* 🎭 Mehrere Sprecher in einer einzigen Generierung
* 🌍 Mischsprachige Äußerungen

### Markup-Sprache

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

# Spezielle Tokens für Ausdrucksstärke
text = """
[räuspert sich] Guten Morgen zusammen. [lacht] 
Die heutige Präsentation wird ... 
[seufzt tief] ... eigentlich ziemlich viel Stoff.
[Musik: beschwingter Jazz] Legen wir los!
"""

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), uneinheitlich zwischen Läufen, kein echtes Sprachklonen

***

## Kokoro: Tiefgehende Analyse

### Architektur

* **82M Parameter** Auf StyleTTS2 basierendes Modell
* Extrem klein, aber überraschend hochwertig
* Schnelle Inferenz auf CPU und GPU

### Verfügbare Stimmen

```python
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')  # 'a' = Amerikanisches Englisch, 'b' = Britisch

# Verfügbare Stimmen
voices = {
    'af_heart': 'Amerikanische weibliche Stimme (warm)',
    'af_bella': 'Amerikanische weibliche Stimme (bella)',
    'af_nicole': 'Amerikanische weibliche Stimme (nicole)',
    'am_michael': 'Amerikanische männliche Stimme (michael)',
    'am_fenrir': 'Amerikanische männliche Stimme (fenrir)',
    'bf_emma': 'Britische weibliche Stimme (emma)',
    'bm_george': 'Britische männliche Stimme (george)',
}

# Mit unterschiedlichen Stimmen generieren
for voice_name, description in voices.items():
    gen = pipeline("Hallo, dies ist ein Test.", voice=voice_name)
    for _, _, audio in gen:
        print(f"Generiert mit {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 = "Dies ist ein sehr langer Text, der beim Erzeugen gestreamt wird und eine Audioausgabe mit geringer Latenz bereitstellt."

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

**Schwächen**: hauptsächlich nur Englisch, kein Sprachklonen, begrenzte Ausdrucksstärke

***

## Fish Speech: Tiefgehende Analyse

### Architektur

* **VQGAN + Sprachmodell** Architektur
* Trainiert auf über 700K Stunden Audio
* Stark mehrsprachig mit Unterstützung asiatischer 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

# Über HTTP-API
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "Hallo von Fish Speech! Das klingt sehr natürlich.",
            "format": "wav",
            "mp3_bitrate": 128,
            "normalize": True,
        }
    )
    
    with open("fish_output.wav", "wb") as f:
        f.write(response.content)
```

### Stimmenklonierung

```python
# Referenz hochladen, Voice-ID zurückerhalten
with open("my_voice.wav", "rb") as f:
    response = httpx.post(
        "http://localhost:8080/v1/voices",
        files={"file": f},
        data={"text": "Der in dieser Aufnahme gesprochene Text."}
    )
    voice_id = response.json()["id"]

# Geklonte Stimme verwenden
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Jetzt spreche ich mit der geklonten Stimme.",
        "reference_id": voice_id,
    }
)
```

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

***

## MeloTTS: Tiefgehende Analyse

### Architektur

* **Basierend auf VITS2** Architektur
* Training mit mehreren englischen Akzenten
* Extrem für Inferenzgeschwindigkeit optimiert

### 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 generieren
model.tts_to_file(
    "Cheerio! Lust auf eine Tasse Tee?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# Mit indischem Akzent generieren
model.tts_to_file(
    "Namaste! Willkommen in unserem Unternehmen.",
    speaker_ids['EN-INDIA'],
    'indian.wav'
)
```

### Stapelverarbeitung (sehr schnell)

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

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

texts = [
    "Erster Satz zum Synthesieren.",
    "Zweiter Satz folgt hier."
    "Dritter und letzter Satz.",
]

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"Es wurden {len(texts)} Dateien in {elapsed:.2f}s erzeugt")
```

**Schwächen**: Kein Voice-Cloning, roboterhaft bei hoher Geschwindigkeit, eingeschränkte Ausdruckskraft

***

## Bereitstellung auf Clore.ai

### Alles-in-einem-TTS-Server

```yaml
# docker-compose.yml — TTS-Dienst 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 erforderlich!

  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]
```

### Zusammenfassung der VRAM-Anforderungen

| 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
# Verwende Kokoro FastAPI oder Ähnliches

from openai import OpenAI

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

response = client.audio.speech.create(
    model="kokoro",
    voice="af_heart",
    input="Hallo Welt! Dies verwendet das OpenAI-TTS-API-Format.",
)
response.stream_to_file("output.mp3")
```

### LangChain-Integration

```python
# TTS mit LangChain für Sprachagenten verwenden
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="Text in eine Sprach-Audiodatei umwandeln"
)
```

***

## Wann welches Modell verwenden

### Entscheidungsleitfaden

```
Benötigst du Voice-Cloning aus einem kurzen Clip?
  → XTTS v2 (3s Referenz) oder Fish Speech (10s Referenz)

Benötigst du Echtzeit-/schnellste Generierung?
  → MeloTTS (CPU-freundlich) oder Kokoro

Benötigst du ausdrucksstarke Sprache (Lachen, Emotion)?
  → Bark (einzigartige Nicht-Sprach-Laute) oder XTTS v2

Benötigst du Chinesisch/Japanisch/Koreanisch?
  → Fish Speech (am besten für CJK) oder MeloTTS

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

Benötigst du mehr als 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 Anwendungsart

| Anwendung               | Beste Wahl               | Warum                                       |
| ----------------------- | ------------------------ | ------------------------------------------- |
| Hörbucherstellung       | XTTS v2                  | Natürliche, konsistente Stimme              |
| Echtzeit-Chatbot        | MeloTTS oder Kokoro      | Schnellste Inferenz                         |
| Podcast-Automatisierung | XTTS v2 oder Fish Speech | Bestes Cloning                              |
| Spielcharaktere         | Bark                     | Ausdrucksstarke, abwechslungsreiche Stimmen |
| Kundenservice           | MeloTTS                  | Skalierbar, schnell                         |
| Barrierefreiheits-Tools | Kokoro                   | Leichtgewichtig, kostenlos                  |
| Voice-Dubbing           | Fish Speech              | Beste Cloning-Qualität                      |
| Langform-Narration      | XTTS v2                  | Gleichbleibende Qualität                    |

***

## Lizenzübersicht

{% hint style="warning" %}
**Die Lizenz ist für die kommerzielle Nutzung wichtig!** Vor dem Einsatz in der Produktion immer prüfen.
{% endhint %}

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

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

***

## Kosten auf Clore.ai

```
Kokoro/MeloTTS (CPU oder günstige GPU):
  Günstigster Server ab ca. ~$0,05/Stunde → ca. ~$36/Monat
  Kann über 100 gleichzeitige Anfragen auf CPU verarbeiten

XTTS v2 (RTX 3080):
  ca. ~$0,30/Stunde → ca. ~$220/Monat
  Kapazität für ca. ~500 Anfragen/Stunde

Fish Speech (RTX 4090):
  ca. ~$0,60/Stunde → ca. ~$440/Monat  
  Kapazität für ca. ~1000 Anfragen/Stunde
```

***

## 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-Bestenliste](https://huggingface.co/spaces/TTS-AGI/TTS-Arena)

***

## Zusammenfassung

| Modell          | Verwenden, wenn                                                      |
| --------------- | -------------------------------------------------------------------- |
| **XTTS v2**     | Bestes Voice-Cloning (3s Referenz), 17 Sprachen, nicht-kommerziell   |
| **Bark**        | Ausdrucksstark, Lachen/Effekte, MIT-Lizenz                           |
| **Kokoro**      | Schnell, hochwertiges Englisch, Apache-Lizenz                        |
| **Fish Speech** | Bestes CJK, produktionsreifes Cloning, nicht-kommerziell             |
| **MeloTTS**     | Am schnellsten, Echtzeit, Englisch mit mehreren Akzenten, MIT-Lizenz |

Für die meisten produktiven Clore.ai-Bereitstellungen:

* **Echtzeit-Sprach-Apps** → MeloTTS oder Kokoro (kostenlos, schnell, MIT)
* **Voice-Cloning-Dienst** → XTTS v2 oder Fish Speech (Lizenz prüfen)
* **Ausdrucksstarke Narration** → Bark oder XTTS v2

***

## GPU-Empfehlungen für Clore.ai

| Anwendungsfall     | Empfohlene GPU   | Geschätzte Kosten bei Clore.ai            |
| ------------------ | ---------------- | ----------------------------------------- |
| Entwicklung/Testen | RTX 3090 (24 GB) | 0,07–0,21 $/GPU/Stunde                    |
| Produktion         | RTX 4090 (24 GB) | 0,14–0,42 $/GPU/Stunde                    |
| Großflächig        | A100 80GB        | [Bare Metal](https://clore.ai/bare-metal) |

> 💡 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.