> 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-es/comparaciones/tts-comparison.md).

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

{% hint style="info" %}
**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.
{% endhint %}

***

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

```python
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.

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

```python
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.

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

```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(
    "¡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)

{% hint style="info" %}
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.
{% endhint %}

| 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** |

{% hint style="success" %}
**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.
{% endhint %}

***

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

{% hint style="info" %}
**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.
{% endhint %}

***

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

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

```bash
# 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

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

```bash
pip install TTS
# Versión GPU
pip install TTS[all]
```

### Despliegue con Docker

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

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

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

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

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

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

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

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

```python
# 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

```python
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)

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

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

```python
# 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

```python
# 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

{% hint style="warning" %}
**¡La licencia importa para el uso comercial!** Comprueba siempre antes de desplegar en producción.
{% endhint %}

| 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)](https://github.com/coqui-ai/TTS) — más de 35 mil estrellas
* [GitHub de Bark](https://github.com/suno-ai/bark) — más de 38 mil estrellas
* [GitHub de Kokoro](https://github.com/hexgrad/kokoro) — más de 12 mil estrellas
* [GitHub de Fish Speech](https://github.com/fishaudio/fish-speech) — más de 14 mil estrellas
* [GitHub de MeloTTS](https://github.com/myshell-ai/MeloTTS) — más de 15 mil estrellas
* [Clasificación de TTS Arena](https://huggingface.co/spaces/TTS-AGI/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](https://clore.ai/bare-metal) |

> 💡 Todos los ejemplos de esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

# 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-es/comparaciones/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.