Introduction

Tiny voice models keep getting tinier, and this one is the size of a few phone photos. Syzygy Research just released Mach Boom, a compressed build of Gradium's open Phonon 31m English text-to-speech model. The whole model is one 18.2 MB file, and it runs on a single CPU core with no GPU.

It went up on Hugging Face as SyzygyResearch/Mach-Boom under Apache-2.0. Syzygy announced it on X late on November 10 (UTC). The repo was private for the first few hours and is public now, so you can download it and run it on a Linux laptop or server today.

What Shipped

  • Model: Mach Boom, a re-encoded copy of gradium/phonon-31m-en. Phonon itself builds on Kyutai's Pocket TTS and the Mimi codec.
  • Vendor: Syzygy Research, the team behind the Mach-2 language models on Hugging Face.
  • Modality: English text-to-speech, 24 kHz mono, with streaming output.
  • Size: mach-boom.bin is 18.2 MB. With the tokenizer and one voice, a working download is about 19.5 MB. The original fp32 Phonon release is about 103 MB.
  • Compression: about 3.53 bits per weight across 41 million stored parameters, counting the audio decoder. Most layers use a 3–4 bit trellis code with Hadamard rotation, and a few small parts stay at int8 or int4.
  • Runtime: new code for this release. It includes Python glue plus C kernels for AVX-512, AVX2 and plain C, and bf16 AMX tiles for the audio decoder on recent Xeons. The kernels compile themselves on first run, which takes about 5 seconds.
  • Voices: four ship in the repo (Zoey, Juniper, Everly and Harper), all American English female voices. Any voice file from gradium/phonon-voices drops in.
  • License: Apache-2.0, the same as Phonon and its voices.
  • Where to run it: Linux on x86-64 with Python 3.8+, numpy, tokenizers, and gcc or clang. There's no Space, API or ComfyUI node yet.

The Numbers

Syzygy tested on the 250 held-out sentences of Gradium TTS Hard Cases. That set is full of phone numbers, dates, money, units and codes, which are the things small TTS models tend to garble. Each model ran in its own runtime with its own default voice, and faster-whisper large-v3-turbo transcribed the results. These are Syzygy's own numbers.

Word error rate (lower is better)

  • Mach Boom (19.5 MB): 5.18%
  • Underdog Woof, Juno (40.6 MB): 6.50%
  • Fish Audio Drama 3 (41.5 GB): 7.62%
  • Phonon 31m, fp32 as released (103.4 MB): 8.61%
  • Phonon 31m, q4k GGUF (55.6 MB): 10.61%
  • Kokoro 82M (327.7 MB): 14.07%
  • Qwen3-TTS 1.7B CustomVoice (4.52 GB): 16.77%
  • Pocket TTS (225.5 MB): 18.13%
  • Kitten Nano 0.8 (27.6 MB): 18.56%

Here's the honest catch. Most of that lead comes from Mach Boom's new English text normalizer, frontend_en.py, which spells out numbers, times and codes before the model sees them. With every model's text rules turned off, Mach Boom scores 14.01%, compared with 11.99% for full-precision Phonon. So the 3.5-bit squeeze does cost some accuracy, and the frontend more than wins it back. That's still a fair result, since the frontend ships in the box and is what you'd actually use.

Speed and memory (4-core Emerald Rapids Xeon VM)

  • 1 core: 8.3–8.4x real time, against 4.1–4.2x for Underdog Woof int8.
  • 4 cores: 11.3–11.7x real time.
  • 1 core, AVX2 only: 4.2–4.3x real time, so older CPUs still run comfortably faster than playback.
  • Peak memory: 93 MB on one core, against 255 MB for Woof.
  • First streamed audio: 61–78 ms.

On a Granite Rapids Xeon, Syzygy reports 9.6–10.1x real time on one core and about 19.5x on four.

I Ran It

I downloaded it to our Linux box, which is an Intel Xeon VM with AVX-512 and AMX, and ran the README's booking-reference sentence. It made 6.96 seconds of audio in 0.59 seconds, which is 11.7x real time, using the default single thread. It read "AB-4471-Z" and "3:30 p.m." as you'd hope. In streaming mode with --first 2, the first audio arrived after 110 ms. That figure includes the Python overhead, so it's a bit slower than Syzygy's kernel-only number.

How to Try It

hf download SyzygyResearch/Mach-Boom --local-dir mach-boom && cd mach-boom
pip install numpy tokenizers
python tts.py "Your booking reference is AB-4471-Z, and the meeting moved to 3:30 p.m." -o out.wav --voice Zoey
python tts.py "Your table is booked for 8 p.m." --pcm --first 2 | aplay -q -r 24000 -f S16_LE

Or call it from Python:

from mach import MachBoom

tts = MachBoom("mach-boom.bin", voices_dir="voices", tokenizer="tokenizer.json")
wav = tts.synth("Call 020 7946 0018 before 5:30 p.m.", "Zoey", seed=0)  # float32, 24 kHz

Pro Tip

Keep the same --seed and --chunk and you'll get identical audio at any thread count. That makes it easy to cache prompts or diff output between builds. If you're on an older CPU, set --threads 4, because the audio decoder runs alongside the speech model.

Where It Fits

This is for kiosks, robots, small x86 mini PCs, offline assistants, and voice agents that read back booking codes and phone numbers. That's exactly what the benchmark was built to test. It's English only, there's no voice cloning beyond Phonon voice files, and it's Linux x86 only for now, so there's no Mac, ARM or browser build yet.

If you want the original model, start with our Gradium Phonon write-up. For the closest 40 MB rival, see Underdog Woof.

Conclusion

Mach Boom isn't a new voice model. It's a very good diet for one. It takes 18 MB, runs on one core, gets numbers right, and keeps an Apache license. If your project needs a small voice that runs offline, give it an afternoon of testing.

—Anabel ♡