> 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-fr/comparaisons/tts-comparison.md).

# Comparaison des moteurs TTS

Comparez les principaux moteurs de synthèse vocale open source pour un déploiement sur les serveurs GPU Clore.ai.

{% hint style="info" %}
**Synthèse vocale (TTS)** convertit le texte écrit en audio au son naturel. Ce guide compare cinq principaux moteurs TTS open source : XTTS v2, Bark, Kokoro, Fish Speech et MeloTTS — en couvrant la qualité, la vitesse, la prise en charge des langues et les capacités de clonage vocal.
{% endhint %}

***

## Matrice de décision rapide

|                     | XTTS v2               | Bark                    | Kokoro     | Fish Speech      | MeloTTS            |
| ------------------- | --------------------- | ----------------------- | ---------- | ---------------- | ------------------ |
| **Développeur**     | Coqui AI              | Suno AI                 | Hexgrad    | Fish Audio       | MyShell AI         |
| **Qualité**         | ⭐⭐⭐⭐⭐                 | ⭐⭐⭐⭐                    | ⭐⭐⭐⭐       | ⭐⭐⭐⭐⭐            | ⭐⭐⭐                |
| **Vitesse**         | Moyen                 | Lent                    | **Rapide** | **Rapide**       | **Le plus rapide** |
| **Clonage de voix** | ✅ (clip de 3 s)       | ✅ (préréglages de voix) | ✅ (limité) | ✅ (clip de 10 s) | ❌                  |
| **Langues**         | 17                    | 10+                     | Anglais    | 8+               | 8                  |
| **VRAM minimale**   | 4 Go                  | 8 Go                    | **CPU ok** | 4 Go             | **CPU ok**         |
| **Licence**         | CPML (non commercial) | MIT                     | Apache 2.0 | CC BY-NC-SA      | MIT                |
| **Étoiles GitHub**  | 35K+ (Coqui TTS)      | 38K+                    | 12K+       | 14K+             | 15K+               |

***

## Aperçu

### XTTS v2

XTTS v2 de Coqui est la référence absolue pour le clonage vocal TTS open source. Il peut cloner n'importe quelle voix à partir d'un clip audio de 3 secondes avec une fidélité exceptionnelle.

**Philosophie**: expressivité maximale et qualité de clonage vocal.

```python
from TTS.api import TTS

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

# Clonage vocal zero-shot à partir d'une référence de 3 s
tts.tts_to_file(
    text="Bonjour, voici une voix clonée qui parle naturellement.",
    speaker_wav="reference_voice.wav",
    language="en",
    file_path="output.wav"
)
```

### Bark

Bark de Suno est un modèle TTS basé sur un transformer qui génère une parole très expressive, y compris des sons non vocaux : rires, soupirs, musique et effets sonores.

**Philosophie**: pas seulement de la parole — génération audio complète.

```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(
    "[rires] Bonjour ! [se racle la gorge] Voici Bark TTS. [soupirs]"
)
write_wav("output.wav", SAMPLE_RATE, audio_array)
```

### Kokoro

Kokoro est un modèle TTS léger et rapide optimisé pour l'anglais. Malgré sa petite taille (\~82M paramètres), il offre une qualité étonnamment élevée.

**Philosophie**: petit modèle, grande qualité, fonctionne partout.

```python
from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='a')  # 'a' = anglais américain

generator = pipeline(
    "Le renard brun rapide saute par-dessus le chien paresseux.",
    voice='af_heart',  # voix préconstruite
    speed=1.0,
)

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

### Fish Speech

Fish Speech de Fish Audio est un TTS de niveau production avec un clonage vocal exceptionnel à partir de courts extraits. Il utilise une architecture innovante codec + modèle de langage.

**Philosophie**: qualité de production, inférence rapide, excellent clonage.

```python
# Fish Speech via l'API HTTP
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Bonjour, voici Fish Speech qui génère de l'audio.",
        "reference_id": "your-voice-id",
        "format": "wav",
    }
)

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

### MeloTTS

MeloTTS de MyShell est un TTS ultra-rapide, multiaccent, optimisé pour les applications en temps réel. Il fonctionne efficacement sur CPU et prend en charge plusieurs accents anglais et langues asiatiques.

**Philosophie**: vitesse en temps réel à n'importe quelle échelle.

```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(
    "Bonjour le monde ! MeloTTS est très rapide.",
    speaker_ids['EN-Default'],
    output_path,
    speed=speed
)
```

***

## Comparaison de la qualité

### Scores de naturalité (MOS — score d'opinion moyen, 1-5)

{% hint style="info" %}
Les scores MOS sont des valeurs approximatives basées sur des articles publiés et des évaluations de la communauté. La qualité réelle dépend fortement du contenu du texte et de la configuration vocale.
{% endhint %}

| Modèle      | MOS anglais | MOS multilingue          | Expressivité   |
| ----------- | ----------- | ------------------------ | -------------- |
| XTTS v2     | 4.3         | 4.1                      | ⭐⭐⭐⭐⭐          |
| Bark        | 3.9         | 3.7                      | ⭐⭐⭐⭐⭐ (unique) |
| Kokoro      | 4.2         | N/A (anglais uniquement) | ⭐⭐⭐            |
| Fish Speech | 4.4         | 4.2                      | ⭐⭐⭐⭐           |
| MeloTTS     | 3.8         | 3.6                      | ⭐⭐             |

### Ce que chaque modèle fait le mieux

| Modèle      | Fonction de qualité remarquable                     |
| ----------- | --------------------------------------------------- |
| XTTS v2     | Clonage vocal quasi parfait, gamme émotionnelle     |
| Bark        | Sons non vocaux, rires, musique, effets             |
| Kokoro      | Meilleur ratio qualité/taille, cadence naturelle    |
| Fish Speech | Meilleure naturalité globale + précision du clonage |
| MeloTTS     | Sortie cohérente et propre pour les longs textes    |

***

## Benchmarks de vitesse

### Caractères par seconde (CPU vs GPU)

Test : "Le renard brun rapide saute par-dessus le chien paresseux. Comment allez-vous aujourd'hui ?" (60 caractères)

| Modèle      | Vitesse sur CPU        | Vitesse sur GPU (RTX 3080) | Facteur temps réel |
| ----------- | ---------------------- | -------------------------- | ------------------ |
| XTTS v2     | \~15 caractères/s      | \~150 caractères/s         | 0,3× (GPU)         |
| Bark        | \~5 caractères/s       | \~40 caractères/s          | 0,1× (GPU)         |
| Kokoro      | \~200 caractères/s     | \~800 caractères/s         | **5× (GPU)**       |
| Fish Speech | \~80 caractères/s      | \~500 caractères/s         | **3× (GPU)**       |
| MeloTTS     | **\~500 caractères/s** | \~2000 caractères/s        | **12× (GPU)**      |

*Un facteur temps réel > 1,0 signifie plus rapide que la vitesse de lecture*

### Temps nécessaire pour générer 1 minute d'audio

| Modèle      | CPU       | RTX 3080  | A100     |
| ----------- | --------- | --------- | -------- |
| XTTS v2     | \~8 min   | \~30s     | \~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** |

{% hint style="success" %}
**Pour les applications en temps réel**: MeloTTS et Kokoro sont les grands gagnants. Tous deux peuvent générer de la parole plus vite que la vitesse de lecture, même sur CPU.
{% endhint %}

***

## Prise en charge des langues

### Langues prises en charge

| Modèle      | Langues | Remarque                                                           |
| ----------- | ------- | ------------------------------------------------------------------ |
| 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       | Anglais (US/UK), japonais (limité)                                 |
| Fish Speech | 8       | EN, ZH, JA, KO, FR, DE, AR, ES                                     |
| MeloTTS     | 8       | EN (4 accents), ES, FR, ZH, JA, KO                                 |

### Notes sur la qualité linguistique

| Modèle      | Anglais    | Chinois      | Japonais | Européen   |
| ----------- | ---------- | ------------ | -------- | ---------- |
| XTTS v2     | Excellente | Bon          | Bon      | Excellente |
| Bark        | Bon        | Correct      | Correct  | Bon        |
| Kokoro      | Excellente | ❌            | Limité   | ❌          |
| Fish Speech | Excellente | **Meilleur** | Bon      | Bon        |
| MeloTTS     | Bon        | Bon          | Bon      | Bon        |

{% hint style="info" %}
**Pour la synthèse vocale chinoise**: Fish Speech et MeloTTS sont les meilleures options open source. Tous deux gèrent naturellement les tons et les caractères.

**Pour les applications multilingues**: XTTS v2 prend en charge le plus grand nombre de langues, avec une qualité constante dans chacune d'elles.
{% endhint %}

***

## Comparaison du clonage vocal

### Capacités de clonage

| Modèle      | Longueur de la référence       | Qualité du clonage | Zéro-shot |
| ----------- | ------------------------------ | ------------------ | --------- |
| XTTS v2     | **3 secondes**                 | ⭐⭐⭐⭐⭐              | ✅         |
| Bark        | Préréglages de voix uniquement | ⭐⭐⭐                | Partiel   |
| Kokoro      | Non pris en charge             | ❌                  | ❌         |
| Fish Speech | 10 secondes                    | ⭐⭐⭐⭐⭐              | ✅         |
| MeloTTS     | Non pris en charge             | ❌                  | ❌         |

### Clonage vocal XTTS v2

```python
from TTS.api import TTS
import torch

# Charger le modèle
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.to("cuda" if torch.cuda.is_available() else "cpu")

# Cloner la voix à partir d'une référence (minimum 3 secondes, idéalement 10 à 30 secondes)
tts.tts_to_file(
    text="""
    Bienvenue dans notre podcast. Aujourd'hui, nous discutons de l'avenir de l'IA 
    et de son impact sur la société. Je suis votre animateur, et je suis ravi de 
    partager avec vous quelques idées fascinantes.
    """,
    speaker_wav="speaker_sample.wav",  # Votre audio de référence
    language="en",
    file_path="cloned_voice_output.wav"
)
```

### Clonage vocal Fish Speech

```bash
# Cloner à partir de l'audio de référence
fish_speech_cli tts \\
  --text "C'est ma voix clonée qui prononce une nouvelle phrase." \\
  --reference-audio speaker_sample.wav \\
  --reference-text "Le texte original prononcé dans l'audio de référence." \\
  --output cloned_output.wav
```

### Préréglages de voix Bark

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

# Bark utilise des codes de locuteur prédéfinis
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(
    "Bienvenue ! [rires] C'est une technologie absolument fascinante.",
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)
```

***

## XTTS v2 : analyse approfondie

### Architecture

* **VITS + GPT** architecture hybride
* Entraîné sur plus de 16K heures dans 17 langues
* Minimum de 3 secondes pour le clonage zero-shot

### Installation sur Clore.ai

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

### Déploiement 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 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
```

**Faiblesses**: licence CPML (non commerciale sans autorisation), plus lent que Kokoro/MeloTTS

***

## Bark : analyse approfondie

### Architecture

* **Transformer de type GPT** pour la génération de jetons audio
* Processus en trois étapes : texte → sémantique → jetons grossiers → fins
* Génère de véritables jetons de codec audio (EnCodec)

### Ce qui rend Bark unique

Bark est le seul TTS open source qui génère nativement :

* 🎵 Musique de fond dans la parole
* 😂 Rires, soupirs, raclements de gorge
* 🎭 Plusieurs locuteurs en une seule génération
* 🌍 Énoncés multilingues mélangés

### Langage de balisage

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

# Jetons spéciaux pour l'expressivité
text = """
[se racle la gorge] Bonjour à tous. [rires] 
La présentation d'aujourd'hui couvrira... 
[soupire profondément] ...en fait, pas mal de sujets.
[musique : jazz entraînant] Commençons !
"""

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

**Faiblesses**: lent (pipeline en 3 étapes), incohérent d'une exécution à l'autre, pas de véritable clonage vocal

***

## Kokoro : analyse approfondie

### Architecture

* **82M de paramètres** modèle basé sur StyleTTS2
* Extrêmement petit mais étonnamment de haute qualité
* Inférence rapide sur CPU et GPU

### Voix disponibles

```python
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')  # 'a' = anglais américain, 'b' = britannique

# Voix disponibles
voices = {
    'af_heart': 'femme américaine (chaleureuse)',
    'af_bella': 'femme américaine (bella)',
    'af_nicole': 'femme américaine (nicole)',
    'am_michael': 'homme américain (michael)',
    'am_fenrir': 'homme américain (fenrir)',
    'bf_emma': 'femme britannique (emma)',
    'bm_george': 'homme britannique (george)',
}

# Générer avec différentes voix
for voice_name, description in voices.items():
    gen = pipeline("Bonjour, ceci est un test.", voice=voice_name)
    for _, _, audio in gen:
        print(f"Généré avec {description}")
```

### Prise en charge du streaming

```python
import sounddevice as sd
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')

# Diffuser l'audio en temps réel au fur et à mesure de sa génération
text = "Ceci est un texte très long qui sera diffusé au fur et à mesure de sa génération, fournissant une sortie audio à faible latence."

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

**Faiblesses**: uniquement en anglais (principalement), pas de clonage vocal, expressivité limitée

***

## Fish Speech : analyse approfondie

### Architecture

* **VQGAN + modèle de langage** architecture
* Entraîné sur plus de 700K heures d'audio
* Fort en multilingue avec prise en charge des langues asiatiques

### Installation

```bash
pip install fish-speech

# Ou via Docker
docker run -d \
  --gpus all \
  -p 8080:8080 \
  fishaudio/fish-speech:latest \\
  +api_server.workers_count=1
```

### API Python

```python
import httpx
import base64

# Via l'API HTTP
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "Bonjour de Fish Speech ! Cela semble très naturel.",
            "format": "wav",
            "mp3_bitrate": 128,
            "normalize": True,
        }
    )
    
    with open("fish_output.wav", "wb") as f:
        f.write(response.content)
```

### Clonage vocal

```python
# Téléverser la référence, récupérer l'ID de voix
with open("my_voice.wav", "rb") as f:
    response = httpx.post(
        "http://localhost:8080/v1/voices",
        files={"file": f},
        data={"text": "Le texte prononcé dans cet enregistrement."}
    )
    voice_id = response.json()["id"]

# Utiliser la voix clonée
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Parole en cours dans la voix clonée.",
        "reference_id": voice_id,
    }
)
```

**Faiblesses**: licence CC BY-NC-SA (non commerciale), plus de VRAM pour une qualité optimale

***

## MeloTTS : analyse approfondie

### Architecture

* **basé sur VITS2** architecture
* Entraînement anglais multiaccent
* Extrêmement optimisé pour la vitesse d'inférence

### Accents et langues

```python
from melo.api import TTS

# Codes de langue et accents pris en charge
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

# Générer avec un accent britannique
model.tts_to_file(
    "Salut ! Envie d'une petite tasse de thé ?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# Générer avec un accent indien
model.tts_to_file(
    "Namasté ! Bienvenue dans notre entreprise.",
    speaker_ids['EN-INDIA'],
    'indian.wav'
)
```

### Traitement par lots (très rapide)

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

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

texts = [
    "Première phrase à synthétiser.",
    "Deuxième phrase ici.",
    "Troisième et dernière phrase.",
]

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"Généré {len(texts)} fichiers en {elapsed:.2f}s")
```

**Faiblesses**: Pas de clonage de voix, robotique à grande vitesse, expressivité limitée

***

## Déploiement sur Clore.ai

### Serveur TTS tout-en-un

```yaml
# docker-compose.yml — service TTS avec plusieurs 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"
    # Pas besoin de 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]
```

### Résumé des besoins en VRAM

| Modèle      | CPU             | GPU 4 Go | GPU 8 Go | GPU 16 Go |
| ----------- | --------------- | -------- | -------- | --------- |
| XTTS v2     | Lent            | ✅        | ✅        | ✅         |
| Bark        | Très lent       | ❌        | ✅        | ✅         |
| Kokoro      | **Rapide**      | ✅        | ✅        | ✅         |
| Fish Speech | Moyen           | ✅        | ✅        | ✅         |
| MeloTTS     | **Très rapide** | ✅        | ✅        | ✅         |

***

## Exemples d’intégration

### API compatible OpenAI (pour remplacement direct)

```python
# De nombreux serveurs TTS offrent des points de terminaison compatibles OpenAI
# Utiliser Kokoro FastAPI ou similaire

from openai import OpenAI

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

response = client.audio.speech.create(
    model="kokoro",
    voice="af_heart",
    input="Hello world! Ceci utilise le format de l’API TTS d’OpenAI.",
)
response.stream_to_file("output.mp3")
```

### Intégration LangChain

```python
# Utiliser TTS avec LangChain pour des agents vocaux
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 le texte en fichier audio de synthèse vocale"
)
```

***

## Quand utiliser quoi

### Guide de décision

```
Besoin d’un clonage de voix à partir d’un court extrait ?
  → XTTS v2 (référence de 3 s) ou Fish Speech (référence de 10 s)

Besoin d’une génération en temps réel / la plus rapide ?
  → MeloTTS (compatible CPU) ou Kokoro

Besoin d’un discours expressif (rires, émotions) ?
  → Bark (sons non vocaux uniques) ou XTTS v2

Besoin du chinois/japonais/coréen ?
  → Fish Speech (meilleur pour les langues CJK) ou MeloTTS

Anglais uniquement, qualité maximale ?
  → Kokoro (meilleur rapport taille/qualité)

Besoin de 17+ langues ?
  → XTTS v2

Utilisation commerciale autorisée ?
  → Kokoro (Apache) ou MeloTTS (MIT) ou Bark (MIT)

Recherche non commerciale ?
  → N’importe lequel (XTTS v2 CPML ou Fish Speech CC BY-NC-SA)
```

### Par type d’application

| Application                | Meilleur choix         | Pourquoi                     |
| -------------------------- | ---------------------- | ---------------------------- |
| Génération de livres audio | XTTS v2                | Voix naturelle et cohérente  |
| Chatbot en temps réel      | MeloTTS ou Kokoro      | Inférence la plus rapide     |
| Automatisation de podcasts | XTTS v2 ou Fish Speech | Meilleur clonage             |
| Personnages de jeu         | Bark                   | Voix expressives et variées  |
| Service client             | MeloTTS                | Évolutif, rapide             |
| Outils d’accessibilité     | Kokoro                 | Léger, gratuit               |
| Doublage vocal             | Fish Speech            | Meilleure qualité de clonage |
| Narration longue           | XTTS v2                | Qualité constante            |

***

## Résumé des licences

{% hint style="warning" %}
**La licence compte pour l’utilisation commerciale !** Vérifiez toujours avant de déployer en production.
{% endhint %}

| Modèle      | Licence                        | Commercial ? | Remarques                                      |
| ----------- | ------------------------------ | ------------ | ---------------------------------------------- |
| XTTS v2     | Licence de modèle public Coqui | ❌ Gratuit    | Nécessite une licence pour un usage commercial |
| Bark        | MIT                            | ✅            | Gratuit pour toute utilisation                 |
| Kokoro      | Apache 2.0                     | ✅            | Gratuit pour toute utilisation                 |
| Fish Speech | CC BY-NC-SA 4.0                | ❌            | Usage non commercial uniquement                |
| MeloTTS     | MIT                            | ✅            | Gratuit pour toute utilisation                 |

**Entièrement ouvert pour un usage commercial**: Bark, Kokoro, MeloTTS

***

## Coût sur Clore.ai

```
Kokoro/MeloTTS (CPU ou GPU peu coûteux) :
  Serveur le moins cher à ~0,05 $/h → ~36 $/mois
  Peut gérer plus de 100 requêtes simultanées sur CPU

XTTS v2 (RTX 3080) :
  ~0,30 $/h → ~220 $/mois
  Capacité d’environ 500 requêtes/h

Fish Speech (RTX 4090) :
  ~0,60 $/h → ~440 $/mois  
  Capacité d’environ 1000 requêtes/h
```

***

## Liens utiles

* [Coqui TTS (XTTS)](https://github.com/coqui-ai/TTS) — plus de 35K étoiles
* [Bark GitHub](https://github.com/suno-ai/bark) — plus de 38K étoiles
* [Kokoro GitHub](https://github.com/hexgrad/kokoro) — plus de 12K étoiles
* [Fish Speech GitHub](https://github.com/fishaudio/fish-speech) — plus de 14K étoiles
* [MeloTTS GitHub](https://github.com/myshell-ai/MeloTTS) — plus de 15K étoiles
* [Classement TTS Arena](https://huggingface.co/spaces/TTS-AGI/TTS-Arena)

***

## Résumé

| Modèle          | À utiliser quand                                                     |
| --------------- | -------------------------------------------------------------------- |
| **XTTS v2**     | Meilleur clonage vocal (réf. 3 s), 17 langues, non commercial        |
| **Bark**        | Expressif, rires/effets, licence MIT                                 |
| **Kokoro**      | Anglais rapide, de haute qualité, licence Apache                     |
| **Fish Speech** | Meilleur pour les langues CJK, clonage en production, non commercial |
| **MeloTTS**     | Le plus rapide, temps réel, anglais multiaccent, licence MIT         |

Pour la plupart des déploiements Clore.ai en production :

* **Applications vocales en temps réel** → MeloTTS ou Kokoro (gratuit, rapide, MIT)
* **Service de clonage vocal** → XTTS v2 ou Fish Speech (vérifier la licence)
* **Narration expressive** → Bark ou XTTS v2

***

## Recommandations GPU Clore.ai

| Cas d’utilisation  | GPU recommandé   | Coût estimé sur Clore.ai                  |
| ------------------ | ---------------- | ----------------------------------------- |
| Développement/Test | RTX 3090 (24 Go) | 0,07–0,21 $/gpu/h                         |
| Production         | RTX 4090 (24 Go) | 0,14–0,42 $/gpu/h                         |
| Grande échelle     | A100 80 Go       | [bare metal](https://clore.ai/bare-metal) |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.


---

# 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-fr/comparaisons/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.