Kani-TTS-2 Voice Cloning

Run Kani-TTS-2 — an ultra-efficient 400M parameter text-to-speech model with voice cloning on Clore.ai GPUs

Kani-TTS-2 by nineninesix.ai (released February 15, 2026) is a 400M-parameter open-source text-to-speech model that achieves high-fidelity speech synthesis using only 3GB of VRAM. Built on LiquidAI's LFM2 architecture with NVIDIA NanoCodec, it treats audio as a language — generating natural-sounding speech with zero-shot voice cloning from a short reference audio clip. At under half the size of competing models and a fraction of the compute, Kani-TTS-2 is perfect for real-time conversational AI, audiobook generation, and voice cloning on budget hardware.

HuggingFace: nineninesix/kani-tts-2-en GitHub: nineninesix-ai/kani-tts-2 PyPI: kani-tts-2 License: Apache 2.0

Key Features

• 400M parameters, 3GB VRAM — runs on virtually any modern GPU, including RTX 3060

• Zero-shot voice cloning — clone any voice from a 3–30 second reference audio sample

• Speaker embeddings — WavLM-based 128-dim speaker representations for precise voice control

• Up to 40 seconds of continuous audio — suitable for longer passages and dialogue

• Real-time or faster — RTF ~0.2 on RTX 5080, real-time even on budget GPUs

• Apache 2.0 — fully open for personal and commercial use

• Pretraining framework included — train your own TTS model from scratch on any language

Comparison with Other TTS Models

Model	Parameters	Min VRAM	Voice Cloning	Language	License
Kani-TTS-2	400M	3GB	✅ Zero-shot	English (extensible)	Apache 2.0
Kokoro	82M	2GB	❌ Preset voices	EN, JP, CN	Apache 2.0
Zonos	400M	8GB	✅	Multi	Apache 2.0
ChatTTS	300M	4GB	❌ Random seeds	Chinese, English	AGPL 3.0
Chatterbox	500M	6GB	✅	English	Apache 2.0
XTTS (Coqui)	467M	6GB	✅	Multi	MPL 2.0
F5-TTS	335M	4GB	✅	Multi	CC-BY-NC 4.0

Requirements

Component	Minimum	Recommended
GPU	Any with 3GB VRAM	RTX 3060 or better
VRAM	3GB	6GB
RAM	8GB	16GB
Disk	2GB	5GB
Python	3.9+	3.11+
CUDA	11.8+	12.0+

Clore.ai recommendation: An RTX 3060 ($0.15–0.30/day) is more than enough. Even the cheapest GPU instances on Clore.ai will run Kani-TTS-2 comfortably. For batch processing (audiobooks, datasets), an RTX 4090 ($0.5–2/day) provides excellent throughput.

Installation

# Install the package
pip install kani-tts-2

# IMPORTANT: Install compatible transformers version (required for LFM2 architecture)
pip install -U "transformers==4.56.0"

# Optional: Install soundfile for saving audio
pip install soundfile

Quick Start

Three lines to generate speech:

from kani_tts import KaniTTS

# Initialize with the English model
model = KaniTTS('nineninesix/kani-tts-2-en')

# Generate speech
audio, text = model("Hello! Welcome to Kani TTS 2, the next generation of efficient text-to-speech.")

# Save to file
model.save_audio(audio, "output.wav")

Usage Examples

1. Basic Text-to-Speech

from kani_tts import KaniTTS

model = KaniTTS('nineninesix/kani-tts-2-en')

# Generate with custom parameters
audio, text = model(
    "The quick brown fox jumps over the lazy dog. "
    "This sentence contains every letter of the English alphabet.",
    temperature=0.7,
    top_p=0.9,
    repetition_penalty=1.1
)

model.save_audio(audio, "pangram.wav")
print(f"Generated {len(audio) / 22000:.1f} seconds of audio")

2. Voice Cloning

Clone any voice from a short reference audio sample:

from kani_tts import KaniTTS, SpeakerEmbedder

# Initialize models
model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# Extract speaker embedding from reference audio (3-30 seconds recommended)
speaker_embedding = embedder.embed_audio_file("reference_voice.wav")

# Generate speech in the cloned voice
audio, text = model(
    "This is a demonstration of voice cloning with Kani TTS 2. "
    "The voice you hear should match the reference audio sample.",
    speaker_emb=speaker_embedding
)

model.save_audio(audio, "cloned_output.wav")

3. Batch Generation for Audiobooks

Generate multiple chapters efficiently:

from kani_tts import KaniTTS, SpeakerEmbedder
import soundfile as sf

model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# Use a narrator voice
narrator_emb = embedder.embed_audio_file("narrator_sample.wav")

chapters = [
    "Chapter One. It was a bright cold day in April, and the clocks were striking thirteen.",
    "Chapter Two. The hallway smelt of boiled cabbage and old rag mats.",
    "Chapter Three. Outside, even through the shut window pane, the world looked cold.",
]

for i, chapter_text in enumerate(chapters):
    audio, _ = model(chapter_text, speaker_emb=narrator_emb)
    model.save_audio(audio, f"chapter_{i+1}.wav")
    print(f"Generated chapter {i+1}")

4. OpenAI-Compatible Streaming API

For real-time applications, use the OpenAI-compatible server:

# Clone the server
git clone https://github.com/nineninesix-ai/kani-tts-2-openai-server.git
cd kani-tts-2-openai-server

# Install dependencies
pip install -r requirements.txt

# Start the server
python server.py --model nineninesix/kani-tts-2-en --host 0.0.0.0 --port 8080

Then use it with any OpenAI TTS client:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed")

response = client.audio.speech.create(
    model="kani-tts-2-en",
    voice="default",
    input="Hello from the OpenAI-compatible Kani TTS server!"
)

response.stream_to_file("streamed_output.wav")

Tips for Clore.ai Users

1. This is the cheapest model to run — At 3GB VRAM, Kani-TTS-2 runs on literally any GPU instance on Clore.ai. An RTX 3060 at $0.15/day is more than sufficient for production TTS.

2. Combine with a language model — Rent one GPU instance and run both a small LLM (e.g., Mistral 3 8B) and Kani-TTS-2 simultaneously for a complete voice assistant. They'll share the GPU with room to spare.

3. Pre-compute speaker embeddings — Extract speaker embeddings once and save them. This avoids loading the WavLM embedder model on every request.

4. Use the OpenAI-compatible server — The kani-tts-2-openai-server provides a drop-in replacement for OpenAI's TTS API, making it easy to integrate with existing applications.

5. Train on custom languages — Kani-TTS-2 includes a full pretraining framework (kani-tts-2-pretrain). Fine-tune the model on your own language dataset — it only takes 8× H100s for ~6 hours.

Troubleshooting

Issue	Solution
ImportError: cannot import LFM2	Install the correct transformers version: pip install -U "transformers==4.56.0"
Audio quality is poor / robotic	Increase temperature to 0.8–0.9; ensure reference audio for cloning is clean (no background noise)
Voice cloning doesn't sound like reference	Use 5–15 seconds of clear, single-speaker audio. Avoid music or background noise in the reference
CUDA out of memory	Shouldn't happen with 3GB model — check if other processes are using GPU memory (nvidia-smi)
Audio cuts off mid-sentence	Kani-TTS-2 supports up to ~40 seconds. Split longer texts into sentences and concatenate the outputs
Slow on CPU	GPU inference is strongly recommended. Even a basic GPU is 10–50× faster than CPU

Further Reading

• GitHub — kani-tts-2 — PyPI package, usage docs, advanced examples

• HuggingFace — kani-tts-2-en — English model weights

• Pretraining Framework — Train your own TTS model from scratch

• OpenAI-Compatible Server — Drop-in replacement for OpenAI TTS API

• Speaker Embedding Model — WavLM-based voice embedder

• MarkTechPost Overview — Community coverage