Audar-TTS-Flash

Open, Arabic-first, expressive zero-shot text-to-speech — quantized to run anywhere.

From Arabic to the world.

Audar-TTS-V1-Flash is the smallest, fastest member of the Audar-TTS family — a compact 553M-parameter open-weights speech model that turns text into natural, expressive speech and clones any voice from a 5–15 second reference clip, with no per-speaker fine-tuning. It is Arabic-first (including Gulf/Emirati and other dialects), fully bilingual with English, and this repository ships it as GGUF quantizations so it runs in real time on a single GPU, on CPU, and on edge devices via llama.cpp.

Flash treats speech synthesis as next-token prediction: a language-model backbone predicts discrete audar-codec acoustic tokens, which a lightweight neural codec decodes to 24 kHz audio. There is no phonemizer and no per-language G2P — dialect coverage comes from data, not brittle pronunciation rules — which is a large part of why the model handles Arabic dialects and Arabic⇄English code-switching gracefully.

Open weights — GGUF quantizations plus full bf16 Transformers weights — under the AudarAI Open License v1.0: free for commercial use, redistribution, and modification. See License.

Highlights

🎧 Voice Gallery

Six ready-to-use voices ship with Audar-TTS, free to use. They are synthetic voices created by interpolating multiple speakers — they do not replicate or resemble any real individual. Each sample is a zero-shot clone: the same reference voice speaks a fresh English and Arabic line. (Captions match the audio word-for-word.)

Model summary

The Audar-TTS family

All tiers share one prompt/conditioning protocol, so you can move between them without changing your integration.

GGUF variants

The codec — audar-codec

The backbone emits discrete `` acoustic tokens; a codec turns those into a 24 kHz waveform. These tokens are decoded by audar-codec — Audar's fine-tuned NeuCodec, adapted for Arabic on extensive data.

🙏 Credit & thanks to Neuphonic for open-sourcing NeuCodec. audar-codec builds on their work, and the tokens remain NeuCodec-compatible — so you can decode with NeuCodec directly (as shown below), which makes this release fully open and reproducible.

Local deployment (GGUF)

# pip install llama-cpp-python neucodec soundfile torch huggingface_hub
import re, torch, soundfile as sf
from huggingface_hub import hf_hub_download
from llama_cpp import Llama
from neucodec import NeuCodec   # base NeuCodec (public); audar-codec is the Arabic-tuned companion

# 1) Backbone (GGUF) — CPU by default; set n_gpu_layers=-1 to offload to GPU
gguf = hf_hub_download("audarai/Audar-TTS-V1-Flash", "Audar-TTS-V1-Flash-Q4_K_M.gguf")
llm  = Llama(model_path=gguf, n_ctx=4096, n_gpu_layers=0, verbose=False)

# 2) Codec — encodes the reference clip and decodes the output
codec = NeuCodec.from_pretrained("neuphonic/neucodec").eval()

# 3) Zero-shot reference: a 5-15 s clip (16 kHz mono) + its transcript
ref_codes = codec.encode_code("reference.wav").squeeze().tolist()
ref_text  = "transcript of the reference clip"
ref = "".join(f"" for c in ref_codes)

target = "مرحبا! [whispers] أهلاً وسهلاً بك."
prompt = ("user: Convert the text to speech:"
          f"{ref_text}"
          f"{ref}"
          f"{target}"
          "\nassistant:")

# 4) Generate speech tokens; stop at
tce  = llm.tokenize(b"", add_bos=False, special=True)[0]
toks = llm.tokenize(prompt.encode("utf-8"), add_bos=False, special=True)
ids  = []
for tid in llm.generate(toks, temp=1.0, top_k=40, top_p=0.9, repeat_penalty=1.1):
    if tid == tce or len(ids) >= 2048: break
    ids.append(tid)
text = "".join(llm.detokenize([t], special=True).decode("utf-8", "ignore") for t in ids)

# 5) Decode to 24 kHz audio
codes = [int(x) for x in re.findall(r"", text)]
wav = codec.decode_code(torch.tensor(codes)[None, None, :]).cpu().numpy()[0, 0, :]
sf.write("out.wav", wav, 24000)

Prefer a managed endpoint? The same model is available via the Audar API/SDK (client.tts, model id audar-tts-v1-flash).

Full-precision inference (Transformers)

The full bf16 safetensors weights ship under the transformers/ subfolder — use these for GPU inference or fine-tuning (the GGUF files at the repo root are for lightweight CPU/edge deployment). This is the exact code path used to produce the Voice Gallery demos above, so those samples are reproducible with it.

# pip install transformers torch neucodec soundfile librosa
import re, torch, soundfile as sf, librosa
from transformer