Chatterbox voice cloning: clone a voice on your own machine, free — hands-on

ElevenLabs and PlayHT will clone a voice for a monthly fee — we tested them in September. Chatterbox, Resemble AI’s open-source text-to-speech family (resemble-ai/chatterbox, MIT, 27,576 GitHub stars at the 5 November 2026 check), does the same job on your own machine, for free, with no account and no API key. This guide installs it, clones a voice from a 10-second clip, takes the same voice into a second language, and checks the watermark baked into every file it makes. One thing to know before you start: Resemble retired Chatterbox in August 2026 — the code stays public under the MIT license, and it still runs, but there is no support and no new release coming.

• Who: Chatterbox, by Resemble AI (resemble-ai/chatterbox on GitHub). MIT license, covering the code and the model weights.
• What: an open-source text-to-speech family — Turbo (350M parameters, English), Nano (110M, runs on CPU), Multilingual V3 (500M, 23 languages), plus the original 500M English model.
• Scale: 27,576 GitHub stars and 3,707 forks at the 5 November 2026 check; the PyPI package is chatterbox-tts 0.1.7.
• Status: retired research since August 2026 — Resemble no longer maintains it, and the code stays public as an archive under the MIT license.
• Clone: a voice from about 10 seconds of clean audio, with no fine-tuning and no API key. Every generated file carries a PerTh watermark.
• Speed: Nano runs 3x faster than real time on 8 CPU cores, per the README; Turbo is built for low-latency English voice agents.

Why a retired project is still worth an afternoon

Voice cloning used to mean a subscription. In our September test, ElevenLabs vs PlayHT both produced convincing clones \u2014 and both metered every character. Chatterbox is the other end of that deal: an MIT-licensed model family you run on your own hardware, with no account, no API key, and no per-minute bill. The catch is real and worth stating plainly. Resemble AI retired the project in August 2026 and moved to deepfake detection; the repository is an archive now, not a product. But archives run. The code is public, the weights are public, the models still download from Hugging Face on first use, and the last push to the repository landed 4 November 2026. If you can live without support, this is the cheapest way to own a voice clone outright.

What you get for that trade: four models in one package. Turbo (350M parameters) is the fast English model, built for voice agents, with native paralinguistic tags \u2014 [laugh], [chuckle], [cough] \u2014 baked into the text. Nano (110M) shares Turbo\u2019s architecture in a smaller package aimed at CPU and on-device inference. Multilingual V3 (500M) clones a voice across 23 languages. The original 500M English model is still there for creative controls. Every one of them clones from a short clip, with no fine-tuning step.

What you’ll need

Python 3.11 \u2014 the version the README was developed and tested against. A GPU is optional: CUDA on NVIDIA, Metal on Apple Silicon, or plain CPU all work, and step 5 covers the CPU-only path. A clean reference recording of the voice you want to clone, about 10 seconds long, in WAV format \u2014 a quiet room beats a long noisy clip. A few gigabytes of free disk: the models download from Hugging Face the first time you load them. No API keys, no account, no sign-up anywhere.

Step 1: Install Chatterbox from the repository

The PyPI package (chatterbox-tts 0.1.7, released March 2026) installs, but the repository is the current code \u2014 install from there:

git clone https://github.com/resemble-ai/chatterbox.git
cd chatterbox
pip install -e .

That puts the chatterbox package on your path with the Turbo, Nano, and Multilingual modules the README documents. The dependencies are pinned in pyproject.toml, which is the point of the editable install: you get the exact versions the project was tested with. Confirm the import before going further:

python -c "import chatterbox; print('chatterbox ok')"

Step 2: Generate your first line with the built-in voice

Before cloning anything, prove the install works with the built-in voice. This is the README\u2019s Turbo example, and it needs no reference clip:

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

# Load the Turbo model
model = ChatterboxTurboTTS.from_pretrained(device="cuda")

text = "Hi there, Sarah here from MochaFone calling you back [chuckle], have you got one minute to chat about the billing issue?"

wav = model.generate(text)
ta.save("test-turbo.wav", wav, model.sr)

Two things to notice. First, device="cuda" is the README\u2019s example \u2014 on a Mac use "mps", on a machine with no GPU use "cpu"; the call is the same. Second, the [chuckle] in the text is not a typo: Turbo takes paralinguistic tags inline, so the model laughs where the tag sits. The first run downloads the Turbo weights from Hugging Face, so give it a minute; later runs are instant. Play test-turbo.wav \u2014 if you hear clean speech, the whole pipeline works.

Step 3: Clone a voice from a 10-second clip

This is the step the whole guide exists for. Record about 10 seconds of the voice \u2014 your own, or someone who has given you permission \u2014 as a clean WAV file, then pass it as the audio prompt:

wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav")
ta.save("cloned.wav", wav, model.sr)

That is the entire cloning workflow: no training run, no fine-tuning, no waiting. The model reads the speaker\u2019s identity from the clip and renders your text in it. The README\u2019s one quality rule is that the reference clip should match the language you are generating in \u2014 a French clip for French text, an English clip for English. If the clip and the text are in different languages, the output can inherit the clip language\u2019s accent; setting cfg_weight to 0 mitigates that, and step 6 covers the tuning knobs in full.

Step 4: Make the same voice speak another language

Multilingual V3 is the model for this. It is the same 500M size as the original, covers 23 languages \u2014 Arabic, Danish, German, Greek, English, Spanish, Finnish, French, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Dutch, Norwegian, Polish, Portuguese, Russian, Swedish, Swahili, Turkish, and Chinese \u2014 and is the README\u2019s recommended model for one voice across languages:

from chatterbox.mtl_tts import ChatterboxMultilingualTTS

multilingual_model = ChatterboxMultilingualTTS.from_pretrained(device="cuda", t3_model="v3")

french_text = "Bonjour, comment \u00e7a va? Ceci est le mod\u00e8le de synth\u00e8se vocale multilingue Chatterbox, il prend en charge 23 langues."
wav_french = multilingual_model.generate(french_text, language_id="fr")
ta.save("test-french.wav", wav_french, multilingual_model.sr)

Pass t3_model="v3" explicitly \u2014 omitting it loads the legacy V2 checkpoint. The language_id is a two-letter code from the README\u2019s list. Combine this with step 3 by adding audio_prompt_path to the same generate call, and the cloned voice speaks French. Resemble also ships a Single Language Pack of six dedicated finetunes \u2014 Chinese, Latam Spanish, Brazilian Portuguese, Spain Spanish, Portugal Portuguese, and Hindi \u2014 for cases where the general multilingual model is not tight enough on one language.

Step 5: Run it on a CPU with Nano

No GPU? Nano is the model for that machine. It shares Turbo\u2019s architecture at 110M parameters, keeps the same single-step decoder and paralinguistic tags, and the README says it runs 3x faster than real time on 8 CPU cores. It loads through the same class, with one flag:

model = ChatterboxTurboTTS.from_pretrained(device="cpu", nano=True)

wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav")
ta.save("test-nano.wav", wav, model.sr)

Nano is English-only, so this is the step for English narration, voice agents, and on-device work \u2014 not for the multilingual path in step 4. If you are on a laptop with no discrete GPU, this is the configuration to start with; it is also the fastest way to iterate on a clone, since generation stays ahead of real time.

Step 6: Tune the delivery

Two knobs control how the speech sounds, and the README\u2019s defaults \u2014 exaggeration=0.5, cfg_weight=0.5 \u2014 work well for most prompts. Change them when the output sounds wrong rather than by habit:

# Calmer, more deliberate pacing for a fast-speaking reference voice
wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav",
                     cfg_weight=0.3)

# More expressive, dramatic delivery
wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav",
                     cfg_weight=0.3, exaggeration=0.7)

The README\u2019s own guidance: if the reference speaker talks fast, lower cfg_weight to around 0.3 to improve pacing. For expressive or dramatic speech, lower cfg_weight to about 0.3 and raise exaggeration to 0.7 or higher \u2014 but note that higher exaggeration tends to speed speech up, so the lower cfg_weight is what keeps it deliberate. Generate short test lines while tuning; a 10-second sample tells you everything a 10-minute render would.

Step 7: Verify the watermark

Every file Chatterbox generates carries Resemble AI\u2019s PerTh watermark \u2014 an imperceptible neural mark the README says survives MP3 compression, audio editing, and common manipulations, with nearly 100% detection accuracy. The project ships the extraction code, so verify it yourself on a file you just made:

import perth
import librosa

AUDIO_PATH = "cloned.wav"

# Load the watermarked audio
watermarked_audio, sr = librosa.load(AUDIO_PATH, sr=None)

# Initialize watermarker (same as used for embedding)
watermarker = perth.PerthImplicitWatermarker()

# Extract watermark
watermark = watermarker.get_watermark(watermarked_audio, sample_rate=sr)
print(f"Extracted watermark: {watermark}")
# Output: 0.0 (no watermark) or 1.0 (watermarked)

A result of 1.0 means the file is watermarked, as every Chatterbox output should be. This is the honest-label mechanism for the whole workflow: the audio you generate is detectable as synthetic, by design, and there is no supported way to strip it.

What you built, and where it stops

You now have a local voice-cloning setup with no subscription attached: install from the repository, generate with Turbo\u2019s built-in voice, clone from a 10-second clip, take the same voice into any of 23 languages with Multilingual V3, run it on a CPU with Nano, tune the delivery with two knobs, and prove the watermark is there. If you would rather skip the code, VoiceStudio wraps the same local-voice idea in a desktop app \u2014 and if you want to put the voice to work, our weekend voice-agent build is the next step.

The limits are the ones this guide has been honest about all along. The project is retired: no support, no fixes, no new models, and the Hugging Face weights could move or vanish with no notice, so keep a local copy of anything you depend on. The watermark is permanent and detectable, which is a feature for disclosure and a limit if you wanted clean audio. Cloning needs permission \u2014 the README\u2019s disclaimer is blunt about misuse, and the law in several jurisdictions now agrees. And quality follows the reference clip: a noisy 10 seconds gives you a noisy voice, whatever the model. Within those bounds, a 27,576-star MIT project that runs on your own machine is a good deal \u2014 it just comes with no one to call when it breaks.