Audio8-TTS-Realistic: Run the 0.6B Voice Cloning Model Locally in 23 Languages (Setup, Scores, Licence)

Most good voice-cloning models are either huge or locked behind a paid API. Audio8-TTS-Realistic from Edge0 is neither: it has just 0.6B parameters, clones a voice from one short clip, and speaks 23 languages, including Hindi, Arabic and Japanese.

It is free under Apache 2.0, so you can use it in commercial projects. The weights file is only about 1.2 GB, small enough for almost any NVIDIA card.

This guide covers what changed from the Preview model, the full per-language scores, exact install and Python steps, hardware needs, how it compares with Qwen3-TTS, Higgs Audio and Kokoro, and fixes for common problems.

What Is Audio8-TTS-Realistic?

Audio8-TTS-Realistic is a text-to-speech model from Edge0 (Edge0-AI), a team that also publishes the Audio8 speech recognition models. It turns text into speech, either in a default voice or in a voice copied from a short reference recording.

Edge0 released it in late October 2026, with coverage from 29 October. The research paper, “Training a Compact, Strong, and Realistic Text-to-Speech Model” (arXiv 2610.14776), was submitted on 10 October 2026.

Why it matters

• Small: about 601 million parameters in the main model, so it runs on everyday GPUs.
• Multilingual cloning: 23 languages from one model, with a single clip of the target voice.
• Truly open: Apache 2.0 for both code and weights, which many voice models do not offer.
• Focus on realism: it was trained to sound like a real recording, not just to pronounce words correctly.

Note on the name: Edge0’s GitHub and its Hugging Face org page list the model as Audio8-TTS-Realistic-0.6b. A model card with the same scores also appears as Audio8-TTS-Realistic-Air. Use the -0.6b ID in commands, as the official repo does.

What Changed From Audio8 Preview

Realistic builds directly on Audio8-TTS-Preview-0.6b. The big changes are more languages and a new training stage aimed at natural-sounding speech.

The three-stage training recipe

1. Multilingual fine-tuning to teach the 23 languages.
2. GRPO with WER and speaker-similarity rewards, which pushes for correct words and a close voice match.
3. GRPO guided by a “realism critic”, a second model trained to tell generated speech from matched human recordings.

The paper adds an “identity-erasure” objective so the critic judges realism, not the fingerprints of a particular generator. The authors say the last stage improves prosody and speaker similarity without hurting word accuracy.

Preview vs Realistic (vendor-reported)

Error is WER or CER in percent (lower is better). SIM is speaker similarity from 0 to 1 (higher is better). Word accuracy is about the same as Preview; the gain is in voice similarity and language coverage.

Audio8-TTS-Realistic Specs at a Glance

The full Audio8 TTS family

Language-by-Language Quality

Edge0 publishes scores for every language, which is rare and useful. Here is the CV3 test (500 sentences per language), all vendor-reported.

The “Verdict” column is my reading of the numbers, not Edge0’s. Cantonese is supported but only scored in the MiniMax test.

Results look better on the MiniMax test

On the MiniMax set (100 items per language), several weak CV3 languages score much better. Hindi gets 9.2% CER with a high 0.817 similarity, Arabic 2.4% CER, Finnish 5.1% WER and Thai 6.7% CER.

The two tests use different sentences and metrics (WER vs CER), so do not compare them directly. The safe advice: test your own language before you commit to it.

Tip for Hindi users: voice similarity in Hindi is among the highest of any language (0.725 on CV3, 0.817 on MiniMax), but word accuracy varies. Keep sentences short and listen to each output.

Try It Online First

Before installing anything, try the free Audio8 TTS Realistic Playground Space on Hugging Face (Edge0’s Spaces list). It runs on ZeroGPU, so expect a queue and a daily usage limit.

1. Open the Playground from the model page on Hugging Face.
2. Type a sentence in your language.
3. Optionally upload a short clean clip of a voice you have permission to use, plus its exact transcript.
4. Generate and listen. If it sounds right for your language, set it up locally.

Edge0 also hosts a demo page with samples at edge0-ai.github.io/Audio8_TTS/realistic-0.6b/.

How to Install and Run It Locally

You need Python 3.10 or newer and, ideally, an NVIDIA GPU with CUDA. These steps work on Windows (PowerShell), Linux and macOS.

Option 1: the official CLI (simplest)

1. Clone the repo:

   git clone https://github.com/Edge0-AI/Audio8_TTS.git
   cd Audio8_TTS

2. Create a virtual environment:

   python3 -m venv .venv
   source .venv/bin/activate

   On Windows, activate with .venv\Scripts\activate instead.

3. Install the requirements:

   pip install -r requirements.txt

4. Generate your first file (the model downloads on first run):

   python audio8_tts_infer.py --model Edge0/Audio8-TTS-Realistic-0.6b --text "Welcome to Audio8 TTS. It is wonderful to hear from you." --output outputs/realistic.wav

5. Open outputs/realistic.wav to listen.

Option 2: Python with Transformers

Install the packages from the model card:

pip install "torch>=2.5.0" "torchaudio>=2.5.0" "transformers>=4.57.0,<5" "soundfile>=0.12" "safetensors>=0.4"

Then use this script, which follows the structure of the model card example:

import soundfile as sf
import torch
from transformers import AutoModel, AutoProcessor

model_id = "Edge0/Audio8-TTS-Realistic-0.6b"
device = "cuda" if torch.cuda.is_available() else "cpu"
dtype = torch.bfloat16 if device == "cuda" else torch.float32

processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
model = AutoModel.from_pretrained(model_id, trust_remote_code=True, torch_dtype=dtype)
model = model.eval().to(device)

inputs = processor(
    text=["Hello! This voice was made on my own computer."],
    return_tensors="pt",
).to(device)

with torch.inference_mode():
    output = model.generate(
        **inputs,
        max_new_tokens=1024,
        do_sample=True,
        temperature=0.8,
        top_p=0.95,
        top_k=50,
        return_dict_in_generate=True,
    )

waveforms, lengths = model.decode_audio(output.codes)
audio = waveforms[0][: lengths[0]].float().cpu().numpy()
sf.write("output.wav", audio, model.config.codec_sample_rate)

The model card also offers a one-line pipeline: pipeline("text-to-speech", model="Edge0/Audio8-TTS-Realistic-0.6b", trust_remote_code=True).

Warning: trust_remote_code=True runs Python code from the repo. Read the files first and pin a specific revision if you use this in production.

Clone a Voice: Step by Step

1. Record or pick a clean clip of the voice, with no music or background noise. Edge0 gives no exact length; a short clip of one or two clear sentences is a sensible start.
2. Write the exact transcript of that clip, word for word. Mismatches lower stability and similarity.
3. With the CLI, add two flags to the command above:

   python audio8_tts_infer.py --model Edge0/Audio8-TTS-Realistic-0.6b --text "Your new sentence here." --reference-audio reference.wav --reference-text "The exact transcript of the recording." --output outputs/clone.wav

4. In Python, change the processor call to include the reference:

   inputs = processor(
       text=["Your new sentence here."],
       reference_audio=["reference.wav"],
       reference_text=["The exact transcript of the recording."],
       return_tensors="pt",
   ).to(device)

5. Split long scripts into short sentences. The reference audio, its transcript and your new text share one 2,048-position budget.

Tip: For a narration or YouTube voice-over, generate one sentence at a time and join the WAV files in any editor. It is more reliable than one long prompt.

Hardware and Speed

Edge0 does not publish a VRAM figure or speed numbers. It smoke-tested on an NVIDIA H20 with PyTorch 2.8.0 and Transformers 4.57.3, and says throughput and streaming were not benchmarked.

• Weights: about 1.2 GB in bf16, so a 4-8 GB card should hold the model plus working memory (our estimate from the file size; measure it yourself with nvidia-smi).
• CPU: the example code falls back to float32 on CPU. Expect it to be much slower than a GPU.
• Low-end option: the older Preview 0.6B has an ONNX INT4 build, and Preview 0.1B has an ONNX INT8 build for CPU, but neither has the 23 languages.
• Server use: the SGLang Omni adapter (sglang_omni/configs/audio8_tts_0_6b.yaml) adds batching and an OpenAI-style speech API.

If you are planning a GPU, our how much VRAM do I need for AI guide puts small TTS models next to LLM and image needs.

Audio8 vs Other Open TTS Models

Qwen3-TTS and Higgs numbers come from the Audio8 model card, which notes the comparisons use different pipelines. Woof details are from our Underdog Woof guide.

Which one should you pick?

• Pick Audio8-Realistic if you want voice cloning in many languages, on a small GPU, with a licence that allows commercial use.
• Pick a bigger model like Higgs Audio v3 if you have the VRAM and need the best accuracy across languages.
• Pick Kokoro or Woof if you only need a fixed voice and want it to run on a CPU or phone.

Edge0’s own comparison is honest about this: Audio8 is not the best on any single column, but it is very good for its size.

Licence, Consent and Safety

• Apache 2.0: you may use, change and sell work made with the 0.6B models, including in apps. Keep the licence and NOTICE file when you redistribute.
• Preview 0.1B is different: it has its own model licence on Hugging Face, so check it separately.
• Consent: Edge0 asks users to get permission before cloning a voice and to disclose synthetic audio where appropriate.
• Platform rules: YouTube and other platforms ask creators to label realistic AI-generated voices. Follow their disclosure settings.

Warning: Never clone a real person’s voice without their clear permission. Impersonation can break laws on fraud and personality rights in many countries.

Troubleshooting Audio8 TTS

The cloned voice sounds unstable or drifts

The reference clip is noisy or the transcript does not match exactly. Use a cleaner clip and correct every word of --reference-text.

Words are skipped, repeated or the audio stops early

These are known failure modes listed on the model card. Shorten the text, split it into sentences, and generate again; sampling is random, so a second try often fixes it.

Long paragraphs fail or get cut off

You hit the 2,048-position context limit, which the reference and text share. Use a shorter reference clip and feed one or two sentences per call.

Error about trust_remote_code or unknown model type

Add trust_remote_code=True and make sure Transformers is between 4.57.0 and 5.0 ("transformers>=4.57.0,<5").

CUDA out of memory

Close other GPU apps such as ComfyUI or an LLM, or lower max_new_tokens. Our CUDA out of memory fix guide has more options.

My language sounds wrong

Check the language table above. Thai, Finnish, Vietnamese, Arabic and Cantonese are the hardest, and Edge0 warns that quality varies by language.

My Take

This is the kind of small open model I like to see. A 0.6B voice cloner with 23 languages and a real Apache 2.0 licence fills a gap between tiny fixed-voice models and multi-gigabyte ones.

The per-language table is the most useful thing Edge0 published. It tells you upfront that English, Chinese, German and Spanish are strong, and that Thai or Finnish need a careful listen.

The weak spot is evidence on realism. The “realistic” claim rests on the paper’s own critic, and no independent listening test exists yet. Try the Playground in your language first, then pair it with a local LLM from our best Ollama models list for a fully offline voice assistant.

Frequently Asked Questions

Is Audio8-TTS-Realistic free?

Yes. The code and the 0.6B weights are under Apache 2.0, which allows commercial use.

Does Audio8 TTS support Hindi?

Yes. Hindi is one of the 12 languages added in this release. Voice similarity is high, but word accuracy varies, so check each output.

How much VRAM does Audio8-TTS-Realistic need?

Edge0 gives no figure. The bf16 weights are about 1.2 GB, so a 4-8 GB NVIDIA card should be enough (our estimate).

Can it run on CPU?

Yes, the example code switches to float32 on CPU, but it is much slower. For CPU-only use, the Preview ONNX builds are lighter.

How do I clone a voice with Audio8?

Pass a clean reference WAV and its exact transcript with --reference-audio and --reference-text, or as reference_audio and reference_text in Python.

Is there a ComfyUI node for Audio8?

Not from Edge0 at the time of writing. Use the CLI, the Python script or the SGLang Omni API.

What is the difference between Realistic-0.6b and Realistic-Air?

Both cards show the same scores and description. Edge0’s GitHub and org page use the -0.6b name, so use that ID.

Is Audio8 better than ElevenLabs?

No direct test exists. It is free and private on your own PC, but paid services still lead on polish and long-form stability.

Sources

• Hugging Face model card: Edge0/Audio8-TTS-Realistic-0.6b and the Audio8-TTS-Realistic-Air card (specs, per-language scores, code, limits)
• GitHub: Edge0-AI/Audio8_TTS (install, CLI, model family, licences)
• arXiv 2610.14776: “Training a Compact, Strong, and Realistic Text-to-Speech Model” (10 October 2026)
• Hugging Face: Edge0 organisation page (model list, Spaces)
• MarkTechPost: “Edge0 Releases Audio8-TTS-Realistic, a 0.6B Voice Cloning TTS Model” (29 October 2026)
• explainx.ai: Audio8-TTS-Realistic-Air analysis (2 November 2026)