Vergleich der TTS-Engines

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

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.

---

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.

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.

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.

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.

# 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.

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)

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.

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.

Für Echtzeitanwendungen: MeloTTS und Kokoro sind die klaren Gewinner. Beide können Sprache selbst auf der CPU schneller als die Wiedergabegeschwindigkeit erzeugen.

---

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

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.

---

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

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

# 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

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

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

Docker-Bereitstellung

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

# 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")

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

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

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

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

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

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

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

# 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

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)

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

# 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)

# 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

# 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

Die Lizenz ist für die kommerzielle Nutzung wichtig! Vor dem Einsatz in der Produktion immer prüfen.

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) — 35K+ Sterne

• Bark GitHub — 38K+ Sterne

• Kokoro GitHub — 12K+ Sterne

• Fish Speech GitHub — 14K+ Sterne

• MeloTTS GitHub — 15K+ Sterne

• TTS-Arena-Bestenliste

---

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

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.