How do I run Chatterbox TTS on a cloud GPU?

Cover: Run Chatterbox TTS on a cloud GPU. Turbo, Multilingual, voice cloning

Deploy a Raw GPU instance, check the GPU with nvidia-smi and nvcc --version, run pip install chatterbox-tts in a Python virtual environment inside tmux, confirm that the PyTorch build it installs supports your card, then load ChatterboxTurboTTS.from_pretrained(device="cuda") in a short Python script, pass a reference clip to clone a voice you have permission to use, and copy the .wav files off before you destroy the instance.

Updated 2026-10-30

This guide follows the Chatterbox README, its pyproject.toml, example scripts and Gradio apps, the chatterbox-tts package page on PyPI and the Chatterbox-Turbo model card, all read on 2026-10-30. The latest chatterbox-tts release on PyPI that day was 0.1.7 (uploaded 2026-03-26). It is for podcasters, video and game creators and developers who want text-to-speech and voice cloning on a rented NVIDIA GPU such as the RTX 5090 or the other cards listed on /pricing.

Only clone voices you own or have clear permission to use. According to the README, every audio file Chatterbox generates carries an imperceptible Perth watermark. The code lives in the GitHub repository resemble-ai/chatterbox, and the model weights are on Hugging Face as ResembleAI/chatterbox-turbo (Turbo), ResembleAI/chatterbox (the original English model and Multilingual) and ResembleAI/chatterbox-nano (Nano). The repository and these three model repositories state the MIT license.

What you need

Item Official value (read 2026-10-30) Source
Install pip install chatterbox-tts, or from source with pip install -e . Chatterbox README
Python >=3.10; developed and tested on Python 3.11 on Debian 11 pyproject.toml, README
PyTorch torch==2.6.0 and torchaudio==2.6.0 on Python 3.10–3.13 pyproject.toml
CUDA runtime of torch 2.6.0 (Linux x86_64) CUDA 12.4 libraries (nvidia-cuda-runtime-cu12==12.4.127) PyPI metadata for torch 2.6.0
Models Chatterbox-Turbo (350M, English), Chatterbox-Multilingual V3 (500M, 23+ languages), Chatterbox (500M, English), Chatterbox-Nano (110M, English) README model table
Hugging Face model IDs ResembleAI/chatterbox-turbo (Turbo), ResembleAI/chatterbox (Chatterbox and Multilingual), ResembleAI/chatterbox-nano (Nano); none is gated REPO_ID in the repository source, Hugging Face model API

The parameter counts are the project’s own figures, not CloudGPU measurements. VRAM need depends on model, precision and workflow; see How much VRAM do I need to run an LLM? for the general method, and the VRAM of each card in the Performance table on /pricing (CloudGPU’s own listing).

The PyPI release 0.1.7 includes the Turbo, Chatterbox and Multilingual classes. The nano=True option and the t3_model="v3" option for Multilingual V3 appear in the repository’s current source but not in the 0.1.7 package files, so install from source (Step 6) if you need Nano or Multilingual V3.

Step 1: Deploy a Raw GPU and connect

On /deploy, pick an NVIDIA GPU and the Raw GPU option (JupyterLab + CUDA pre-installed, root SSH on a dedicated container). Connect over SSH with the host, port and user shown for your instance, or open a terminal in JupyterLab.

Step 2: Check the GPU and tools

nvidia-smi          # GPU name, driver version and the "CUDA Version" the driver supports
nvcc --version      # CUDA toolkit version, if installed
python3 --version   # chatterbox-tts needs 3.10 or newer
which git tmux rsync

Compare the “CUDA Version” in the nvidia-smi header with the CUDA 12.4 libraries that torch 2.6.0 uses (table above). If git, tmux or rsync is missing, install it with apt (you are root on the container):

apt-get update && apt-get install -y git tmux rsync

Step 3: Install chatterbox-tts

Install into a virtual environment, inside tmux so the install keeps going if SSH disconnects:

tmux new -s tts
python3 -m venv ~/tts-env
source ~/tts-env/bin/activate
pip install -U pip
pip install chatterbox-tts

Then check which PyTorch build was installed and whether it sees your GPU:

python -c "import torch; print(torch.__version__, torch.version.cuda, torch.cuda.is_available(), torch.cuda.get_device_name(0)); print(torch.cuda.get_arch_list())"

The line should print True, your GPU name, and an architecture list. Detach from tmux with Ctrl-b then d, and reattach with tmux attach -t tts.

Step 4: Check the PyTorch build on an RTX 5090

CloudGPU’s /pricing listing shows the RTX 5090 32G as a Blackwell card. According to the PyTorch 2.7 release post (2025-04-23), PyTorch 2.7 introduced support for the Blackwell architecture with pre-built CUDA 12.8 wheels. The torch==2.6.0 that chatterbox-tts pins on Python 3.10–3.13 is older than that, so on an RTX 5090 look at the Step 3 output:

  • If sm_120 is in the architecture list, continue with Step 5.
  • If it is not, or a later step fails with a CUDA “no kernel image is available” error, the installed torch build does not include kernels for this card.

Before you change anything, check your Python version inside the virtual environment:

python --version   # the README says Chatterbox was developed and tested on Python 3.11

The repository documents Python 3.11 as the tested version and requires 3.10 or newer; it does not document a Python version that installs a torch build with Blackwell kernels. If sm_120 is missing, deploy a card from an earlier architecture listed on /pricing, such as an RTX 4090 or the A100 80G, and keep the default install from Step 3. If you try something else, check the Step 3 output again before you go on.

For more on matching PyTorch builds to drivers, see How to install a specific PyTorch CUDA version on a cloud GPU.

Step 5: Generate speech with Chatterbox-Turbo

Upload a short reference recording of the voice you have permission to use. The README’s example calls it your_10s_ref_clip.wav:

rsync -avP -e "ssh -p <ssh-port>" ./ref.wav <ssh-user>@<ssh-host>:tts/

Then, on the instance, save this as ~/tts/turbo.py. It follows the README’s Turbo example:

import torchaudio as ta
from chatterbox.tts_turbo import ChatterboxTurboTTS

model = ChatterboxTurboTTS.from_pretrained(device="cuda")

text = "Thanks for calling back [chuckle], do you have a minute to talk about the order?"
wav = model.generate(text, audio_prompt_path="ref.wav")
ta.save("turbo-out.wav", wav, model.sr)

cd ~/tts && source ~/tts-env/bin/activate   # or ~/tts-env314
python turbo.py

The first run downloads the model files from Hugging Face and caches them for later runs on the same instance; to manage that cache yourself, see How to download a Hugging Face model on a cloud GPU. According to the README, Turbo understands paralinguistic tags such as [cough], [laugh] and [chuckle]. The repository’s example_tts_turbo.py also calls model.generate(text) without a reference clip.

Other languages: Chatterbox-Multilingual

import torchaudio as ta
from chatterbox.mtl_tts import ChatterboxMultilingualTTS

model = ChatterboxMultilingualTTS.from_pretrained(device="cuda")
wav = model.generate("Bonjour, comment ça va ?", language_id="fr", audio_prompt_path="ref.wav")
ta.save("fr-out.wav", wav, model.sr)

The README lists 23 language codes, including ar, de, en, es, fr, hi, it, ja, ko, pt and zh. It also says the reference clip should match the language you request; otherwise the output may carry the accent of the clip’s language, and setting cfg_weight=0 helps. With a source install (Step 6), pass t3_model="v3" to from_pretrained to load Multilingual V3.

For the original English model (from chatterbox.tts import ChatterboxTTS), the README’s tips say the defaults exaggeration=0.5 and cfg_weight=0.5 work for most prompts, and that for more expressive speech you can lower cfg_weight to about 0.3 and raise exaggeration to about 0.7.

Step 6: Use the Gradio demo privately (optional)

The repository ships browser demos such as gradio_tts_turbo_app.py. Install from source to get them:

cd ~ && git clone https://github.com/resemble-ai/chatterbox.git
cd chatterbox && source ~/tts-env/bin/activate   # or ~/tts-env314
pip install -e .

gradio_tts_turbo_app.py ends with .launch(share=True). According to the Gradio source, share=True creates a publicly shareable link, so anyone with that link can use your demo on your GPU. To keep it private, turn sharing off and use an SSH tunnel:

sed -i 's/launch(share=True)/launch(share=False)/' gradio_tts_turbo_app.py
python gradio_tts_turbo_app.py

Gradio listens on 127.0.0.1 and, if no port is set, searches for a free port starting at 7860; use the local URL it prints. On your computer:

ssh -N -L 7860:127.0.0.1:7860 -p <ssh-port> <ssh-user>@<ssh-host>

Then open http://127.0.0.1:7860. See How to use SSH port forwarding on a cloud GPU if the tunnel does not connect.

Check your own setup

These are checks to do on your own instance; this page does not assume the result.

  • PyTorch sees the GPU: the Step 3 check prints True and your GPU name (and sm_120 on an RTX 5090).
  • Chatterbox uses the GPU: while turbo.py runs, nvidia-smi in a second SSH session lists a python process on the GPU. See How to check GPU utilization on a cloud GPU.
  • The watermark is present: the README’s extraction script (perth.PerthImplicitWatermarker().get_watermark(...)) prints 1.0 for watermarked audio and 0.0 for none.

If generation runs out of GPU memory

Our own measurements on CloudGPU are coming; until then, verify with the nvidia-smi checks below.

While your script runs, check GPU memory from a second SSH session:

nvidia-smi --query-gpu=name,memory.used,memory.total --format=csv
nvidia-smi   # the process list at the bottom shows each process and the GPU memory it uses

The README describes Turbo as using less compute and VRAM than the earlier Chatterbox models, and Nano as the smallest model. If you hit a CUDA out-of-memory error, close other processes on the GPU (check nvidia-smi), split long text into shorter pieces, try Turbo or Nano, or deploy a card with more VRAM from /pricing.

Before you destroy the instance

According to /terms, data on an instance is permanently deleted when the instance is destroyed. Copy your audio to your computer first:

rsync -avP -e "ssh -p <ssh-port>" <ssh-user>@<ssh-host>:tts/ ./tts-output/

GPU time is billed per minute, rounded up, with a 1-minute minimum, and billing stops when you destroy the instance; see /terms.

FAQ

What Python version does Chatterbox TTS need? The chatterbox-tts package requires Python 3.10 or newer, and the README says it was developed and tested on Python 3.11. On Python 3.10 to 3.13 it pins torch 2.6.0. Run python3 --version inside your environment to confirm which version you are on.

Does Chatterbox TTS work on an RTX 5090? Check before you rely on it. PyTorch added Blackwell support in version 2.7, and chatterbox-tts pins torch 2.6.0 on Python 3.10 to 3.13. Run torch.cuda.get_arch_list() after installing; if sm_120 is missing, deploy an RTX 4090 or the A100 80G from /pricing and keep the default install.

How do I clone a voice with Chatterbox? Pass a short reference recording to generate with audio_prompt_path, for example model.generate(text, audio_prompt_path=“ref.wav”). Only use voices you own or have clear permission to use; every generated file carries a Perth watermark according to the README.

Which Chatterbox model should I use for languages other than English? Use ChatterboxMultilingualTTS with a language_id such as fr, de or zh. The README lists 23 languages and says the reference clip should match the requested language. Multilingual V3 needs a source install and t3_model=“v3”.

Will my audio files stay on the instance after I destroy it? No. Data on an instance is permanently deleted when the instance is destroyed, so copy your output folder to your computer first. Billing is per minute, rounded up, with a 1-minute minimum, and stops when you destroy the instance.

Sources