---
title: "Installation et utilisation de base de Chatterbox-TTS sur Linux"
description: "Tu veux que ton bot, ton jeu ou même ton script Python parle comme un humain ? Avec Chatterbox-TTS , tu peux transformer du texte en voix naturelle, clonage vocal inclus. Et le meilleur ? Tout ça open-source et sans payer de licence. Mais attention, ce n’est pas magique : il faut un peu de patience (et un fichier audio de toi ou d’un·e ami·e pour commencer). Alors, prêt à donner une voix à tes projets ? C’est parti ! À la fin de ce tuto, tu auras un environnement prêt à générer des voix en anglais, français, chinois… ou même avec ta propre voix (si tu as ton fichier de référence). Tu pourras tester les modèles Turbo (ultra-rapide), Nano (pour les vieux PC) et multilingue. Et oui, ça inclut d"
canonical_url: "https://www.internetcreatif.fr/actualite/installation-et-utilisation-de-base-de-chatterbox-tts-sur-linux/"
markdown_url: "https://www.internetcreatif.fr/actualite/installation-et-utilisation-de-base-de-chatterbox-tts-sur-linux.md"
language: "fr-FR"
author: "internet"
date_published: "2026-09-12T19:20:46+00:00"
date_modified: "2026-09-12T19:57:37+00:00"
content_type: "article"
source_url: "https://github.com/resemble-ai/chatterbox"
source_title: "resemble-ai/chatterbox"
---

# Installation et utilisation de base de Chatterbox-TTS sur Linux

## À retenir

- Tu veux que ton bot, ton jeu ou même ton script Python parle comme un humain ?
- À la fin de ce tuto, tu auras un environnement prêt à générer des voix en anglais, français, chinois… ou même avec ta propre voix (si tu as ton fichier de référence).
- Maintenant que tout est installé, on passe à l’action.
- Vérifie l’existence des fichiers générés : ls *.wav Tu devrais voir test-turbo.wav , test-nano.wav , test-french.wav , etc.
- Maintenant, imagine les possibilités : des bots plus naturels pour tes jeux, des scripts qui parlent comme toi, ou même des projets artistiques avec des voix clonées.
> Comment réussir « Installation et utilisation de base de Chatterbox-TTS sur Linux » sans erreur ?

Tu veux que ton bot, ton jeu ou même ton script Python parle comme un humain ? Avec **Chatterbox-TTS**, tu peux transformer du texte en voix naturelle, clonage vocal inclus. Et le meilleur ? Tout ça open-source et sans payer de licence. Mais attention, ce n’est pas magique : il faut un peu de patience (et un fichier audio de toi ou d’un·e ami·e pour commencer). Alors, prêt à donner une voix à tes projets ? C’est parti !
## 🎯 Résultat attendu : ton PC va cracher des fichiers audio comme "test-turbo.wav" et "test-french.wav"

![Bureau d’étude Linux éclairé par une lumière douce, montrant un terminal en cours d’installation de Chatterbox-TTS avec des logs Python et Git. Une capture audio de 10 secondes s’affiche sur Audacity à côté d’une carte graphique NVIDIA. Un mug de café et des livres sur l’IA complètent le décor technique. ---](https://www.internetcreatif.fr/wp-content/uploads/2026/09/799f3814-b2e1-5ce0-9efa-e3246bb0e11f_image1_0001.jpg)

À la fin de ce tuto, tu auras un environnement prêt à générer des voix en anglais, français, chinois… ou même avec ta propre voix (si tu as ton fichier de référence). Tu pourras tester les modèles Turbo (ultra-rapide), Nano (pour les vieux PC) et multilingue. Et oui, ça inclut des balises comme `[chuckle]` pour que le bot rigole à ta place. **⚠️ Prérequis : vérifie si ton PC est compatible avant de continuer** Avant de plonger, fais un petit check-up avec moi : - **Un système Linux générique** (Ubuntu/Debian, c’est le roi du tuto) – Si tu es sur Windows ou macOS, désolé·e, ce guide est fait pour toi·te.
- **Python 3.10+ installé**. Vérifie avec `python --version`. Sinon, installe-le via ton gestionnaire de paquets (ex: `sudo apt install python3.10`).
- **Une connexion Internet stable** : on va télécharger des gigas de modèles TTS.
- **Un fichier audio de 10 secondes** (ex: `your_10s_ref_clip.wav`) pour le clonage vocal. Tu peux enregistrer ta voix avec un micro ou utiliser un fichier existant. Sinon, les modèles standard fonctionnent sans.
- **Optionnel mais recommandé** : une carte graphique NVIDIA (pour accélérer les calculs) ou de la patience si tu as juste un CPU.

 **🛠️ Installation pas à pas : on clone, on installe, et hop !** Tu vas avoir le choix entre deux méthodes : soit tu clones le dépôt pour modifier le code (pour les geeks), soit tu installes directement via pip (plus simple). Je te montre les deux. **🧪 Option 1 – Crée un environnement "propre" avec Conda** **Ouvre ton terminal** et crée un nouvel environnement Python dédié à Chatterbox. Copie-colle ça : ```
conda create -yn chatterbox python=3.11
conda activate chatterbox
```

 Si tu n’as pas Conda, installe-le d’abord depuis [miniconda.io](https://docs.conda.io/en/latest/miniconda.html). Sinon, saute à la méthode 2. **Clone le dépôt officiel** pour avoir accès au code source (et aux modèles) : ```
git clone https://github.com/resemble-ai/chatterbox.git
cd chatterbox
```

 **Installe en mode "développement"**. Ça permet de tester les modifications sans tout réinstaller à chaque changement : ```
pip install -e .
```

 **🚀 Option 2 – Installe directement avec pip (pour les pressés)** Si tu veux juste utiliser Chatterbox sans toucher au code, cette méthode est plus rapide. Mais attention, tu ne pourras pas modifier les fichiers Python après coup. ```
pip install chatterbox-tts
```

 **✅ Vérifie que tout a bien marché (sinon, on panique ensemble)** **Active ton environnement Conda** (si tu l’as utilisé) et vérifie que Python et les paquets sont là : ```
conda activate chatterbox
pip list | grep chatterbox
```

 Tu devrais voir `chatterbox-tts` dans la liste. Sinon, réessaie l’installation. **Teste les dépendances obligatoires** (PyTorch et torchaudio) : ```
python -c "import torch; import torchaudio; print('OK: PyTorch et torchaudio sont prêts !')"
```

 **Vérifie que le dépôt a bien été cloné** (si tu as utilisé la méthode 1) : ```
ls chatterbox/ | grep -E "tts_turbo.py|mtl_tts.py"
```

 Tu devrais voir des fichiers comme `tts_turbo.py`. Si rien ne s’affiche, relance le clone. **Teste la détection de ta carte GPU (si tu en as une NVIDIA)** : ```
python -c "import torch; print(torch.cuda.is_available())"
```

 Si ça affiche `True`, bravo ! Sinon, ton modèle Turbo sera plus lent (mais le Nano fonctionnera quand même).
## 🎨 Configuration et premier démarrage : fais parler ton PC

![Studio d’enregistrement épuré avec un notebook Jupyter affichant du code Python pour la synthèse vocale multilingue. Un micro de référence et des fichiers WAV générés (*test-turbo.wav*, *test-french.wav*) sont visibles, sous une lumière douce mettant en valeur le matériel technique. ---](https://www.internetcreatif.fr/wp-content/uploads/2026/09/799f3814-b2e1-5ce0-9efa-e3246bb0e11f_image2_0001.jpg)

Maintenant que tout est installé, on passe à l’action. Ouvre un nouveau fichier Python (ou utilise un notebook Jupyter) et colle ces exemples pour générer des fichiers audio. > **💡 Astuce :** Les modèles Turbo sont ultra-rapides, mais ils ont besoin d’une carte graphique. Si tu n’en as pas, utilise `device="cpu"` ou lance le modèle Nano (plus lent mais compatible CPU).

 ```
import torchaudio as ta
import torch
from chatterbox.tts_turbo import ChatterboxTurboTTS

# Charge le modèle Turbo sur la GPU si tu en as une (sinon, ça tombe sur CPU)
model = ChatterboxTurboTts.from_pretrained(device="cuda")  # ou "cpu" / "mps" pour Apple Silicon

# Texte avec des balises paralinguistiques (le bot va rigoler !)
text = "[chuckle] Bonjour, je suis une voix générée par Chatterbox-TTS et j’ai l’impression de parler comme un humain. [sigh]"

# Génère l’audio (remplace "your_10s_ref_clip.wav" par ton fichier ou supprime audio_prompt_path pour une voix standard)
wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav")

# Enregistre le résultat dans un fichier WAV
ta.save("test-turbo.wav", wav, model.sr)

print("🎉 Fichier 'test-turbo.wav' généré ! Va l’écouter avec : ffplay test-turbo.wav")
```

 Et si tu veux tester le modèle Nano (compatible CPU et ultra-léger) : ```
model_nano = ChatterboxTurboTTS.from_pretrained(device="cpu", nano=True)
wav_nano = model_nano.generate(text, audio_prompt_path="your_10s_ref_clip.wav")
ta.save("test-nano.wav", wav_nano, model_nano.sr)
```

 Passons aux langues ! Chatterbox gère 23 langues avec son modèle multilingue. Voici comment faire parler ton PC en français et en chinois : ```
from chatterbox.mtl_tts import ChatterboxMultilingualTTS

# Charge le modèle multilingue (version V3, la plus récente)
multilingual_model = ChatterboxMultilingualTTS.from_pretrained(device="cuda", t3_model="v3")

# Texte en français
french_text = "Bonjour ! Je suis une voix française générée par Chatterbox. Tu veux que je parle d’autre chose ? [laugh]"
wav_french = multilingual_model.generate(french_text, language_id="fr")
ta.save("test-french.wav", wav_french, multilingual_model.sr)

# Texte en chinois
chinese_text = "你好，我是一个中文语音合成器，你想听什么？"
wav_chinese = multilingual_model.generate(chinese_text, language_id="zh")
ta.save("test-chinese.wav", wav_chinese, multilingual_model.sr)
```
## 🔍 Vérifie que tout fonctionne (et écoute les résultats !)

![Coin de salon aménagé en laboratoire de test, avec un ordinateur diffusant des fichiers audio via `ffplay`. Une paire d’écouteurs et une feuille de notes techniques (*CUDA*, *language_id*) sont posées sur une table en bois, éclairée par la lumière naturelle. ---](https://www.internetcreatif.fr/wp-content/uploads/2026/09/799f3814-b2e1-5ce0-9efa-e3246bb0e11f_image3_0001.jpg)

**Vérifie l’existence des fichiers générés** : ```
ls *.wav
```

 Tu devrais voir `test-turbo.wav`, `test-nano.wav`, `test-french.wav`, etc. **Écoute les résultats**. Sous Linux, utilise `ffplay` (installe-le avec `sudo apt install ffmpeg` si besoin) : ```
ffplay test-turbo.wav -nodisp -autoexit
```

 **Teste une voix standard sans clonage** (pour vérifier que le modèle fonctionne même sans fichier de référence) : ```
from chatterbox.tts import ChatterboxTTS
model = ChatterboxTTS.from_pretrained(device="cpu")
wav = model.generate("Hello, this is a standard English voice!")
ta.save("test-english.wav", wav, model.sr)
```

 **🔒 Sécurisation : attention aux fichiers sensibles** Chatterbox est open-source et ne stocke pas tes données, mais quelques précautions s’imposent : - **Ne partage pas ton fichier de référence audio** (`your_10s_ref_clip.wav`) sans y être obligé·e. Si quelqu’un l’a, il peut générer des voix à ton nom.
- **Évite d’utiliser Chatterbox pour des projets illégaux**. La synthèse vocale peut servir à de mauvaises choses (deepfakes, usurpation), mais c’est surtout un outil pour les créateurs de contenu ou les développeurs.
- **Gère tes fichiers audio générés** : supprime-les si tu ne veux pas qu’ils traînent sur ton disque dur.

 **❌ Problèmes fréquents (et comment les résoudre)** **"ModuleNotFoundError: No module named 'chatterbox'"** Solution : Vérifie que tu as bien activé ton environnement Conda (`conda activate chatterbox`) ou réinstalle avec `pip install chatterbox-tts`. Si tu as utilisé la méthode du dépôt, assure-toi d’être dans le bon dossier (`cd chatterbox`). **"CUDA out of memory"** Solution : Change de `device="cuda"` à `device="cpu"`, ou utilise le modèle Nano (`nano=True`). Si tu veux optimiser, ferme d’autres applications gourmandes en GPU. **"Fichier audio manquant : your_10s_ref_clip.wav"** Solution : Crée un fichier WAV de 10 secondes avec ta voix (utilise Audacity ou enregistre-toi avec `arecord -d 10 test.wav`). Sinon, supprime `audio_prompt_path` pour utiliser une voix par défaut. **"Language_id non reconnu"** Solution : Vérifie que le code du language_id est correct (ex: "fr" pour français, "zh" pour chinois). La liste complète des langues supportées est dans la doc officielle. **🔄 Mise à jour et désinstallation** **⬆️ Mets ton Chatterbox à jour** **Si tu as cloné le dépôt** : ```
cd chatterbox
git pull origin master
pip install -e .
```

 **Si tu as installé via pip** : ```
pip install --upgrade chatterbox-tts
```

 **🗑️ Supprime Chatterbox sans laisser de traces** **Si tu as utilisé Conda** : ```
conda deactivate
conda env remove --name chatterbox
```

 **Si tu as installé via pip** : ```
pip uninstall chatterbox-tts
```

 **Supprime le dépôt cloné (si tu l’as utilisé)** : ```
cd ..
rm -rf chatterbox/
```
## Conclusion

![Atelier futuriste avec une projection holographique d’un avatar vocal synthétique et des écrans affichant un script de clonage vocal. Des fichiers audio générés (*project_voice_clone.wav*) et un modèle 3D de réseau neuronal complètent l’ambiance technologique sous éclairage bleuté. ---](https://www.internetcreatif.fr/wp-content/uploads/2026/09/799f3814-b2e1-5ce0-9efa-e3246bb0e11f_image4_0001.jpg)

Félicitations ! Tu viens de donner une voix à ton PC. Maintenant, imagine les possibilités : des bots plus naturels pour tes jeux, des scripts qui parlent comme toi, ou même des projets artistiques avec des voix clonées. Bien sûr, ça reste du synthétique, mais avec Chatterbox, tu es déjà bien plus loin qu’avec un TTS basique. Un dernier conseil : si tu veux aller plus loin, explore les balises paralinguistiques ([sigh], [laugh]) ou le clonage vocal avancé. Et n’hésite pas à partager tes créations sur Twitter avec le hashtag `#ChatterboxTTS` – qui sait ? Peut-être que ton bot deviendra viral. > **🚀 Pro tip :** Si tu veux tester d’autres modèles TTS, jette un œil à [le dépôt officiel](https://github.com/resemble-ai/chatterbox). Et si tu bloques sur une étape, revisite les sections "Problèmes fréquents" ou pose ta question en commentaire (ou sur GitHub).

 À bientôt pour de nouveaux tutos, et surtout… fais parler ton PC ! 🎤💻