Field noteNov 16, 20265 min read1 source

Phonon 0.7.0 adds a dedicated WebGPU engine

In one minute

Phonon 0.7.0 replaces the browser frontend’s generic WebGPU path with an engine built for Phonon, and changes how GPU work is submitted and how speech generation is handled. For teams shipping local text-to-speech, the release makes browser GPU execution more purpose-built while also bringing CUDA, Core ML, and API changes.

What happened

Gradium’s Phonon 0.7.0 release describes changes since version 0.6.0. The default model is pinned to the current gradium/phonon-31m-en commit, whose default voice is Reuben; the release says the weights and tokenizer are unchanged. This is a versioned runtime and frontend release rather than a new model-weight release.

In the browser frontend, phonon-tts now has its own WebGPU engine, written for Phonon’s architecture instead of using the generic xn WebGPU path. The release describes a frame as a fixed list of fused kernels that the GPU replays. Sampling and detection of the end of speech also happen on the GPU, allowing many frames to be submitted in one call. Gradium says this is faster and starts speech sooner on every GPU it measured, including Apple GPUs in Chrome and Safari and on iPhone. The release does not publish timings or a test methodology.

WebGPU remains opt-in. Developers can select it with device: 'webgpu', or use device: 'auto' on a hardware adapter with q8 weights. If a checkpoint uses functionality the engine does not implement, the engine refuses it before loading; in auto mode, that checkpoint runs on CPU instead. That fallback is a meaningful deployment detail: choosing automatic device selection does not mean every checkpoint will run on WebGPU.

The release also reports several CUDA changes. The flow language model’s step is replayed as a CUDA graph; Mimi runs on its own stream and thread so it can overlap with the next step; and flow-network time conditioning is computed once at load. The release says decoding is “several times faster” but gives no numeric benchmark. With --quant q8 --device cuda, transformer linear layers now run as q8_0 on the GPU rather than being refused. Core ML export now uses a 200-token prefill, matching the text length used by other frontends and preventing long sentences from producing false sentence ends; the trade-off is that the first audio arrives a little later.

Other changes include temperature and seed setters for C, Swift, and Android APIs; least-recently-used eviction when priming a 17th voice; and ptts::s2s plus an example for checkpoints conditioned per frame on input audio rather than text. An experimental q8_0 Mimi decoder on CPU is also available, though the release says it pays off with kai or xn’s own kernels, not with Accelerate alone. The Rust API has a breaking change: ptts::tts_model::TTSConfig adds public field audio_delay, which struct-literal construction must now set. The release identifies that as the reason for the 0.7.0 version number.

What the archive adds

New Runtime’s Phonon 0.6.0 note covered earlier runtime updates, including Metal restoration, CPU fallback, language support, and Core ML export. Version 0.7.0 is a new event in that release series: its new fact is the dedicated WebGPU engine, alongside further CUDA and API changes.

Trend signal

This release supports harness architecture outlives model choice: practical runtime behavior depends on the execution layer around unchanged weights as well as on the model itself. Phonon 0.7.0 changes GPU scheduling, fallback, and frontend behavior without changing the model’s weights or tokenizer. That is a concrete example of the runtime becoming a consequential product boundary, though one release alone does not establish a broad trend.

Why it matters

For teams embedding speech generation, a specialized browser engine can make local inference more responsive without requiring a different model checkpoint. The important operational distinction is that the faster path is not universal: WebGPU is opt-in, q8 weights are part of the stated auto condition, and unsupported checkpoints fall back to CPU only under automatic selection. Teams should therefore test the exact checkpoint and device combinations they intend to ship rather than treating WebGPU support as a blanket property of Phonon.

The release also shows that execution trade-offs differ by frontend. Core ML’s longer prefill addresses false sentence endings but delays first audio; CUDA changes target throughput through graph replay and overlap. Those are different latency dimensions, and applications should validate both time-to-first-audio and end-to-end generation on their target hardware. The new Rust field is a separate migration concern for teams constructing configuration structs directly.

What happens next

  • Phonon’s browser WebGPU path will be used in at least one documented downstream application. (6 months, 55%). Watch for: an application or integration naming phonon-tts WebGPU as its shipped inference path.

Limits and uncertainty

Gradium’s release notes provide no numerical WebGPU or CUDA benchmark results, hardware-by-hardware measurements, or test protocol, so the speed and startup claims cannot be independently compared from the release alone. It does not quantify the Core ML first-audio delay or establish which checkpoints are supported by the new WebGPU engine. The release also does not state whether automatic selection chooses WebGPU consistently across browser and device combinations beyond the described hardware-adapter and q8-weight condition. The effect of the experimental CPU Mimi quantization depends on the kernels used.

Skill to build now

Test device selection against the checkpoints you actually plan to deploy. Select device: 'webgpu' for an explicit WebGPU trial, and test device: 'auto' separately with q8 weights; include a checkpoint the engine does not implement to verify the CPU fallback behavior. Record time to first audio and completion time on your target browser and GPU, since the release claims changes to both startup and decoding but does not publish measurements.

Reader takeaway

Phonon 0.7.0 makes local browser speech generation more GPU-specific, not universally WebGPU-enabled. The practical change is the new fused-kernel execution path, with explicit selection and checkpoint limits; teams should benchmark their own target combinations before assuming faster playback in production.

Evidence / sources

  1. 1github.com/gradium-ai/xn-ptts/releases/tag/v0.7.0
All Field Notes

Next reads

Read next

Open the graph
  1. 01topicFrontendExplore the frontend topic hub.
  2. 02archiveField NotesOpen the latest editorial analysis.
  3. 03sourcesSourcesSee the original sources this archive cites.
Who read this page?Machine requests, hidden until opened

Loading the privacy-safe route aggregate...

Open the JSON contract