Comparación de motores TTS

Compara los principales motores de texto a voz de código abierto para desplegar en servidores GPU de Clore.ai.

Texto a voz (TTS) convierte texto escrito en audio de sonido natural. Esta guía compara cinco motores TTS de código abierto líderes: XTTS v2, Bark, Kokoro, Fish Speech y MeloTTS — cubriendo calidad, velocidad, soporte de idiomas y capacidades de clonación de voz.

---

Matriz de decisión rápida

	XTTS v2	Bark	Kokoro	Fish Speech	MeloTTS
Desarrollador	Coqui AI	Suno AI	Hexgrad	Fish Audio	MyShell AI
Calidad	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐
Velocidad	Medio	Lento	Rápido	Rápido	El más rápido
Clonación de voz	✅ (clip de 3 s)	✅ (preajustes de voz)	✅ (limitado)	✅ (clip de 10 s)	❌
Idiomas	17	10+	Inglés	8+	8
VRAM mínima	4GB	8GB	CPU ok	4GB	CPU ok
Licencia	CPML (no comercial)	MIT	Apache 2.0	CC BY-NC-SA	MIT
Estrellas en GitHub	35K+ (Coqui TTS)	38K+	12K+	14K+	15K+

---

Resumen

XTTS v2

XTTS v2 de Coqui es el estándar de oro para TTS de clonación de voz de código abierto. Puede clonar cualquier voz a partir de un clip de audio de 3 segundos con fidelidad excepcional.

Filosofía: Máxima expresividad y calidad de clonación de voz.

from TTS.api import TTS

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

# Clonación de voz cero-shot a partir de referencia de 3 s
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

Bark de Suno es un modelo TTS basado en transformadores que genera habla muy expresiva, incluidos sonidos no verbales: risas, suspiros, música y efectos sonoros.

Filosofía: No solo habla — generación de audio completa.

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 es un modelo TTS ligero y rápido optimizado para inglés. A pesar de su pequeño tamaño (~82M parámetros), ofrece una calidad sorprendentemente alta.

Filosofía: Modelo pequeño, gran calidad, funciona en cualquier lugar.

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',  # pre-built voice
    speed=1.0,
)

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

Fish Speech

Fish Speech de Fish Audio es un TTS de nivel de producción con clonación de voz excepcional a partir de clips cortos. Utiliza una novedosa arquitectura de códec + modelo de lenguaje.

Filosofía: Calidad de producción, inferencia rápida, clonación excelente.

# Fish Speech vía API HTTP
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

MeloTTS de MyShell es un TTS ultra-rápido y multi-acento optimizado para aplicaciones en tiempo real. Funciona eficientemente en CPU y admite múltiples acentos ingleses y lenguas asiáticas.

Filosofía: Velocidad en tiempo real a cualquier escala.

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
)

---

Comparación de calidad

Puntajes de naturalidad (MOS — Mean Opinion Score, 1-5)

Los puntajes MOS son valores aproximados basados en artículos publicados y evaluaciones de la comunidad. La calidad real depende en gran medida del contenido del texto y la configuración de la voz.

Modelo	MOS en inglés	MOS multilingüe	Expresividad
XTTS v2	4.3	4.1	⭐⭐⭐⭐⭐
Bark	3.9	3.7	⭐⭐⭐⭐⭐ (único)
Kokoro	4.2	N/D (solo EN)	⭐⭐⭐
Fish Speech	4.4	4.2	⭐⭐⭐⭐
MeloTTS	3.8	3.6	⭐⭐

Qué hace mejor cada modelo

Modelo	Característica de calidad destacada
XTTS v2	Clonación de voz casi perfecta, rango emocional
Bark	Sonidos no verbales, risas, música, efectos
Kokoro	Mejor relación calidad-tamaño, cadencia natural
Fish Speech	Mejor naturalidad general + precisión de clonación
MeloTTS	Salida consistente y limpia para textos largos

---

Benchmarks de velocidad

Caracteres por segundo (CPU vs GPU)

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

Modelo	Velocidad en CPU	Velocidad en GPU (RTX 3080)	Factor en tiempo real
XTTS v2	~15 caracteres/s	~150 caracteres/s	0.3× (GPU)
Bark	~5 caracteres/s	~40 caracteres/s	0.1× (GPU)
Kokoro	~200 caracteres/s	~800 caracteres/s	5× (GPU)
Fish Speech	~80 caracteres/s	~500 caracteres/s	3× (GPU)
MeloTTS	~500 caracteres/s	~2000 caracteres/s	12× (GPU)

Factor en tiempo real > 1.0 significa más rápido que la velocidad de reproducción

Tiempo para generar 1 minuto de audio

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

Para aplicaciones en tiempo real: MeloTTS y Kokoro son los claros ganadores. Ambos pueden generar habla más rápido que la velocidad de reproducción incluso en CPU.

---

Soporte de idiomas

Idiomas compatibles

Modelo	Idiomas	Notable
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	Inglés (US/UK), japonés (limitado)
Fish Speech	8	EN, ZH, JA, KO, FR, DE, AR, ES
MeloTTS	8	EN (4 acentos), ES, FR, ZH, JA, KO

Notas sobre la calidad por idioma

Modelo	Inglés	Chino	Japonés	Europeo
XTTS v2	Excelente	Bueno	Bueno	Excelente
Bark	Bueno	Aceptable	Aceptable	Bueno
Kokoro	Excelente	❌	Limitado	❌
Fish Speech	Excelente	Mejor	Bueno	Bueno
MeloTTS	Bueno	Bueno	Bueno	Bueno

Para TTS en chino: Fish Speech y MeloTTS son las mejores opciones de código abierto. Ambos manejan tonos y caracteres de manera natural.

Para aplicaciones multilingües: XTTS v2 admite la mayor cantidad de idiomas con calidad consistente en todos ellos.

---

Comparación de clonación de voz

Capacidades de clonación

Modelo	Duración de referencia	Calidad de clonación	Zero-Shot
XTTS v2	3 segundos	⭐⭐⭐⭐⭐	✅
Bark	Solo preajustes de voz	⭐⭐⭐	Parcial
Kokoro	No soportado	❌	❌
Fish Speech	10 segundos	⭐⭐⭐⭐⭐	✅
MeloTTS	No soportado	❌	❌

Clonación de voz XTTS v2

from TTS.api import TTS
import torch

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

# Clonar voz desde referencia (mínimo 3 segundos, ideal 10-30 segundos)
tts.tts_to_file(
    text="""
    Bienvenidos a nuestro podcast. Hoy discutimos el futuro de la IA 
    y su impacto en la sociedad. Soy su anfitrión y estoy emocionado 
    de compartir con ustedes algunos insights fascinantes.
    """,
    speaker_wav="speaker_sample.wav",  # Tu audio de referencia
    language="en",
    file_path="cloned_voice_output.wav"
)

Clonación de voz Fish Speech

# Clonar desde audio de referencia
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

Preajustes de voz de Bark

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

# Bark usa códigos de altavoz predefinidos
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: Análisis profundo

Arquitectura

• VITS + GPT arquitectura híbrida

• Entrenado con más de 16K horas en 17 idiomas

• Mínimo de 3 segundos para clonación zero-shot

Instalación en Clore.ai

pip install TTS
# Versión para GPU
pip install TTS[all]

Despliegue con Docker

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

# server.py — API REST de XTTS v2
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

Debilidades: Licencia CPML (no comercial sin permiso), más lento que Kokoro/MeloTTS

---

Bark: Análisis profundo

Arquitectura

• Transformador estilo GPT para generación de tokens de audio

• Proceso en tres etapas: texto → semántico → tokens gruesos → finos

• Genera tokens reales de códec de audio (EnCodec)

Qué hace único a Bark

Bark es el único TTS de código abierto que genera de forma nativa:

• 🎵 Música de fondo dentro del discurso

• 😂 Risas, suspiros, aclaramiento de garganta

• 🎭 Múltiples hablantes en una generación

• 🌍 Enunciados de idiomas mixtos

Lenguaje de marcado

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

# Tokens especiales para expresividad
text = """
[clears throat] Good morning everyone. [laughs] 
La presentación de hoy cubrirá... 
[sighs deeply] ...en realidad bastante contenido.
[music: upbeat jazz] Let's get started!
"""

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

Instalación

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

Debilidades: Lento (pipeline de 3 etapas), inconsistente entre ejecuciones, sin clonación de voz real

---

Kokoro: Análisis profundo

Arquitectura

• 82M parámetros Modelo basado en StyleTTS2

• Extremadamente pequeño pero sorprendentemente de alta calidad

• Inferencia rápida en CPU y GPU

Voces disponibles

from kokoro import KPipeline

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

# Voces disponibles
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)',
}

# Generar con diferentes voces
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}")

Soporte de streaming

import sounddevice as sd
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')

# Transmitir audio en tiempo real mientras se genera
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()

Debilidades: Solo inglés (principalmente), sin clonación de voz, expresividad limitada

---

Fish Speech: Análisis profundo

Arquitectura

• VQGAN + Modelo de lenguaje arquitectura

• Entrenado con más de 700K horas de audio

• Fuerte multilingüe con soporte para idiomas asiáticos

Instalación

pip install fish-speech

# O vía Docker
docker run -d \
  --gpus all \
  -p 8080:8080 \
  fishaudio/fish-speech:latest \
  +api_server.workers_count=1

API de Python

import httpx
import base64

# Vía API HTTP
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)

Clonación de voz

# Subir referencia, obtener ID de voz
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"]

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

Debilidades: Licencia CC BY-NC-SA (no comercial), mayor VRAM para la mejor calidad

---

MeloTTS: Análisis profundo

Arquitectura

• Basado en VITS2 arquitectura

• Entrenamiento en inglés multi-acento

• Extremadamente optimizado para velocidad de inferencia

Acentos e idiomas

from melo.api import TTS

# Códigos de idioma y acentos soportados
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

# Generar con acento británico
model.tts_to_file(
    "Cheerio! Fancy a spot of tea?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# Generar con acento indio
model.tts_to_file(
    "Namaste! Welcome to our company.",
    speaker_ids['EN-INDIA'],
    'indian.wav'
)

Procesamiento por lotes (Muy rápido)

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

Debilidades: Sin clonación de voz, robótico a alta velocidad, expresividad limitada

---

Despliegue en Clore.ai

Servidor TTS todo en uno

# docker-compose.yml — Servicio TTS con múltiples 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"
    # ¡No se necesita GPU!

  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]

Resumen de requisitos de VRAM

Modelo	CPU	GPU de 4 GB	GPU de 8 GB	GPU de 16 GB
XTTS v2	Lento	✅	✅	✅
Bark	Muy lento	❌	✅	✅
Kokoro	Rápido	✅	✅	✅
Fish Speech	Medio	✅	✅	✅
MeloTTS	Muy rápido	✅	✅	✅

---

Ejemplos de integración

API compatible con OpenAI (para reemplazo directo)

# Muchos servidores TTS ofrecen endpoints compatibles con OpenAI
# Use Kokoro FastAPI o similar

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8880/v1",  # Tu servidor TTS
    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")

Integración con LangChain

# Usando TTS con LangChain para agentes de voz
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="Convertir texto en archivo de audio"
)

---

Cuándo usar cada uno

Guía de decisión

¿Necesitas clonación de voz a partir de un clip corto?
  → XTTS v2 (referencia de 3 s) o Fish Speech (referencia de 10 s)

¿Necesitas generación en tiempo real / más rápida?
  → MeloTTS (amigable con CPU) o Kokoro

¿Necesitas habla expresiva (risa, emoción)?
  → Bark (sonidos no verbales únicos) o XTTS v2

¿Necesitas chino/japonés/coreano?
  → Fish Speech (mejor para CJK) o MeloTTS

Solo inglés, ¿calidad máxima?
  → Kokoro (mejor relación tamaño/calidad)

¿Necesitas más de 17 idiomas?
  → XTTS v2

¿Uso comercial permitido?
  → Kokoro (Apache) o MeloTTS (MIT) o Bark (MIT)

¿Investigación no comercial?
  → Cualquiera (XTTS v2 CPML o Fish Speech CC BY-NC-SA)

Por tipo de aplicación

Aplicación	Mejor opción	Por qué
Generación de audiolibros	XTTS v2	Voz natural y consistente
Chatbot en tiempo real	MeloTTS o Kokoro	Inferencia más rápida
Automatización de podcasts	XTTS v2 o Fish Speech	Mejor clonación
Personajes de juegos	Bark	Voces expresivas y variadas
Atención al cliente	MeloTTS	Escalable y rápido
Herramientas de accesibilidad	Kokoro	Ligero y gratuito
Doblaje de voz	Fish Speech	Mejor calidad de clonación
Narración de larga duración	XTTS v2	Calidad consistente

---

Resumen de licencias

¡La licencia importa para el uso comercial! Revisa siempre antes de desplegar en producción.

Modelo	Licencia	¿Comercial?	Notas
XTTS v2	Coqui Public Model License	❌ Gratis	Requiere licencia para uso comercial
Bark	MIT	✅	Gratis para todo uso
Kokoro	Apache 2.0	✅	Gratis para todo uso
Fish Speech	CC BY-NC-SA 4.0	❌	Solo no comercial
MeloTTS	MIT	✅	Gratis para todo uso

Totalmente abierto para uso comercial: Bark, Kokoro, MeloTTS

---

Costo en Clore.ai

Kokoro/MeloTTS (CPU o GPU económica):
  Servidor más barato a ~$0.05/h → ~$36/mes
  Puede manejar 100+ solicitudes concurrentes en CPU

XTTS v2 (RTX 3080):
  ~$0.30/h → ~$220/mes
  Capacidad de ~500 solicitudes/h

Fish Speech (RTX 4090):
  ~$0.60/h → ~$440/mes  
  Capacidad de ~1000 solicitudes/h

---

Enlaces útiles

• Coqui TTS (XTTS) — 35K+ estrellas

• Bark GitHub — 38K+ estrellas

• Kokoro GitHub — 12K+ estrellas

• Fish Speech GitHub — 14K+ estrellas

• MeloTTS GitHub — 15K+ estrellas

• Tabla de clasificación TTS Arena

---

Resumen

Modelo	Usar cuando
XTTS v2	Mejor clonación de voz (referencia 3 s), 17 idiomas, no comercial
Bark	Expresivo, risas/efectos, licencia MIT
Kokoro	Rápido, alta calidad en inglés, licencia Apache
Fish Speech	Mejor para CJK, clonación en producción, no comercial
MeloTTS	El más rápido, en tiempo real, inglés multiacento, licencia MIT

Para la mayoría de despliegues de Clore.ai en producción:

• Aplicaciones de voz en tiempo real → MeloTTS o Kokoro (gratis, rápido, MIT)

• Servicio de clonación de voz → XTTS v2 o Fish Speech (verificar licencias)

• Narración expresiva → Bark o XTTS v2

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
Producción	RTX 4090 (24GB)	~$0.70/gpu/hr
Gran escala	A100 80GB	~$1.20/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.