MagpieTTS 357M: 12-language speech synthesis that runs on a laptop

MagpieTTS is NVIDIA's multilingual text-to-speech model: 364 million parameters, 12 languages — Italian and French included — and a 332 MB file that runs locally on a regular laptop, no GPU needed. It's the second link in the voice chain we've already covered on this site: Whisper turns speech into text, and MagpieTTS does the reverse, turning text into speech.

Until a year ago, local speech synthesis was a compromise: either it worked in a single language, or it sounded like a robot. A single model covering 12 languages with the same voice identity in each is something else. And it costs less than an hour of your life.

What is MagpieTTS Multilingual 357M

NVIDIA has published MagpieTTS Multilingual on Hugging Face: an end-to-end text-to-speech model with a transformer encoder-decoder architecture, 364M parameters, and an open license that allows commercial use. It covers twelve languages: Arabic, Chinese, English, French, German, Hindi, Italian, Japanese, Korean, Portuguese, Spanish, and Vietnamese.

The current version is v2607 (July 2026), which added Arabic, Korean, and Portuguese to the nine languages of the March v2602 release. Earlier checkpoints (v2512 from January) exist if you want a pinned installation.

Under the hood, the model doesn't "draw" audio the way an image model does: it predicts the tokens of a speech codec (NanoCodec, 22 kHz, 1.89 kbps, 21.5 frames per second) and decodes them into a 16-bit mono WAV. The quality of the result depends on that codec almost as much as on the text model — the same principle that makes a well-compressed film look good even at a low bitrate.

Five voices, Aria, Jason, Leo, Sofia, and John Van Stan, with different tones. The output is always a WAV file: no server, no API, no data leaving your machine.

The requirements: the math

This is the part that actually matters: what does it take to run it?

	MagpieTTS 357M
Model file (GGUF Q8_0)	332 MB
Model file (full F16)	569 MB
Estimated total RAM (model + codec)	under 1 GB
GPU	not required (supported as an option)

The numbers come from the model card: the Q8_0 quantization weighs 332 MB, the full-precision version 569 MB. The NanoCodec decoder that converts tokens into audio adds a few hundred MB. Total: under a gigabyte of RAM. An 8 GB laptop, a Raspberry Pi 5, an old desktop: all of them can do it.

The engine is NeMo-Speech.cpp, NVIDIA's lightweight native C++ runtime (v0.2.0, October 2026) for Linux, macOS, and Windows. It runs on CPU and, if an NVIDIA GPU is present, on CUDA as well. It downloads the GGUF model, tokenizer, and codec automatically: no configuration, no Python environment.

Compared to the historical alternative for local voice, Piper, the difference is one of approach:

	MagpieTTS 357M	Piper
Parameters	364M	compact models per language
Languages	12, one model	one per model
Voices	5, shared across languages	many, one per language and voice
Installation	C++ binary + 332 MB	Python + model per language
License	NVIDIA Open Model License (commercial use OK)	GPL-3.0

Piper has a dedicated Italian voice and a huge community; MagpieTTS has multilingual coverage in a single file. If you use voice in two or three languages, MagpieTTS wins on practicality. If you need an Italian voice that sounds Italian, Piper is ahead today — and more generally, the smaller model is still the one that runs best on a laptop.

From zero to first audio

The shortest path is the C++ runtime:

1. Install NeMo-Speech.cpp following the installation guide (prebuilt binary for Linux/macOS, or build from source).
2. Download the model: nemo-speech pull magpie — it fetches the v2607 GGUF, the tokenizer, and NanoCodec. If you only want the files without synthesizing, this command is enough.
3. Synthesize: nemo-speech synthesize "Hello, I am your local voice." --output voice.wav — at step 3 you should find a few-second audio file and be able to open it: that's the result.

If it doesn't work: if step 2 fails on the download, check your connection (the files come from Hugging Face); if step 3 doesn't produce the file, verify the output folder exists and is writable. The runtime also prints text-normalization logs locally, useful for seeing where things stall.

If you want to program, there's the Python path with the NeMo Speech framework:

pip install nemo_toolkit[tts]@main

from nemo.collections.tts.models import MagpieTTSModel
model = MagpieTTSModel.from_pretrained("nvidia/magpie_tts_multilingual_357m")
audio, _ = model.do_tts("Hello, world.", language="en", speaker_index=4)

You need Python ≥ 3.10.12 and a recent version of PyTorch. The C++ path is for running; the Python path is for integrating and experimenting.

And the limits?

Every voice has a price, and here there are two.

The twelve languages share the same five voices. Aria sounds like Aria in Italian as in Vietnamese: that's a design choice (consistent identity across languages, useful for a voice agent), but you won't find a natively Italian voice. For a product aimed at Italian speakers, you'll hear it.

Text fidelity depends on normalization. Numbers, acronyms, and abbreviations are handled by the model's built-in normalizer for all twelve languages; in practice, if you write "VAT 22%" and you want to hear "VAT twenty-two percent," the normalizer has to understand it. For technical domains with their own acronyms, testing counts more than specifications.

There's also a license limit worth keeping in mind: the NVIDIA Open Model License allows commercial use but has its own terms to read — it's not a free license like MIT or Apache.

Where it fits

The most natural use case is the full local chain: Whisper listens, the text model reasons, MagpieTTS answers. It's the architecture of a voice assistant, without a single byte crossing the network. If you're coming from here, local voice starts with Whisper to text-to-speech; and if you haven't installed a text model yet, running an LLM locally is the first step.

In summary

MagpieTTS Multilingual 357M is the most complete local text-to-speech released this season: 12 languages, Italian included, in a 332 MB file that runs on any laptop without a GPU. NVIDIA's C++ runtime takes you from zero to first audio in three commands, and the license allows commercial use. The honest limit: the five voices are English timbres in every language, and for a natively Italian voice Piper is still ahead. If you use voice in multiple languages, MagpieTTS is the right choice; if in just one, look at the alternative too.

Sources

• MagpieTTS Multilingual 357M model card — Hugging Face
• NeMo-Speech.cpp — GitHub NVIDIA
• Piper TTS — GitHub

Article generated with AI