The time between generating text and hearing the first sound of the response must stay under 32 milliseconds on an NVIDIA B200 GPU if you want a natural conversation.
NVIDIA has released Magpie TTS, an open-weight model designed to run inside your own infrastructure. The update adds Modern Standard Arabic, Korean, and Brazilian Portuguese to its supported languages.
Why you need to control the latency budget
Every voice interaction has a strict time limit. Users capture audio, transcribe speech, run a large language model, retrieve context, and generate a response before they even hear the final output. Text-to-speech is the last step in that chain. If this final stage takes too long, the whole experience feels sluggish.
Integrated speech models simplify deployment with a single API call. However, they limit your ability to fine-tune components for specific domains, swap in better models as they arrive, enforce data residency, or pinpoint exactly where delays occur. A cascaded architecture keeps each layer independently tunable and deployable on infrastructure you own.
Magpie Multilingual TTS is built for that approach. With open weights and production-ready NVIDIA NIM support, you can deploy multilingual speech inside your own environment, optimise latency for your workload, and customise the model for your domain.
Global applications require global support
Modern voice applications do not serve a single language. Global customer support, enterprise assistants, healthcare documentation, and retail automation increasingly require natural conversations across multiple languages while maintaining low latency.
Developers need the ability to deploy where their data lives, meet enterprise privacy requirements, customise pronunciation and voices, predict latency under production workloads, and scale on their own infrastructure. Open models change what is possible on every one of these fronts.
One model, twelve languages
Magpie TTS Multilingual is a 364M-parameter open-weights model supporting English, Spanish, French, German, Italian, Vietnamese, Mandarin, Hindi, Japanese, Modern Standard Arabic, Korean, and Brazilian Portuguese.
Each language includes male and female speaker voices through a shared multilingual speaker representation. The release also improves multilingual flexibility with expanded code-switching support for Hindi and Japanese, enabled through IPA grapheme-to-phoneme processing and custom pronunciation dictionaries. This makes it easier to accurately pronounce names, technical terminology, and mixed-language content.
Instead of maintaining separate TTS models for different regions, developers can build multilingual applications on a single open foundation.
The latency your users actually notice
In conversational AI, text-to-speech is the final stage before users hear a response. That makes Time to First Audio (TTFA) — the delay between speech generation beginning and the first audio reaching the user — one of the most important latency metrics in a voice pipeline.
Because Magpie TTS can be deployed inside your own environment, the latency you measure is the server-side latency you actually control, with no managed-service round-trip in the number.
Performance benchmarks
- B200 GPU: 32 ms TTFA (1-stream) and 239 ms TTFA (64-stream)
- H100 GPU: 47 ms TTFA (1-stream) and 275 ms TTFA (64-stream)
- DGX Spark: 53 ms TTFA (1-stream) and 962 ms TTFA (64-stream)
- A100 GPU: 79 ms TTFA (1-stream) and 395 ms TTFA (64-stream)
Source: NVIDIA TTS NIM Performance documentation (v26.07), average of three trials, on-prem.
At 32ms on B200, Magpie’s TTFA leaves the rest of the latency budget for ASR and LLM processing — keeping total end-to-end latency within the sub-200ms window natural conversation requires. Across NVIDIA GPUs, Magpie delivers first audio in 32–79ms on a single stream. At 64 concurrent streams, B200 reaches 239ms TTFA while delivering throughput at 320× real time — generating audio more than 300 times faster than it plays back, even under concurrent load.
The table above shows Magpie served as the NVIDIA NIM, measured on-prem — the optimized container running on your own GPU. The open Hugging Face checkpoint is the same model and your path for research and fine-tuning; the NIM is the tuned serving stack that produces these production latencies. Both run on hardware you control.
Because the model runs on your own infrastructure, you can benchmark performance directly, tune it for your deployment, and scale according to your workload. For real-time voice agents, that is the difference between conversations that feel responsive and conversations that feel delayed.
Optimised for real-time speech generation
Low latency is not accidental. Magpie introduces two complementary architectural improvements that reduce inference time while maintaining speech quality.
Frame stacking. The decoder predicts two audio frames during each decoding step rather than one. This cuts the number of decoder iterations in half, shortening generation time and improving throughput.
Local transformer. Frame stacking alone would reduce audio quality by introducing dependencies between simultaneously generated codebook tokens. The local transformer models those dependencies and refines the generated audio, recovering the quality that frame stacking would otherwise sacrifice.
Together, these techniques deliver both faster generation and natural speech synthesis. The architecture is described in Frame-Stacked Local Transformers for Efficient Multi-Codebook Speech Generation (ICASSP 2026).
Quality improvements across existing languages
This release does not only add languages — it also improves synthesis quality across many existing ones. Compared to the previous release, Magpie shows reduced character error rates (CER) and higher speaker similarity (SSIM) on several languages, with the clearest gains on French and Spanish.
Quality metrics
- French: CER dropped from 2.70% to 1.54%; SSIM rose from 0.703 to 0.747
- Spanish: CER dropped from 1.14% to 0.60%; SSIM rose from 0.715 to 0.793
- German: CER rose slightly from 0.66% to 0.80%; SSIM rose from 0.626 to 0.742
Source: Magpie TTS Multilingual model card. CER lower is better; SSIM higher is better.
The newly added Arabic (1.62% CER), Korean (2.69%), and Brazilian Portuguese (2.91%) models establish baseline quality for future improvements.
While objective metrics help measure progress, speech quality is ultimately perceptual. You can hear the difference yourself on NVIDIA Build or the Hugging Face demo.
Why open weights matter
Latency you can measure is useful. Latency you can control is even better.
Open weights give developers capabilities that come from owning the deployment. With Magpie you can deploy on infrastructure you control, run entirely within your own infrastructure, including private or air-gapped environments. You own your latency budget without a managed-service round-trip and optimise directly for your hardware and workload. You can customise pronunciation and voices by fine-tuning with NeMo for your own brand, domain vocabulary, or speaker data. You scale on your own terms by optimising the serving stack for your infrastructure and workload. You maintain enterprise control by keeping sensitive conversations and customer data inside your environment.
For enterprises building production voice AI, this control over deployment, performance, and customisation is often what matters most.
Build complete voice agents
Voice AI in production is a system of models, not a single one. Magpie TTS is part of the NVIDIA Nemotron Voice Agent Developer Example, a reference implementation showing how purpose-built speech, language, and reasoning models work together as a coordinated system — so you can build always-on voice agents, not just better-sounding speech.
Developers can combine Nemotron Speech for streaming speech recognition, Magpie TTS for natural multilingual speech synthesis, Nemotron language and multimodal models for reasoning and tool calling, NVIDIA NIM for GPU-optimised, production-ready inference microservices, and NeMo for customisation and fine-tuning.
The Nemotron Voice Agent developer example provides an end-to-end reference implementation that developers can clone, customise, and deploy in hours. It includes production patterns for real-time interruptible conversations, multimodal voice agents with vision understanding, multi-agent orchestration and tool calling, multilingual voice interactions, and sub-second end-to-end latency using NVIDIA NIM.
Rather than assembling individual components from scratch, developers can start from a complete reference architecture and adapt it to their own applications.
How to start
Try the model
Deploy to production
- NVIDIA Magpie Multilingual TTS NIM — optimised inference containers
Customise for your domain
- NVIDIA NeMo Speech — fine-tuning and training
Build complete voice agents
Open weights and license
- Model card on Hugging Face — open weights under the NVIDIA Open Model License.
Recommended inference configuration:
cfg_scale = 2.5 # classifier-free guidance — raise for tighter text adherence
temperature = 0.6
top_k = 80
apply_attention_prior = True
prior_epsilon = 0.1
