Audar-TTS-V1-Flash · GGUF

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.)

🎛️ Demo generation settings: temperature = 1.0 · repetition_penalty = 1.1 · top_k = 40 · top_p = 0.9 — tuned for maximum expressiveness ([laughs], [excited], [whispers]…). A low repetition_penalty (≈1.1) is what lets laughter through — a higher value suppresses it. For steadier, more neutral delivery, lower temperature toward 0.6–0.7.

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 <|speech_N|> 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"<|speech_{c}|>" for c in ref_codes)

target = "مرحبا! [whispers] أهلاً وسهلاً بك."
prompt = ("user: Convert the text to speech:"
          f"<|REF_TEXT_START|>{ref_text}<|REF_TEXT_END|>"
          f"<|REF_SPEECH_START|>{ref}<|REF_SPEECH_END|>"
          f"<|TARGET_TEXT_START|>{target}<|TARGET_TEXT_END|>"
          "\nassistant:<|TARGET_CODES_START|>")

# 4) Generate speech tokens; stop at <|TARGET_CODES_END|>
tce  = llm.tokenize(b"<|TARGET_CODES_END|>", 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"<\|speech_(\d+)\|>", 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 transformers import AutoTokenizer, AutoModelForCausalLM
from neucodec import NeuCodec

repo  = "audarai/Audar-TTS-V1-Flash"
tok   = AutoTokenizer.from_pretrained(repo, subfolder="transformers")
model = AutoModelForCausalLM.from_pretrained(repo, subfolder="transformers",
                                             torch_dtype=torch.bfloat16).eval().to("cuda")
codec = NeuCodec.from_pretrained("neuphonic/neucodec").eval().to("cuda")

# Zero-shot reference: a 5-15 s clip (16 kHz mono) + its transcript
wav, _    = librosa.load("reference.wav", sr=16000, mono=True)
ref_codes = codec.encode_code(torch.from_numpy(wav)[None, None, :]).squeeze().tolist()
ref       = "".join(f"<|speech_{c}|>" for c in ref_codes)
ref_text  = "transcript of the reference clip"

target = "Oh, you have to hear this — [excited] we just closed the biggest deal of the entire year!"
prompt = ("user: Convert the text to speech:"
          f"<|REF_TEXT_START|>{ref_text}<|REF_TEXT_END|>"
          f"<|REF_SPEECH_START|>{ref}<|REF_SPEECH_END|>"
          f"<|TARGET_TEXT_START|>{target}<|TARGET_TEXT_END|>"
          "\nassistant:<|TARGET_CODES_START|>")

ids = tok.encode(prompt, add_special_tokens=False, return_tensors="pt").to(model.device)
tce = tok.convert_tokens_to_ids("<|TARGET_CODES_END|>")
out = model.generate(ids, max_new_tokens=1500, do_sample=True,
                     temperature=1.0, top_k=40, top_p=0.9, repetition_penalty=1.1,
                     min_new_tokens=50, eos_token_id=tce, pad_token_id=151643)

text  = tok.decode(out[0, ids.shape[1]:], skip_special_tokens=False)
codes = [int(x) for x in re.findall(r"<\|speech_(\d+)\|>", text)]
wav   = codec.decode_code(torch.tensor(codes)[None, None, :]).cpu().numpy()[0, 0, :]
sf.write("out.wav", wav, 24000)

Voice Gallery demo settings (tested): temperature=1.0, top_k=40, top_p=0.9, repetition_penalty=1.1, min_new_tokens=50, stop at <|TARGET_CODES_END|>. Lower temperature toward 0.6–0.7 for steadier, more neutral delivery. A low repetition_penalty (≈1.1) keeps laughter and other expressive bursts intact.

Expression tags

Insert tags inline in the target text to shape delivery:

[laughs] · [curious] · [excited] · [sighs] · [exhales] · [mischievously] · [whispers] · [sarcastic]

Tags work in both Arabic and English. Use them sparingly for the most natural results.

Intended use & limitations

Intended use. Voice assistants and agents, narration, accessibility, IVR/telephony, and any application that synthesizes Arabic and English speech — in the cloud, on-premises, or offline. Zero-shot cloning is intended for consented voices only.

Limitations.

• Chunk very long inputs at sentence boundaries.
• Multi-word or stacked expression tags are more fragile than single tags.
• As with all neural TTS, rare names, numbers, and code-switch boundaries can be mispronounced.

Evaluation

Audar-TTS is evaluated on an internal cross-provider Arabic TTS benchmark covering intelligibility (resynthesis WER/CER), predicted naturalness (UTMOSv2, SQUIM), speaker similarity, and expression fidelity. We report results with their caveats: predicted-MOS metrics are not calibrated for Arabic, similarity/expression proxies are English-biased, and a formal human MOS/CMOS study is planned, not yet completed. Qualitatively, Audar-TTS is designed to be competitive with leading systems on Arabic intelligibility and expression control, with particular strength on Gulf-dialect speech.

📊 An audited benchmark table will accompany the forthcoming Audar-TTS technical report.

📜 License

Released under the AudarAI Open License, Version 1.0 (full text: AudarAI Open License v1.0 · repo copy). In brief (the license text controls):

• ✅ Commercial use — no revenue cap, user cap, field-of-use limit, or royalty (§2.3, §2.6).
• ✅ Redistribution of the weights and modified versions (§2.4, §5).
• ✅ Modification, fine-tuning, quantization, distillation, merging (§2.2, §2.5).
• 📋 Conditions: include the license with redistributions, keep notices, state modifications, and don't imply official AudarAI endorsement; the license grants no trademark rights (§5, §8).

The backbone is adapted from Qwen2.5 (Apache-2.0); the audar-codec decoder is distributed separately and builds on NeuCodec (see §10, Third-Party Components).

Responsible use

Clone voices only with the speaker's explicit consent. Do not use Audar-TTS to deceive, defraud, or impersonate real people or organizations, and comply with applicable law (§9).

Citation

@misc{audar-tts-flash-2026,
  title  = {Audar-TTS: Arabic-First Expressive Speech Synthesis},
  author = {Audar AI Research Team},
  year   = {2026},
  note   = {Audar-TTS-V1-Flash},
  url    = {https://huggingface.co/audarai/Audar-TTS-V1-Flash}
}

About AudarAI

Leading Arabic-First Multilingual Audio Intelligence

AudarAI starts with Arabic — and expands to the world.

We are building advanced multilingual audio intelligence that helps individuals, enterprises, and governments communicate across languages, cultures, and borders. By combining Arabic-first speech technology with global multilingual AI, AudarAI transforms voice into understanding, interaction, and connection.

Our work spans speech recognition, speech understanding, voice-enabled digital assistants, human-computer interaction, and intelligent audio systems designed for real-world impact. From empowering people to access technology in their native language to helping organizations communicate globally, AudarAI is shaping a future where every voice can be heard, understood, and connected.

Arabic-first. Multilingual by design. Human-centered at heart.

🌐 www.audarai.com · 🤗 Hugging Face · GitHub · contact@audarai.com

© 2026 AUDARAI PTE. LTD. · Licensed under the AudarAI Open License v1.0