Maya 2 Native: Streaming Text-to-Speech for Indian Languages

Maya 2 Native is an open-weight multilingual text-to-speech (TTS) model for 11 Indian languages and English. It generates 24 kHz speech, streams audio as it is produced, and supports 20 built-in voices, zero-shot voice cloning and cross-lingual speech synthesis. Model weights and inference code are released under Apache-2.0.

Build Hindi, Tamil, Telugu and other Indian-language voice agents, IVR systems, accessibility tools, narration and multilingual applications with a model you can host yourself. The inference engine provides a Python API, an OpenAI-compatible speech endpoint, WebSocket streaming, continuous batching and text normalization for numbers, dates, currency and other written forms.

Supported languages: Assamese, Bengali, English, Gujarati, Hindi, Kannada, Malayalam, Marathi, Odia, Punjabi, Tamil and Telugu.

Listen to speech samples · Run locally · Streaming API · Voice cloning · Benchmarks · Agent reference · Inference code

Watch Maya in action

Watch the video on Google Drive

Open the video · View on Google Drive

VoiceArena benchmark

Ranked #2 for Hindi among real-time TTS models on VoiceArena, with the category set to All. Checked November 3, 2026.

Source: VoiceArena Hindi TTS leaderboard · Filters: Hindi / All / Real-time only · Methodology.

Parentheses reproduce the published rank intervals. Scores and ranks change as samples are added, and overlapping intervals should be considered when comparing nearby models. This result is scoped to the selected Hindi leaderboard. On the same date, the all-model Hindi view places Maya-2-Native at #7 with rank interval 5–10; the #2 position is specifically the real-time-only view. VoiceArena dates the Maya-2-Native entry to July 2026 and does not identify an exact checkpoint revision on the page.

View the supplied leaderboard snapshot

The supplied screenshot shows #2, Elo 1049 ±10, 2,171 samples, and rank interval 2–3. It is preserved here as a snapshot; its capture date is not shown. The table above records the live check on November 3, 2026.

At a glance

For developers: the model is Maya 2 Native. The existing package, Python class, and configuration filename remain maya3, Maya3TTS, and maya3_config.json. Use the identifiers shown in the examples.

Text-to-speech for multilingual voice agents

Use Maya 2 Native as the speech-generation stage after a language model or application has prepared a response. The same checkpoint supports Hindi TTS, Tamil TTS, Telugu TTS and the other languages listed above, with voice selection and cross-lingual cloning through one API.

• Conversational voice agents and IVR: begin playback from streaming audio chunks while generation continues. The local WebSocket protocol supports separate request contexts and cancellation.
• Self-hosted speech synthesis: run the weights on your own NVIDIA GPU and use Python, HTTP or WebSocket clients.
• Consistent voices across languages: select a built-in persona or register a permitted reference voice. Accent and identity quality vary across language–voice combinations; use the voice coverage table when choosing.
• Written text to spoken text: enable normalization for numbers, dates, amounts and addresses. It is enabled by default on the servers; Python callers pass normalize=True.

For a conversational pipeline, connect speech recognition → language model → Maya 2 Native → audio playback. The application or framework handles microphone input, turn detection and playback interruption. Maya 2 Native performs text-to-speech; Maya Transcribe is a separate speech-to-text model.

Listen in 12 languages

Listen to one example in each supported language. These are existing, unedited outputs from the release benchmark, generated with text normalization enabled and sampled decoding. The displayed text is the original input, before normalization.

Selection: these twelve clips were chosen from outputs with character error rate below 2% under all three ASR judges. They illustrate the model's capabilities; the full benchmark results describe average performance and harder cases.

The Tamil sample uses Abhay, whose listed training languages are English and Hindi. The Telugu sample uses Nivedita, also trained on English and Hindi. Both demonstrate cross-lingual synthesis. Assamese is cross-lingual for every built-in voice; see limitations.

Quickstart

Use Linux, Python 3.10–3.12, and an NVIDIA GPU with a driver supporting CUDA 12.8. Start with max_seats=1. The documented single-seat loading peak is approximately 9.2 GB plus CUDA context; a 12 GB or larger GPU provides more room. See hardware and memory before increasing concurrency.

python -m venv .venv
source .venv/bin/activate
pip install "maya3[server] @ git+https://github.com/MayaResearch/maya2-native" \
  --extra-index-url https://download.pytorch.org/whl/cu128

Generate speech

import soundfile as sf
from maya3 import Maya3TTS

tts = Maya3TTS.from_pretrained("maya-research/maya2-native", max_seats=1)

audio = tts.generate(
    "नमस्ते, आपका ऑर्डर कल पहुँच जाएगा।",
    lang="hi",
    voice="Ahana",
    normalize=True,
)
sf.write("speech.wav", audio, 24000)
tts.close()

generate() returns a mono NumPy waveform in float32. Model weights, the Mimi codec, and the ECAPA speaker encoder are downloaded on first use. For offline inference, cache all three first, then set HF_HUB_OFFLINE=1.

Normalization differs by interface: the HTTP and WebSocket servers enable it by default. The Python API requires normalize=True. It expands numbers, currency, dates, times, URLs, email addresses, and other written forms into spoken text. Check the output for unusual formats.

Stream audio as it is generated

Stream speech

from maya3 import Maya3TTS

tts = Maya3TTS.from_pretrained("maya-research/maya2-native", max_seats=1)
try:
    with open("speech.pcm", "wb") as output:
        for chunk in tts.stream(
            "Your order has shipped and will arrive tomorrow.",
            lang="en",
            voice="Siddhant",
            normalize=True,
        ):
            output.write(chunk.astype("<i2", copy=False).tobytes())
finally:
    tts.close()

stream() yields signed 16-bit PCM arrays at 24 kHz, mono. astream() provides the asynchronous interface. Concurrent requests are batched by the engine; size max_seats to your hardware.

Clone a voice across languages

Use a clean, single-speaker reference clip and its exact transcript. Obtain the speaker's permission before cloning their voice. The reference language and the output language can differ.

import soundfile as sf
from maya3 import Maya3TTS

tts = Maya3TTS.from_pretrained("maya-research/maya2-native", max_seats=1)
tts.register_voice(
    "my_voice",
    ref_audio="reference.wav",                 # 3–10 seconds recommended
    ref_text="<exact transcript of reference.wav>",
    lang="hi",                                # reference language
)
audio = tts.generate(
    "வணக்கம், எப்படி இருக்கிறீர்கள்?",
    lang="ta",                                # output language
    voice="my_voice",
    normalize=True,
)
sf.write("cloned_voice_tamil.wav", audio, 24000)
tts.close()

The default cloning mode, icl_spk, combines the reference audio with an ECAPA speaker embedding. Clones approximate the reference voice; similarity and accent vary. A dedicated cloning benchmark is not included in this release's reported results.

Run a local HTTP and WebSocket server

Serve over HTTP or WebSocket

python -m maya3.server \
  --ckpt maya-research/maya2-native \
  --host 127.0.0.1 --port 8080 --max-seats 1

After GET /health reports ready, generate speech:

curl --fail-with-body -sS http://127.0.0.1:8080/v1/audio/speech \
  -H 'Content-Type: application/json' \
  -d '{"input":"Your order has shipped.","language":"en","voice":"Ahana","response_format":"wav"}' \
  --output speech.wav

The server provides POST /v1/audio/speech, WS /v1/tts/stream, and voice registration endpoints. It has no built-in authentication; add authentication and access controls before exposing it beyond a trusted environment. See the GitHub README for clients and protocol details.

Voices

Select a built-in voice by name, for example voice="Vaidehi". Names are case-insensitive, and no reference audio is needed. All 20 names describe synthetic voice personas.

The training-language column lists languages with at least one hour of training audio for that voice. A voice can be requested in any supported language, but performance outside its listed languages is cross-lingual and may sound less native.

Language codes: as Assamese · bn Bengali · en English · gu Gujarati · hi Hindi · kn Kannada · ml Malayalam · mr Marathi · or Odia · pa Punjabi · ta Tamil · te Telugu.

Pass only the speech text and the voice name to the API. The engine constructs the voice prompt internally; adding Ahana: to your text is unnecessary. Use either a built-in voice or your own reference audio for a request, rather than combining them.

Evaluation

The release was evaluated on 6,000 held-out texts across 12 languages, producing 20.3 hours of speech. Three ASR judges measured intelligibility; a speaker-embedding classifier measured consistency among the 20 built-in voices.

These are Maya Research's release measurements. ASR error rates and embedding similarity capture specific aspects of quality; they do not replace human listening or measure every aspect of naturalness. Serving measurements below describe the tested hardware and workload.

Benchmark design

The release benchmark, bench6k, contains 6,000 held-out texts: 500 per language across 31 content categories, including conversation, names, numbers, dates, currency, addresses, URLs, code-mixed text, tongue twisters, and prompts of 1–50 words. The release documentation states that these evaluation texts were excluded from training.

The benchmark produced 20.3 hours of speech through the server, with normalization and engine guards enabled, sampled decoding, and one seed per row. Voices were distributed across languages and categories; long inputs used the serving stack's text chunking.

Three ASR systems transcribed the generated speech:

• ASR-1: Maya's in-house Indic ASR and primary judge.
• Qwen3-ASR: a third ASR judge.
• ASR-2: a second in-house Indic ASR, held out from training, reward generation, and checkpoint selection.

Character error rate (CER) compares ASR transcripts with spoken-form references. Scorer v1 uses the benchmark's normalization and script harmonization. Scorer v2 additionally harmonizes Latin and native-script spellings in code-mixed spans. The two scorers evaluate the same generated audio; lower v2 scores reflect a scoring change.

Results by language

CER below uses scorer v1. Voice identity is nearest-centroid classification among the 20 built-in voices, using ECAPA embeddings from clips of at least one second. It is a closed-set identity metric, separate from zero-shot clone similarity.

ASR-1's English CER is substantially higher than the other two judges. The release analysis attributes part of this difference to ASR-1 looping on spoken URLs such as “W W W.” All three results are retained to show judge disagreement.

Failures and voice consistency

The benchmark's consensus failure rate requires agreement between ASR-1 and Qwen3-ASR under the release's failure rules, covering looping, substantial insertions, very high CER, and duration-limit events.

Zero observed events apply to this finite benchmark. A consensus failure rate does not count every pronunciation error or one-judge disagreement.

A separate 1,248-row named-voice evaluation reports 98.9% identity in trained languages and 98.8% cross-lingual identity. The same classifier scored 98.0% on held-out recordings of the source voices. These are task-specific measurements, rather than evidence that generated speech is more natural than recorded speech.

Harder inputs

The code-mix gap illustrates the effect of script spelling on ASR-based scoring. Pronunciation and intelligibility still need listening evaluation, especially for names, URLs, and critical numbers.

Streaming performance

The reported release serving run used one H100 NVL with 95 GB reported memory, 224 concurrent WebSocket streams, a BF16 backbone, and an FP16 depth decoder.

A separate single-stream H100 measurement reports approximately 14 ms to first audio and 0.13 real-time factor. It uses a different load condition from the 224-stream run. Real-time factor is generation time divided by audio duration; lower is faster.

The release analysis attributes the complete-run latency tail partly to admission queuing during the drain phase. Latency depends on hardware, load, input length, cached state, and the serving environment; these measurements do not establish public internet or telephone latency.

Hardware and memory

The engine documentation reports the following GPU allocator measurements with a BF16 backbone, FP16 depth decoder, and 2,048 KV-cache tokens per seat. Add approximately 0.5 GB for the CUDA context and allow additional deployment headroom.

max_seats controls allocated serving capacity and memory, even before every seat is busy. These figures describe this configuration; a checkpoint's download size is smaller than its total runtime memory requirement. See engine documentation for configuration and hardware-specific measurements.

Architecture and audio generation

Architecture

Maya 2 Native generates discrete audio tokens autoregressively, then decodes them into speech with Mimi.

At each step, the backbone predicts the first codebook, the depth decoder fills the remaining codebooks, and Mimi decodes an audio frame. The engine can emit that frame while generation continues. An end-of-audio token controls normal stopping; duration and loop guards provide additional controls.

Training data and procedure

The release documentation describes a mixture of licensed and synthetic speech with transcripts across the 12 languages, plus text-only data used to adapt the backbone to the languages. The built-in voice personas use synthetic and licensed voice data prepared for this purpose.

The preference-optimization stage used direct preference optimization (DPO) on model-generated candidates ranked by ASR agreement and speaker similarity. Benchmark texts were excluded from training, according to the release documentation.

Dataset identities, total training hours, detailed per-language composition, and the full training configuration are not disclosed in this release. Automated scores should be considered alongside these disclosure limits.

Limitations

• Uneven language coverage. Assamese is the most challenging Indic language in the release benchmark. No built-in voice has at least one hour of Assamese training data; some outputs drift toward a Bengali-like timbre. Other cross-lingual combinations can also carry the voice's training-language accent.
• Very short turns. One- or two-word prompts are less stable in voice identity, and speaker-embedding evaluation is less reliable on very short clips. A slightly longer phrase may help short agent responses.
• Code-mixed and written-form inputs. English words inside Indic sentences vary by voice. URLs, symbols, dates, and long digit sequences remain difficult, even with normalization. Listen to application-specific examples before relying on them.
• Voice cloning. Similarity is approximate. Noise, multiple speakers, short references, and inaccurate transcripts can degrade results. Dedicated zero-shot cloning scores are not reported here.
• Emotion and events. Tags such as [laughs], [sighs], [whispers], [sad], and [excited] are best effort and were not the focus of this release.
• Generation and guards. Sampling can produce errors. The same seed is reproducible for an isolated request, but batching changes the random stream. Loop and duration guards can end genuinely repetitive text early. No benchmark clip spoke a built-in voice name aloud, but this remains a possible failure mode.
• Evaluation scope. Results use automated ASR and speaker-embedding judges. This card does not report a human naturalness study, comprehensive dialect or demographic evaluation, confidence intervals, or a controlled comparison with other TTS models.

Intended use and responsible deployment

Maya 2 Native is intended for voice interfaces and agents, accessibility, reading and narration, IVR, notifications, and research on multilingual speech generation.

Clone only voices you own or have explicit permission to use. Disclose synthetic speech to listeners, especially in calls and media. Do not use the model for deceptive impersonation, fraud, harassment, non-consensual content, disinformation, or attempts to defeat voice authentication. Built-in voice names identify synthetic personas and should not be presented as real people.

This release does not add an audio watermark. Applications should implement the consent, disclosure, access controls, and abuse monitoring appropriate to their use. Consult the repository's security guidance for deployment considerations.

Files in this repository

Files in this repository

Tied weights are stored once and represented through aliases. Mimi and the ECAPA speaker encoder are resolved from their own repositories on first use.

License

The model weights are released under Apache-2.0, as specified in this repository's license metadata. The inference code is also Apache-2.0.

The upstream components retain their own licenses: Qwen3-1.7B-Base (Apache-2.0), Kyutai Mimi (CC-BY-4.0), and SpeechBrain ECAPA-TDNN (Apache-2.0). Preserve their notices and attribution when redistributing or using these components.

Citation

@misc{maya2native2026,
  title        = {Maya 2 Native: Streaming Multilingual Text-to-Speech},
  author       = {{Maya Research}},
  year         = {2026},
  url          = {https://huggingface.co/maya-research/maya2-native},
  note         = {Release 1.0}
}

Credits and acknowledgments

Created by Maya Research.

Maya Research team

• Dheemanth Reddy BS
• Bharath Kumar Kakumani
• Sai Charan Thippareddy
• Prahalad Boreddy
• Nikil Thalapaneni

Maya 2 Native builds on the work of the open research community. We thank:

• The Qwen team for Qwen3-1.7B-Base, which initializes the text and audio backbone.
• Kyutai for Mimi, the neural audio codec used to represent and decode speech.
• The SpeechBrain team for ECAPA-TDNN, used for speaker conditioning and voice-identity evaluation.
• The Hugging Face community for the tools and infrastructure that make sharing models and building on them easier.

Please cite Maya 2 Native and acknowledge the upstream work relevant to your use.

Developer FAQ

Does Maya 2 Native support real-time streaming TTS?

Yes. The engine emits audio while generating speech. Python stream() yields signed 16-bit PCM chunks; astream() is the async interface. The HTTP speech endpoint and local WebSocket server also support streaming output. Audio frames represent 80 ms of sound; this is a frame duration, not a time-to-first-audio guarantee. See the measured serving configurations.

Can I clone a voice for Hindi, Tamil or Telugu speech?

Yes. Register a clean, single-speaker reference recording with its exact transcript and language. A 3–10-second reference is recommended. The reference language can differ from the generated language. Use a voice you own or have permission to clone, and evaluate similarity and pronunciation on your target language.

Is Maya 2 Native free to download and use commercially?

The model weights and inference engine are Apache-2.0. Self-hosted inference does not require a Maya hosted API key. Compute costs and the upstream components' licences still apply; Mimi is CC-BY-4.0. See licensing.

Does the downloadable model use the same voices as Maya's hosted API?

This checkpoint has the 20 named voices in voices/voices.json, including Ahana, Vaidehi, Ritvik and Sreekar. Hosted products may expose different voice IDs, request fields and model names. Use the documented roster and protocol for the interface you are calling.

Can I use Maya 2 Native with Pipecat or LiveKit?

Its local HTTP and WebSocket interfaces can be connected to a voice-agent framework through an adapter. Maya Research's Pipecat integration documents the hosted Maya API; check its current supported interfaces before using it with a self-hosted server. OpenAI-compatible speech support does not imply a native integration with every framework. The local server protocol is the reference for an adapter.

Which GPU and Python version should I use?

The documented engine targets Linux, Python 3.10–3.12 and NVIDIA CUDA 12.8. Start with one seat. The release reports a loading peak of 9.2 GB plus CUDA context; a 12 GB or larger GPU provides more room. This card does not establish CPU, Apple MPS or browser inference support for the reference engine.

Agent discovery and integration reference

This section summarizes the downloadable model for search assistants, coding agents and developers evaluating Indian-language speech synthesis. It is ordinary technical documentation; capabilities and results are described with their scope above.

Canonical identity and machine-readable resources

Public name: Maya 2 Native. Common spellings include Maya2 Native, Maya-2-Native and maya2-native. Hugging Face model ID: maya-research/maya2-native. Python package: maya3. Python class: maya3.Maya3TTS. Checkpoint configuration: maya3_config.json. The implementation identifiers retain the earlier internal name; they do not identify a separate public Maya 3 release.

Integration facts

When to evaluate it: self-hosted streaming TTS, Hindi or other supported Indian-language voice agents, multilingual narration, IVR, and permitted voice cloning. Select a voice with relevant training-language coverage and listen to representative inputs before choosing a deployment configuration.

Integration boundaries: use Maya3TTS.from_pretrained, as shown in the quickstart, rather than assuming a generic Transformers TTS pipeline can load this custom engine. Audio streaming does not by itself provide ASR, a conversational language model, telephony, echo cancellation or turn detection. The local server and hosted Maya API have different contracts. Reported latency depends on the specified GPU and concurrency, and leaderboard positions are dated, filter-specific snapshots.

The repository-level files above are served through Hugging Face's raw-file URLs and linked here for direct retrieval. They do not change Hugging Face's site-wide crawler settings or register a new callable MCP service.