Chatterbox Nano — Azerbaijani fine-tune
This repository contains an Azerbaijani fine-tune of ResembleAI/chatterbox-nano. The original Nano architecture is retained; the exported LoRA weights are merged into the model files. This export also includes the expanded tokenizer vocabulary needed for Azerbaijani characters.
Fine-tuning
This checkpoint was fine-tuned for 10 epochs on 257.17 hours of Azerbaijani audio, as recorded in the training manifest.
🎭 Emotions and vocal effects
The Nano tokenizer includes these paralinguistic tags. Put a tag in the text where you want the expression or vocal sound:
| Type | Tags |
|---|---|
| Emotion and delivery | [angry] · [fear] · [surprised] · [whispering] · [advertisement] · [dramatic] · [narration] · [crying] · [happy] · [sarcastic] |
| Vocal effects | [clear throat] · [sigh] · [shush] · [cough] · [groan] · [sniff] · [gasp] · [chuckle] · [laugh] |
Example: Salam! [chuckle] Bu gün sizin üçün gözəl xəbərim var.
These tags are part of the inherited Nano vocabulary. How clearly each one is rendered in Azerbaijani can vary; the presence of a tag does not guarantee a particular acoustic result.
🚧 Chatterbox Nano AZ V2 — Coming Soon
The current checkpoint is an early Azerbaijani adaptation. Azerbaijani pronunciation and naturalness may be less consistent than English, the language the original Nano was built for. AZ V2 is planned to improve Azerbaijani speech quality and tag realization. It is not released yet; this is a roadmap notice, not a measured quality guarantee.
Use this Azerbaijani checkpoint
The exported tokenizer has an expanded vocabulary. Load it with load_nano_model from the training repository; the upstream ChatterboxTurboTTS.from_pretrained(..., nano=True) example below loads the original Nano model and does not restore this fine-tune's vocabulary extension.
Install the loader package from the training repository:
git clone https://github.com/Izahat/chatterbox-nano-training.git
cd chatterbox-nano-training
python -m pip install -e .
Download this model repository with Git LFS, then set MODEL_DIR to its local path. Both examples require a short, clean reference voice recording.
CPU
import torchaudio
from chatterbox_nano_training import load_nano_model
model = load_nano_model("/path/to/chatterbox-nano-AZ", device="cpu")
audio = model.generate(
"Salam! Bu gün hava çox gözəldir.",
audio_prompt_path="/path/to/reference.wav",
)
torchaudio.save("azerbaijani_cpu.wav", audio.cpu(), model.sr)
NVIDIA GPU
Use a CUDA-enabled PyTorch build compatible with the installed NVIDIA driver.
import torch
import torchaudio
from chatterbox_nano_training import load_nano_model
if not torch.cuda.is_available():
raise RuntimeError("CUDA is not available in this PyTorch environment")
model = load_nano_model("/path/to/chatterbox-nano-AZ", device="cuda")
audio = model.generate(
"Azərbaycan dilində səs sintezini yoxlayırıq.",
audio_prompt_path="/path/to/reference.wav",
)
torchaudio.save("azerbaijani_cuda.wav", audio.cpu(), model.sr)
Voice-cloning examples
Each example uses a different voice clip from AZ_TTS_DATA as the reference. The fine-tuned model then speaks a new Azerbaijani sentence in that reference voice. The reference transcript is shown for context; the generated sentence is the text passed to the model.
Speaker 1
Reference transcript: “Tibb elmi insan orqanizminin mürəkkəb quruluşunu öyrənir. Bayram süfrəsində şəkərbura mütləq olmalıdır.”
Generated text: “Salam! Bu gün sizinlə yeni bir hekayə paylaşmaq istəyirəm.”
Speaker 2
Reference transcript: “Oxucu köhnə məktubun müəllifini tanımırdı; kitabxanaçı yazı üslubunu arxivdəki başqa sənədlərlə tutuşdurub ehtiyatlı ehtimalını açıqladı.”
Generated text: “Məncə, bu fikir çox maraqlıdır. Gəlin, birlikdə yoxlayaq.”
Speaker 3
Reference transcript: “Bu layihədə beş min yeddi yüz yetmiş beş addım var, hamısını bitirdikmi? Görünür, hüquq cəmiyyətdə ədalətin təminatçısıdır. Bu qədər insan haradan gəldi!”
Generated text: “Səhər şəhərin küçələri sakit idi, günortaya doğru hər yer canlandı.”
These are demonstration samples, not a standardized voice-cloning or speech-quality evaluation.
Inference speed
The upstream model card reports 3× real time on an 8-core CPU for the original Chatterbox Nano. That published figure is not a benchmark of this Azerbaijani fine-tune; speed depends on hardware and software setup. Benchmark this checkpoint on your own machine before relying on a throughput estimate.
Original Chatterbox Nano model card
The following documentation is from the upstream Chatterbox model card. Its general installation, model-family examples, supported-language list, tips, watermark information, acknowledgements, and citation describe the original Chatterbox project.
Chatterbox TTS
Made with ❤️ byChatterbox is a family of four state-of-the-art, open-source text-to-speech models by Resemble AI.
We are excited to introduce Chatterbox-Nano, our most efficient model yet. Built on a streamlined 110M parameter architecture, Nano delivers high-quality speech on CPU - 3x faster than realtime on 8 cores. We have also distilled the speech-token-to-mel decoder, previously a bottleneck, reducing generation from 10 steps to just one, while retaining high-fidelity audio output.
Paralinguistic tags are now native to both Nano and Turbo models, allowing you to use [cough], [laugh], [chuckle], and more to add distinct realism. While Turbo was built primarily for low-latency voice agents, it excels at narration and creative workflows.
If you like the model but need to scale or tune it for higher accuracy, check out our competitively priced TTS service (link). It delivers reliable performance with ultra-low latency of sub 200ms—ideal for production use in agents, applications, or interactive media.
⚡ Model Zoo
Choose the right model for your application.
| Model | Size | Languages | Key Features | Best For | 🤗 | Examples |
|---|---|---|---|---|---|---|
| Chatterbox-Nano | 110M | English | Paralinguistic Tags ([laugh]), 3x faster than realtime on 8-core CPU |
On-device / CPU inference, tight latency & memory budgets | Demo | Listen |
| Chatterbox-Turbo | 350M | English | Paralinguistic Tags ([laugh]), Lower Compute and VRAM |
Zero-shot voice agents, Production | Demo | Listen |
| Chatterbox-Multilingual (Language list) | 500M | 23+ | Zero-shot cloning, Multiple Languages | Global applications, Localization | Demo | Listen |
| Chatterbox (Tips and Tricks) | 500M | English | CFG & Exaggeration tuning | General zero-shot TTS with creative controls | Demo | Listen |
Installation
pip install chatterbox-tts
Alternatively, you can install from source:
# conda create -yn chatterbox python=3.11
# conda activate chatterbox
git clone https://github.com/resemble-ai/chatterbox.git
cd chatterbox
pip install -e .
We developed and tested Chatterbox on Python 3.11 on Debian 11 OS; the versions of the dependencies are pinned in pyproject.toml to ensure consistency. You can modify the code or dependencies in this installation mode.
Usage
Chatterbox-Nano
Nano shares Turbo's architecture and is loaded through the same ChatterboxTurboTTS class by passing nano=True:
import torchaudio as ta
import torch
from chatterbox.tts_turbo import ChatterboxTurboTTS
# Load the Nano model (also runs on CPU: device="cpu")
model = ChatterboxTurboTTS.from_pretrained(device="cuda", nano=True)
# Generate with Paralinguistic Tags
text = "Hi there, Sarah here from MochaFone calling you back [chuckle], have you got one minute to chat about the billing issue?"
# Generate audio (requires a reference clip for voice cloning)
wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav")
ta.save("test-nano.wav", wav, model.sr)
Chatterbox-Turbo
import torchaudio as ta
import torch
from chatterbox.tts_turbo import ChatterboxTurboTTS
# Load the Turbo model
model = ChatterboxTurboTTS.from_pretrained(device="cuda")
# Generate with Paralinguistic Tags
text = "Hi there, Sarah here from MochaFone calling you back [chuckle], have you got one minute to chat about the billing issue?"
# Generate audio (requires a reference clip for voice cloning)
wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav")
ta.save("test-turbo.wav", wav, model.sr)
Chatterbox and Chatterbox-Multilingual
import torchaudio as ta
from chatterbox.tts import ChatterboxTTS
from chatterbox.mtl_tts import ChatterboxMultilingualTTS
device = "cuda" # or "cpu" / "mps"
# English example
model = ChatterboxTTS.from_pretrained(device=device)
text = "Ezreal and Jinx teamed up with Ahri, Yasuo, and Teemo to take down the enemy's Nexus in an epic late-game pentakill."
wav = model.generate(text)
ta.save("test-english.wav", wav, model.sr)
# Multilingual examples
multilingual_model = ChatterboxMultilingualTTS.from_pretrained(device=device)
french_text = "Bonjour, comment ça va? Ceci est le modèle de synthèse 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)
chinese_text = "你好,今天天气真不错,希望你有一个愉快的周末。"
wav_chinese = multilingual_model.generate(chinese_text, language_id="zh")
ta.save("test-chinese.wav", wav_chinese, multilingual_model.sr)
# If you want to synthesize with a different voice, specify the audio prompt
AUDIO_PROMPT_PATH = "YOUR_FILE.wav"
wav = model.generate(text, audio_prompt_path=AUDIO_PROMPT_PATH)
ta.save("test-2.wav", wav, model.sr)
See example_tts.py, example_tts_turbo.py, example_tts_nano.py, and example_vc.py for more examples.
Supported Languages
Arabic (ar) • Danish (da) • German (de) • Greek (el) • English (en) • Spanish (es) • Finnish (fi) • French (fr) • Hebrew (he) • Hindi (hi) • Italian (it) • Japanese (ja) • Korean (ko) • Malay (ms) • Dutch (nl) • Norwegian (no) • Polish (pl) • Portuguese (pt) • Russian (ru) • Swedish (sv) • Swahili (sw) • Turkish (tr) • Chinese (zh)
Original Chatterbox Tips
General Use (TTS and Voice Agents):
- Ensure that the reference clip matches the specified language tag. Otherwise, language transfer outputs may inherit the accent of the reference clip’s language. To mitigate this, set
cfg_weightto0. - The default settings (
exaggeration=0.5,cfg_weight=0.5) work well for most prompts across all languages. - If the reference speaker has a fast speaking style, lowering
cfg_weightto around0.3can improve pacing.
- Ensure that the reference clip matches the specified language tag. Otherwise, language transfer outputs may inherit the accent of the reference clip’s language. To mitigate this, set
Expressive or Dramatic Speech:
- Try lower
cfg_weightvalues (e.g.~0.3) and increaseexaggerationto around0.7or higher. - Higher
exaggerationtends to speed up speech; reducingcfg_weighthelps compensate with slower, more deliberate pacing.
- Try lower
Built-in PerTh Watermarking for Responsible AI
Every audio file generated by Chatterbox includes Resemble AI's Perth (Perceptual Threshold) Watermarker - imperceptible neural watermarks that survive MP3 compression, audio editing, and common manipulations while maintaining nearly 100% detection accuracy.
Watermark extraction
You can look for the watermark using the following script.
import perth
import librosa
AUDIO_PATH = "YOUR_FILE.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)
Official Discord
👋 Join us on Discord and let's build something awesome together!
Acknowledgements
Citation
If you find this model useful, please consider citing.
@misc{chatterboxtts2025,
author = {{Resemble AI}},
title = {{Chatterbox-TTS}},
year = {2025},
howpublished = {\url{https://github.com/resemble-ai/chatterbox}},
note = {GitHub repository}
}
Disclaimer
Don't use this model to do bad things. Prompts are sourced from freely available data on the internet.