Gradium's Phonon Runs Text-to-Speech in Browsers at Under 75 MB

Gradium has released Phonon, a family of compact text-to-speech models designed to run locally in browsers, mobile apps, and CPU-only environments. According to Gradium’s evaluations, the models outperform larger open alternatives on transcription accuracy and blind listening tests while keeping published weight sizes below 75 MB.

The flagship phonon-31m-en model uses 31 million parameters and ships under Apache 2.0. The broader family supports English, French, German, Spanish, and Portuguese, although its larger models carry non-commercial licenses.

Phonon generates compact audio representations with a flow-matching transformer, producing one 80 ms frame at a time. The Mimi codec then decodes those representations into audio. Because decoding proceeds during generation, playback can begin before the full utterance is ready.

One runtime, three release tracks

The three releases share a runtime API. Developers select a model through its repository identifier, while the language and voice settings must match that model.

Q8 indicates eight-bit quantized weights, which reduce storage and compute requirements. The published sizes cover model weights rather than an application’s full package size or runtime memory use.

Only the 31M English weights permit unrestricted commercial use under Apache 2.0. The 40M releases require attribution and prohibit commercial use under CC BY-NC; Gradium offers separate commercial licensing.

Gradium’s benchmark lead

Gradium reports a 1.7% word error rate for phonon-31m-en on a difficult test set containing phone numbers, email addresses, and postal codes. Kokoro scored 3.5%, while NeuTTS Nano scored 8.71% on the same evaluation. Lower word error rates indicate that a speech recognizer recovered more of the intended text from the generated audio.

Across the five supported languages, a Phonon model ranked first on Gradium’s three reported measures: blind-listening Elo, LLM-scored hard-set WER, and Seed-TTS WER. Elo scores are relative to the models in a specific comparison pool, so they cannot be compared directly across unrelated leaderboards.

These results are company-published rather than an independent evaluation. Production testing should include representative names, numbers, abbreviations, domain terminology, accents, and target hardware.

Low latency without a GPU

Phonon’s runtime targets CPUs, mobile accelerators, and browser backends. Arm’s measurements using KleidiAI kernels report first audio after 28 ms and generation at 15 times real-time speed on Arm CPUs.

A throughput of 15× real time means the system can generate 15 seconds of audio in roughly one second once synthesis is underway. The published platform results use different hardware and backends, so they do not constitute a controlled cross-platform comparison.

Available backends include CUDA, Metal, Vulkan, WebGPU, WebAssembly, Arm Neon, and Intel AVX2. The appropriate backend is selected at build time.

Gradium’s browser demo performs synthesis inside the visitor’s tab after loading the required assets. Fully offline applications still need to bundle or cache the model files, but subsequent text and generated speech do not require a synthesis request to Gradium’s servers.

From package install to PCM stream

pip install ptts

The Python API can write a complete WAV file or yield float32 PCM chunks while synthesis continues:

import ptts

tts = ptts.TTS(
    "hf://gradium/phonon-31m-en",
    lang="en",
    quant="q8",
)

tts.save(
    "speech.wav",
    "Hello from Phonon.",
    voice="en_us_Easton",
)

with tts.stream(
    "Speech can start playing right away.",
    voice="en_us_Easton",
) as audio:
    for pcm in audio:
        ...  # float32 chunks at audio.sample_rate

The lang argument controls text normalization, including the handling of numbers, dates, currencies, and email addresses. Streaming applications can forward each PCM chunk to an audio output as soon as it arrives.

A runtime built for existing stacks

Phonon integrates with Hugging Face Transformers, Ollama, LM Studio’s Bionic Read Aloud system, MLX-Audio on Apple Silicon, and Pipecat for voice agents. An OpenAI-compatible server supports clients already built around OpenAI-style speech endpoints.

The runtime also exposes foreign-function interfaces for Rust, Python, Swift, C, C++, and WebAssembly. That range allows the same model family to serve native applications, browser code, embedded systems, and local services.

Gradium includes approximately 100 preset voices. Instant voice cloning and prompt-based voice design are available through Gradium Studio and are separate from the Apache-licensed 31M model release.

From Pocket TTS to Phonon

Phonon builds on Pocket TTS and the Mimi codec developed by Kyutai. Pocket TTS demonstrated real-time speech synthesis on consumer CPUs; Phonon extends that work with quantized model releases, streaming generation, multiple hardware backends, language-specific normalization, and bindings for common application environments.

The workloads behind the release

• Offline assistants and accessibility tools: Local generation can support screen readers and Android TalkBack-style features without sending text to a speech service.
• Game dialogue: xybrid.ai runs Phonon inside an on-device game engine for real-time character speech.
• CPU-only voice agents: Modal has demonstrated a Pipecat agent that begins local synthesis without an external TTS network request.
• Wearables: One demonstration runs Phonon on an Apple Watch with Wi-Fi disabled.
• Automotive systems: Gradium and Forvia are collaborating through a joint research and development partnership.

Deployment boundaries

What changes for developers

Teams building browser, mobile, and edge speech features can now test a 64.5 MB Apache-licensed English model without provisioning GPU inference or sending synthesis text to a hosted TTS service. The deployment decision still depends on voice quality for the product’s vocabulary, runtime memory, hardware support, and licensing requirements.

Gradium’s WER, Elo, and latency figures provide useful starting points. A representative text corpus and measurements on production hardware will determine whether Phonon can replace an existing hosted service or local speech engine.