Phonon-2.5: A 156 MB Speech Transcription Model Supporting 25 Languages, Beating Whisper large-v3 on Average

Fermion Research has released Phonon-2.5, a lightweight on-device automatic speech recognition (ASR, converting speech into text) model, alongside Phonon-2.5 English, a specialized English-only variant.

Its core highlights include:

• Small footprint, single-file multilingual support: The model download size is 156 MB (occupying 178 MB uncompressed on disk), transcribing 25 languages from a single file (predominantly European and Mediterranean languages; Chinese is not supported);
• Trade-off between low error rate and compact size: On the FLEURS 25-language benchmark, it achieves an average Word Error Rate (WER) of 11.71%, lower than Parakeet Redux (12.18%) of comparable size and the 16x larger uncompressed base model Parakeet TDT 0.6B v3 (13.26%);
• Cross-platform local offline execution: Retaining the predecessor's architecture and inference engine, it runs across Apple silicon, standard x86-64 / Arm CPUs, and NVIDIA GPUs without uploading audio to the cloud;
• Open weights with attribution for commercial use: Model weights are released under the CC-BY-4.0 license, permitting commercial use, modification, and distribution with attribution; the command-line interface is licensed under Apache 2.0.

What 156 MB Brings

Mainstream high-accuracy speech recognition models frequently span several gigabytes. For instance, OpenAI's Whisper large-v3 has a download size of roughly 3.1 GB, Whisper large-v3-turbo is around 1.6 GB, and Meta's MMS-1B-all approaches 4 GB. Meanwhile, small models in the hundred-megabyte class historically struggled to maintain transcription quality: in the comparison charts released by the team, Whisper base, which sits at a comparable size to Phonon-2.5, exhibits an average Word Error Rate as high as 53.71%—an error rate roughly 4.6 times that of Phonon-2.5 (11.71%). Achieving similar size with vastly divergent performance demonstrates that merely compressing footprint is not uncommon; the genuine challenge lies in maintaining viable recognition quality at an ultra-compact scale.

In practical workflows, this creates clear operational differentiation. Consider a concrete task: feeding an interview recording in a supported language into a locally running engine to output text complete with punctuation, capitalization, and word-level timestamps—entirely processed offline on the local machine without streaming audio to cloud transcription APIs.

Model files must first be downloaded to the machine before audio can be processed offline:

• Lowering distribution and storage barriers: The 156 MB download file (158 MB for the English-specialized version, 178 MB on disk) significantly reduces download times and local storage demands, easing rapid distribution across edge devices or personal computers;
• Download size does not equal runtime memory: A compact file primarily optimizes download bandwidth and storage footprint. Cold-start engine initialization latency and actual active RAM usage depend on the specific inference engine implementation and cannot be directly inferred as low memory consumption purely from a small download file.

Storing Weights at Five Levels, Expanding at Runtime

Phonon-2.5 is derived from NVIDIA's Parakeet TDT 0.6B v3, compressing the 2,508 MB full-precision original into a 156 MB distribution file. By comparison, applying standard post-training 4-bit quantization directly to the base model (resulting in a file size around 472 MB) degrades the average Word Error Rate across the 25 languages to 14.48%.

Understanding how it preserves recognition capabilities through such drastic compression requires examining the nature of neural weights and low-bit representations:

• Weights and low-bit concepts: In neural network computation, weights are numerical coefficients that scale the strength of incoming audio signals. Low-bit quantization stores these numbers using fewer binary bits.
• Five-state discrete weights (~2.1 bits/weight): Phonon's encoder constrains each weight to five discrete values—zero (0), or positive and negative pairs across two distinct magnitudes (+a, -a, +b, -b), where magnitudes a and b are learned per output row.
• Packed encoding mechanism: In compact storage, base-3 digits (trits) natively encompass 0 as well as positive and negative signs, packing 5 trits into a single byte; for non-zero weights, an additional 1 bit selects magnitude a or b, yielding an overall average of approximately 2.1 bits per weight without separate sign bits.

Loading and Computation Pipeline: Download Size Does Not Equal Runtime Memory

When processing audio, the inference engine transitions from disk loading to hardware execution; thus, the 156 MB download (178 MB on disk) does not translate directly to runtime memory:

• The engine reads and unpacks the compact binary only once during startup initialization, bypassing packed bytes during subsequent decoding passes;
• On Apple silicon Macs, the MLX engine unpacks the encoder into dense 16-bit copies upon loading and executes computation on the GPU;
• On x86-64 and Arm CPUs, each row of weights is requantized into 8-bit integers (INT8) upon loading, executing dot products in a persistent thread pool using CPU vector instruction sets;
• On NVIDIA GPUs, weights are expanded into 16-bit tensors upon loading, running batched decoding via prebuilt CUDA graphs.

The team has not publicly disclosed the specific training recipe or dataset mixture for version 2.5, noting only that it retains the predecessor's format and engine; consequently, one cannot attribute the benchmark gains over the base model purely to compression itself.

More Accurate on Average: How 101.8% Is Calculated

In the release announcements, the most prominent headline metric claimed "word accuracy reaching 101.8% of the 2.5 GB full-precision base model." Making sense of this figure requires unpacking Word Error Rate and benchmark methodology.

The primary metric for evaluating speech recognition quality is Word Error Rate (WER), calculated by summing deletions, substitutions, and insertions in the hypothesis and dividing by the total words in the reference text. For instance, a 10% WER roughly corresponds to 10 word-level edit errors per 100 reference words; it does not strictly imply that 90 words were transcribed flawlessly. The FLEURS benchmark uses the complete public test sets of read sentences for each language, evaluated with the same code and text normalization standards; however, average read-speech performance across 25 languages does not mirror noisy real-world meetings, code-switching, or Chinese speech environments.

The figure 101.8% represents a relative retention ratio derived from average Word Error Rates across 25 languages, rather than an absolute transcription accuracy percentage. The formula is: Relative Accuracy Retention = (100 - Phonon-2.5 Mean WER) / (100 - Base Model Mean WER)

The full-precision base model posts an average WER of 13.26% across 25 languages, corresponding to a baseline word accuracy of 86.74%; Phonon-2.5 lowers the average WER to 11.71%, corresponding to a word accuracy of 88.29%. Dividing the two yields 88.29 / 86.74 ≈ 101.8%. This ratio denotes that the model's overall average error rate is lower than that of the full-precision base model, rather than claiming an absolute accuracy exceeding 100%.

Recomputing against the published tables confirms that the 101.8% shown at the top of the chart matches this mean WER conversion, while the bars below show individual ratios per language. Averaging those 25 individual ratios directly yields approximately 102.19%; the two mathematical methods must not be conflated.

Looking at absolute error rates across the public FLEURS 25-language benchmark:

• Phonon-2.5 achieves a 25-language average WER of 11.71%;
• Parakeet TDT 0.6B v3 (2.5 GB full-precision base model) records an average WER of 13.26%;
• Despite occupying only 6.2% of the base model's size (156 MB vs 2,508 MB), the average error rate drops by 1.55 percentage points.

Why does the micro model outperform the base model on average? A per-language breakdown reveals distinct divergence:

1. The full-precision base model remains superior on common languages: On English (base 6.53% vs Phonon 6.58%), Spanish (4.69% vs 4.80%), French (6.61% vs 8.12%), German (5.96% vs 6.67%), Italian (4.75% vs 5.21%), Dutch (7.93% vs 9.21%), and Russian (7.21% vs 8.67%), the full-precision base model consistently logs lower error rates.
2. Substantial gains on long-tail languages pull up the average: Phonon-2.5 shows pronounced improvements in languages where the original base model underperformed. Most notably, Greek (falling from 36.11% to 20.83%), Latvian (from 23.66% to 14.92%), and Slovenian (from 24.70% to 18.53%) dramatically boost the overall average.
3. Positioning of other comparative models: In data shared by the authors, Canary 1B v2 achieves an even lower average WER of 9.97% across the 25 languages (at a size of roughly 3.9 GB); OpenAI's Whisper large-v3 registers an average WER of 12.18% across the 25 languages (higher than Phonon-2.5's 11.71%), yet Whisper still posts lower error rates than Phonon-2.5 on mainstream individual languages like English, Spanish, French, and German.

Different Baselines Behind the Two "Leading in 14 Languages" Claims

Official materials twice mention "leading in 14 out of 25 languages," which can easily be mistaken for the same subset of languages, when they actually refer to two entirely different comparison baselines:

• Compared to the similarly sized Parakeet Redux: Phonon-2.5 has a lower error rate in 14 languages. For example, on the English test, Phonon-2.5 (6.58%) outperforms Redux (7.32%), but still trails the full-precision base model (6.53%).
• Compared to the 16x larger full-precision base Parakeet TDT 0.6B v3: Phonon-2.5 likewise performs better in 14 languages, but this group consists largely of long-tail languages where the base model originally struggled. For instance, in Latvian, Phonon-2.5 (14.92%) substantially outperforms the base model (23.66%), but is slightly higher than Redux (14.76%).

In the interactive component below, toggle between the overall average and the six individual languages shown in official charts to verify discrepancies between Phonon and Whisper, then inspect the exact lists for the two "leading in 14 languages" subsets. None of the 25 supported languages include Chinese.

English-Specialized Model: Phonon-2.5 English Performance

Alongside the multilingual model, the team released Phonon-2.5 English (model alias phonon-2.5-en, download size 158 MB, disk footprint 178 MB) optimized specifically for English-only workflows.

Across the seven English evaluation sets of the open-source Open ASR Leaderboard (encompassing LibriSpeech clean (clear audiobooks) and other (more challenging audiobooks), AMI meetings, Earnings-22 corporate calls, GigaSpeech podcasts, SPGISpeech financial dictation, and VoxPopuli parliamentary addresses), Phonon-2.5 English outperforms predecessor Phonon-2 across all 7 benchmarks, reducing average Word Error Rate from 5.21% to 4.82%.

While the English-specialized model outperforms the multilingual edition on average (4.82% vs 5.06%), differences emerge across specific subsets: on LibriSpeech clean (1.60% vs 1.64%) and other (3.41% vs 3.56%), the multilingual edition actually records lower error rates, while both tie at 3.31% on SPGISpeech.

The 4.96% figure for the full-precision base model cites the public leaderboard entry; figures for remaining models were evaluated by the team using the leaderboard's open evaluation harness (with Earnings-22 using the leaderboard chunked dataset), rather than a unified simultaneous re-benchmark.

How to Use It on Your Own Computer

Desktop Application: Detta

For users seeking instant dictation within everyday desktop software without setting up a developer environment, the team provides a free Mac desktop application, Detta (Apple silicon Macs only; requires macOS 26.2 or later).

Pressing a shortcut in any application records speech, and releasing it automatically enters text into the active window. Under the hood, it pairs two local models: speech-to-text is handled by a locally running Phonon model, while speech correction, filler-word removal (such as "um"), and duplicate cleanup are performed by a dedicated local Gluon model. These text-cleaning capabilities are not native to raw Phonon.

The official website provides an illustrative cleanup example: a user says "back to HTML. I mean XML", correcting HTML to XML mid-sentence; the final transcribed output keeps only "back to XML", while "um" and repetitive expressions are pruned. This illustrates the output of Detta working in tandem with Gluon.

The Detta website currently still lists built-in Phonon-2; the authors note that 2.5 is rolling out in batches, so whether an installed app has received the new model depends on actual received updates.

To specify models, batch-process audio files, or integrate with existing software, use the command-line tool, which requires Python 3.10 or later. The following commands reflect official documentation and have not been tested for transcription on this machine; first try a recording whose spoken words you can verify.

1. Installation and Environment Setup

Apple silicon Macs use the MLX engine. With Python 3.12 installed, open a terminal, create an isolated environment, and install:

python3.12 -m venv .venv && source .venv/bin/activate
pip install "fermion-research[mlx]"

For CPU environments:

• Linux (x86-64 / Arm64): Install PyTorch from the CPU wheel index first to avoid pulling heavy CUDA dependencies, then install the package:

pip install --no-deps torch --index-url https://download.pytorch.org/whl/cpu
pip install fermion-research

• Windows: Run pip install fermion-research directly.

2. CLI Audio Transcription

When transcribing from the command line, specify the phonon-2.5 model name explicitly. Invoking the bare phonon command defaults to the predecessor Phonon-2; the engine does not switch automatically. Place the target audio (such as recording.wav) in the current working directory, and the tool will automatically detect the language:

# Transcribe audio file; writes punctuated, capitalized text directly to standard output
fermion transcribe phonon-2.5 recording.wav

# Use English-specialized model
fermion transcribe phonon-2.5-en call.wav

# Output JSON containing word-level start and end timestamps
fermion transcribe phonon-2.5 recording.wav --json

The CLI supports WAV, FLAC, OGG, and AIFF formats via libsndfile, automatically resampling input to 16 kHz mono. For MP3 or M4A audio, the CLI prompts converting with ffmpeg beforehand (unlike the Detta desktop app, which supports diverse media formats natively).

When processing longer audio, the CLI does not ingest an entire hour in a single pass: for audio files exceeding 35 seconds, the tool automatically splits audio along pauses into ~25 to 35-second windows for individual decoding before stitching text together. For critical long recordings, spot-checking sentence continuity and proper nouns across chunk boundaries is recommended.

3. Hotwords

When recognizing specific names or domain terminology, pass a short hotwords parameter. When acoustic features are ambiguous, the decoder will bias toward those tokens, though accuracy still depends on actual pronunciation and is not guaranteed:

fermion transcribe phonon-2.5 meeting.wav --hotwords "Ada, Quillon"

4. Local Compatible Server and Docker Images

Launching the local server allows existing applications supporting OpenAI audio endpoints to point their base URL locally (e.g., http://127.0.0.1:8010/v1) and specify the model name to route transcription locally:

fermion serve phonon-2.5 --port 8010

This service provides the /v1/audio/transcriptions endpoint alongside /v1/audio/stream supporting WebSocket streaming. On macOS, fermion listen phonon-2.5 also enables real-time microphone dictation.

Container images bypassing local Python dependencies are available on the official registry:

• CPU container image: ghcr.io/fermionresearch/phonon-cpu
• NVIDIA GPU container image: ghcr.io/fermionresearch/phonon-cuda

Transcribing an Hour in ~20 Seconds: How It Runs

Regarding throughput, the author shared Phonon-2.5 benchmark results in the release thread: a base M5 MacBook Air reached 179× real-time speed, an 8-core AMD Zen 5 CPU reached 147×, and a single NVIDIA H100 achieved 6,672× in batch mode. Official technical documentation notes that the new release retains the predecessor's format and engine, resulting in essentially identical throughput, providing the predecessor's baseline comparisons: M5 MLX GPU at 174×, Zen 5 CPU at 143×, and H100 batch processing at 6,680×.

Phonon-2.5 retains the predecessor's inference engine. Once the compact file is loaded and unpacked, execution throughput stems from platform-specific optimizations across compute, communication, and scheduling:

• Apple silicon Mac: The MLX engine keeps sequential decoding entirely on the GPU, avoiding round-trip CPU synchronization on every step and instead syncing with the CPU once every 16 steps, dramatically lowering intra-chip overhead;
• CPU (x86-64 and Arm): Weights are converted to INT8 format upon loading and executed via vector instruction sets; normalization, activation, and residual additions for each layer write directly into the next layer's 8-bit input buffer, minimizing memory round-trips by fusing inter-layer operations;
• NVIDIA GPU: Audio inputs of similar duration are bucketed together (1-second buckets) and execute through static computation graphs prebuilt at load time, advancing decoding for the entire batch 16 steps in a single launch to reduce dispatch overhead.

These throughput metrics must be evaluated alongside their operating conditions:

• The meaning of "x real-time" and exclusions: "x real-time" indicates the duration in audio seconds transcribable per elapsed second. Predecessor benchmarks included log-mel feature extraction preprocessing time, but excluded model loading time. Cold-loading the model upon initial execution typically takes 10 to 40 seconds; "transcribing 1 hour of audio in 20 seconds" likewise excludes this initial load overhead.
• High throughput on Mac relies on GPU: Speeds exceeding 170× on the M5 depend on MLX driving the Apple silicon GPU; switching to pure CPU mode drops predecessor baseline throughput to 40×.
• Batched throughput is not single-stream latency: The 6,680× figure for the H100 cited in technical documentation was measured under a batch size of 128 on the predecessor, compared to a single-stream baseline of 465×; the 6,672× figure shared in the 2.5 release thread notes only "batched transcription" without disclosing whether the identical batch size of 128 was used, and should not be assumed as an exact batch setting for the new release.

The Core ML-based version previewed by the team (promising up to 800× real-time speed) remains in future planning.

Overall, Phonon-2.5 provides an efficient local offline speech transcription option across supported languages within a minimal download and storage footprint. Because the model does not support Chinese, Chinese-language use cases still require a dedicated, separate recognition solution.