Phonon

Streaming speech, on your device.

Phonon brings natural text-to-speech to phones, laptops, browsers, and local services. It is built for offline assistants, accessibility tools, and interactive experiences that need speech without a cloud round trip. The runtime is written in Rust and needs no PyTorch.

What you get · Choose an integration · Packages and downloads · Quickstart · Guides

Runtime preview available: Python, Rust, browser packages, and native downloads are published. See the runtime preview release for installation instructions. The unversioned registry commands below target the upcoming stable release and currently select older packages. Phonon model files are available separately from the runtime packages. Docker public access is being finalized.

The browser runs synthesis on your device; it downloads model files on first use.

• Small enough to ship: Choose a 40M or 90M parameter model. Both can ship inside a mobile app or load in a browser tab.
• Five languages in one model: Speak English, French, German, Spanish, and Portuguese, with more languages planned.
• Fast across devices: A custom inference stack runs in browsers and on phones, laptops, and embedded hardware, with Core ML on Apple devices, a QNN preview for supported Snapdragon NPUs, and GPU support. Multiple backends deliver faster inference than Kokoro and llama.cpp-based runtimes on the same hardware.
• Voices ready to use or make your own: Choose from ready-to-use voices, or explore voice design and cloning in Gradium Studio.
• Control the delivery: Adjust speaking speed and start playing streamed audio before the full utterance is ready.

Phonon is the product and model identity. The Rust, Python, Swift, and planned Android Maven packages are named ptts; the browser npm package is phonon-tts. This repository remains xn-ptts. Swift apps use import PhononTTS.

Packages and native downloads are available as a runtime preview. Follow the runtime preview release to install the preview. The unversioned commands below are the installation paths for the upcoming stable release.

Desktop downloads and Python wheels do not need a Rust compiler. Older x86 CPUs may need a source build: x86 wheels and desktop downloads target x86-64-v3. See the platform requirements in the CLI guide and Python guide.

Every integration needs an explicitly selected checkpoint. No model is chosen automatically.

The local examples below use a q8 checkpoint folder supplied to you, for example:

model/
  config.json
  tokenizer.json
  model.q8.gguf
  default-voice.safetensors

Voice files may instead live in voices/ or embeddings/. Use the files and voice names your checkpoint supplies; do not substitute another model's tokenizer or config. The examples use q8 weights. For f32 weights, omit --quant q8 or quant="q8", use Quant::F32 in Rust, and set quant: 'f32' with weights: { f32: '/model/model.safetensors' } in the browser.

Already received a model from us? Extract it locally and use the matching integration below. You do not need a public Hugging Face repo or an HF token for local files. Runtime packages contain no model weights.

For the shell examples below, set the folder once:

export MODEL_DIR=/absolute/path/to/model

The command line and Python can also acquire a checkpoint from Hugging Face. Use its repo ID and a fixed revision when you want a repeatable model version. Private repos require HF_TOKEN or a saved HF login. Local folders require no Hub access.

lang is required and selects text normalization, such as how numbers and symbols are spoken. Choose en, fr, de, es, pt, or none to pass text through unchanged. This setting does not establish which languages a checkpoint can speak.

These examples use the published runtime preview and a supplied checkpoint. Install the preview using the release instructions, or follow the source setup. The unversioned uvx and registry commands target the upcoming stable release.

uvx ptts --model "$MODEL_DIR" --lang en --quant q8 "Hello from Phonon." -o speech.wav

brew install gradium-ai/tap/ptts

ptts --dir "$MODEL_DIR" --lang en --quant q8 "Hello from Phonon." -o speech.wav

ptts --repo OWNER/MODEL --revision COMMIT_SHA --lang en --quant q8 \
  "Hello from Phonon." -o speech.wav

python -m pip install ptts

import os
import ptts

tts = ptts.TTS(config=os.environ["MODEL_DIR"], lang="en", quant="q8")
tts.save("speech.wav", "Hello from Phonon.")

with tts.stream("Speech can play while the rest is being generated.") as audio:
    for pcm in audio:
        # Send each chunk to your player at audio.sample_rate.
        print(pcm.shape)

python -m ptts --model "$MODEL_DIR" --lang en --quant q8 \
  "Hello from Phonon." -o speech.wav

npm install phonon-tts

import { PhononTTS } from 'phonon-tts';

const tts = await PhononTTS.load({
  lang: 'en',
  model: {
    config: '/model/config.json',
    tokenizer: '/model/tokenizer.json',
    weights: { q8: '/model/model.q8.gguf' },
    voices: { default: '/model/default-voice.safetensors' },
  },
});

const wav = await tts.synthWav('Hello from Phonon.'); // WAV Blob

import Foundation
import PhononTTS

guard let bundled = Bundle.main.url(forResource: "Models", withExtension: nil) else {
    throw PhononError(description: "Add the model folder to your app as Models.")
}
let models = try PhononModels.install(bundled: bundled)
let tts = try await Phonon.load(models: models, language: .english)
let player = try PhononPlayer()
try await player.play(tts.stream("Hello from Phonon."))

import ai.gradium.phonon.PhononTTS

val tts = PhononTTS.load(context, modelDirectory, lang = "en")
val sampleRate = tts.sampleRate
tts.speak("Hello from Phonon.") { pcm ->
    audioSink.write(pcm) // Mono float PCM at sampleRate.
    true // Return false to stop; tts.stop() also works from another thread.
}
// Reuse tts. Stop and wait for speech to finish before calling tts.close().

cargo install cargo-ndk
export ANDROID_NDK_HOME=/path/to/ndk
./android/build.sh

PTTS_IMAGE="ghcr.io/gradium-ai/ptts-openai-server:<release-version>"
docker run --rm -p 127.0.0.1:8880:8880 -v "$MODEL_DIR:/models:ro" \
  -e PTTS_CONFIG=/models -e PTTS_LANG=en -e PTTS_QUANT=q8 \
  "$PTTS_IMAGE"

curl http://localhost:8880/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{"input":"Hello from Phonon.","voice":"default","response_format":"wav"}' \
  -o speech.wav

cargo add ptts --features hf

use ptts::checkpoint::{Checkpoint, ResolveOptions};
use ptts::preprocess::Lang;
use ptts::synth::{DeviceKind, Quant};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let checkpoint = Checkpoint::resolve(
        std::env::var("MODEL_DIR")?,
        ResolveOptions { quant: Quant::Q80, weights: None },
    )?;
    let mut tts = checkpoint.builder(Lang::En).device(DeviceKind::Cpu).build()?;
    checkpoint.register_voices(&mut tts);
    let pcm = tts.say("Hello from Phonon.")?;
    ptts::wav::write_wav_file("speech.wav", &pcm, tts.sample_rate())?;
    Ok(())
}

Native desktop packages cover the targets listed in the CLI guide. Apple apps use Core ML. Android apps can use the CPU library or the QNN AAR preview on supported Snapdragon NPUs. QNN requires a matching compiled bundle and has no automatic CPU fallback. Browser apps use Wasm on CPU by default. Browser WebGPU is opt in. The npm package targets browsers, not native Node.js inference.

Performance and memory use depend on the checkpoint and device.

Report bugs or request integrations through GitHub Issues. Include your runtime version, device/OS, model revision, weight format, normalization language, and a small reproduction.

Phonon builds on Pocket TTS, developed by Kyutai, and uses the xn Rust tensor runtime. Gradium's Phonon checkpoints are the primary target. Compatible Pocket TTS checkpoints use the same explicit loading interface when they supply their own config, tokenizer JSON, weights, and voices.

The code is MIT OR Apache-2.0, at your option: MIT · Apache-2.0.

Model weights and voices are distributed separately and have their own licenses. Check the model license before redistribution.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this repository is dual licensed as above, without additional terms or conditions.