Comparación de motores TTS

Compara los principales motores de texto a voz de código abierto para su despliegue 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, compatibilidad con idiomas y capacidades de clonación de voz.

---

Matriz rápida de decisión

	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+

---

Descripción general

XTTS v2

XTTS v2 de Coqui es el estándar de oro para la síntesis de voz de código abierto con clonación de voz. Puede clonar cualquier voz a partir de un clip de audio de 3 segundos con una 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 zero-shot a partir de una referencia de 3 s
tts.tts_to_file(
    text="Hola, esta es una voz clonada hablando de forma natural.",
    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 altamente expresiva, incluidos sonidos que no son habla: risas, suspiros, música y efectos de sonido.

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] ¡Hola! [clears throat] Esto es 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' = inglés estadounidense

generator = pipeline(
    "The quick brown fox jumps over the lazy dog.",
    voice='af_heart',  # voz preconstruida
    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 una 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, excelente clonación.

# Fish Speech mediante API HTTP
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Hola, esto es Fish Speech generando 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 ultrarrápido y multiacento optimizado para aplicaciones en tiempo real. Funciona eficientemente en CPU y admite múltiples acentos del inglés e idiomas asiáticos.

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(
    "¡Hola, mundo! MeloTTS es muy rápido.",
    speaker_ids['EN-Default'],
    output_path,
    speed=speed
)

---

Comparación de calidad

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

Las puntuaciones 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 de 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	⭐⭐

En qué destaca cada modelo

Modelo	Característica de calidad destacada
XTTS v2	Clonación de voz casi perfecta, rango emocional
Bark	Sonidos no hablados, risas, música, efectos
Kokoro	La 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 caracteres)

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)

Un 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	~20s	~5 s	~2s
Fish Speech	~45 s	~8s	~3s
MeloTTS	~8s	~2s	<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.

---

Compatibilidad con idiomas

Idiomas compatibles

Modelo	Idiomas	Destacado
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 (EE. UU./Reino Unido), 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 del 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 forma natural.

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

---

Comparación de clonación de voz

Capacidades de clonación

Modelo	Longitud de la referencia	Calidad de clonación	Zero-shot
XTTS v2	3 segundos	⭐⭐⭐⭐⭐	✅
Bark	Solo preajustes de voz	⭐⭐⭐	Parcial
Kokoro	No compatible	❌	❌
Fish Speech	10 segundos	⭐⭐⭐⭐⭐	✅
MeloTTS	No compatible	❌	❌

Clonación de voz de 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")

# Clona la voz a partir de una referencia (mínimo 3 segundos, idealmente 10-30 segundos)
tts.tts_to_file(
    text="""
    Bienvenidos a nuestro podcast. Hoy estamos hablando del futuro de la IA 
    y su impacto en la sociedad. Soy su presentador, y me emociona 
    compartir algunas ideas fascinantes con ustedes.
    """,
    speaker_wav="speaker_sample.wav",  # Tu audio de referencia
    language="en",
    file_path="cloned_voice_output.wav"
)

Clonación de voz de Fish Speech

# Clonar a partir de audio de referencia
fish_speech_cli tts \\
  --text "Esta es mi voz clonada diciendo una nueva frase." \\
  --reference-audio speaker_sample.wav \\
  --reference-text "El texto original pronunciado en el audio de referencia." \\
  --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 hablante 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(
    "¡Bienvenidos! [laughs] Esta tecnología es absolutamente fascinante.",
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)

---

XTTS v2: análisis detallado

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 GPU
pip install TTS[all]

Despliegue con Docker

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 — 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 detallado

Arquitectura

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

• Proceso de 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 habla

• 😂 Risas, suspiros, carraspeos

• 🎭 Múltiples hablantes en una sola generación

• 🌍 Enunciados en varios idiomas

Lenguaje de marcado

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

# Tokens especiales para mayor expresividad
text = """
[clears throat] Buenos días a todos. [laughs] 
La presentación de hoy cubrirá... 
[sighs deeply] ...en realidad, bastante terreno.
[music: jazz animado] ¡Comencemos!
"""

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 detallado

Arquitectura

• 82M de 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' = inglés estadounidense, 'b' = británico

# Voces disponibles
voices = {
    'af_heart': 'Femenina estadounidense (cálida)',
    'af_bella': 'Femenina estadounidense (bella)',
    'af_nicole': 'Femenina estadounidense (nicole)',
    'am_michael': 'Masculino estadounidense (michael)',
    'am_fenrir': 'Masculino estadounidense (fenrir)',
    'bf_emma': 'Femenina británica (emma)',
    'bm_george': 'Masculino británico (george)',
}

# Generar con distintas voces
for voice_name, description in voices.items():
    gen = pipeline("Hola, esto es una prueba.", voice=voice_name)
    for _, _, audio in gen:
        print(f"Generado con {description}")

Compatibilidad con streaming

import sounddevice as sd
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')

# Transmitir audio en tiempo real a medida que se genera
text = "Este es un texto muy largo que se transmitirá a medida que se genere, proporcionando una salida de audio de baja latencia."

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 detallado

Arquitectura

• VQGAN + modelo de lenguaje arquitectura

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

• Fuerte multilingüe con compatibilidad con idiomas asiáticos

Instalación

pip install fish-speech

# O mediante 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

# Mediante API HTTP
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "¡Hola desde Fish Speech! Esto suena muy 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 de vuelta un ID de voz
with open("my_voice.wav", "rb") as f:
    response = httpx.post(
        "http://localhost:8080/v1/voices",
        files={"file": f},
        data={"text": "El texto pronunciado en esta grabación."}
    )
    voice_id = response.json()["id"]

# Usar voz clonada
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Ahora hablando con la voz clonada.",
        "reference_id": voice_id,
    }
)

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

---

MeloTTS: análisis detallado

Arquitectura

• basado en VITS2 arquitectura

• Entrenamiento de inglés con múltiples acentos

• Extremadamente optimizado para la velocidad de inferencia

Acentos e idiomas

from melo.api import TTS

# Códigos de idioma y acentos compatibles
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! ¿Te apetece una taza de té?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# Generar con acento indio
model.tts_to_file(
    "¡Namaste! Bienvenidos a nuestra empresa.",
    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 = [
    "Primera frase para sintetizar.",
    "Segunda frase va aquí."
    "Tercera y última oración.",
]

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"Se generaron {len(texts)} archivos en {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
# Usa Kokoro FastAPI o similar

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8880/v1",  # Tu servidor TTS
    api_key="no necesario"
)

response = client.audio.speech.create(
    model="kokoro",
    voice="af_heart",
    input="¡Hola mundo! Esto usa el formato de la API TTS de OpenAI.",
)
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 a audio de voz"
)

---

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 o la más rápida?
  → MeloTTS (compatible con CPU) o Kokoro

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

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

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

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

¿Se permite uso comercial?
  → 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 coherente
Chatbot en tiempo real	MeloTTS o Kokoro	Inferencia más rápida
Automatización de pódcasts	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 formato largo	XTTS v2	Calidad constante

---

Resumen de licencias

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

Modelo	Licencia	¿Uso comercial?	Notas
XTTS v2	Licencia pública de modelo de Coqui	❌ 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 uso 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):
  El servidor más barato cuesta ~$0.05/h → ~$36/mes
  Puede manejar más de 100 solicitudes simultáneas 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) — más de 35 mil estrellas

• GitHub de Bark — más de 38 mil estrellas

• GitHub de Kokoro — más de 12 mil estrellas

• GitHub de Fish Speech — más de 14 mil estrellas

• GitHub de MeloTTS — más de 15 mil estrellas

• Clasificación de TTS Arena

---

Resumen

Modelo	Cuándo usar
XTTS v2	Mejor clonación de voz (referencia de 3 s), 17 idiomas, no comercial
Bark	Expresivo, risas/efectos, licencia MIT
Kokoro	Inglés rápido y de alta calidad, licencia Apache
Fish Speech	Mejor para CJK, clonación para producción, no comercial
MeloTTS	El más rápido, en tiempo real, inglés con múltiples acentos, licencia MIT

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

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

• Servicio de clonación de voz → XTTS v2 o Fish Speech (consulta la licencia)

• Narración expresiva → Bark o XTTS v2

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Producción	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Gran escala	A100 80GB	bare metal

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