Underdog Bark 3.0: A 163 MB Open Speech Model That Matches Parakeet

Underdog has released Bark 3.0, an open speech recognition model that fits in a 163 MB download. Its model card says it averages 4.94% word error across the seven English sets of the Open ASR Leaderboard, which would put it level with NVIDIA's 2.5 GB Parakeet TDT 0.6B v3 and ahead of OpenAI's Whisper large-v3 at 6.04%, from a download 57 times smaller.

Those numbers come from the vendor and were scored with the leaderboard's code, but the Bark rows are not on the leaderboard yet. This post covers what Bark 3.0 is, how it was built, how to run it, and how to read the comparison. It follows our coverage of Underdog's private personal AI launch and its Saluki 2-bit GGUF models. Source: the Bark 3.0 model card on Hugging Face.

TL;DR: Bark 3.0 at a glance

How does Bark 3.0 compare?

The card's benchmark table lists word error rate, lower is better, with competitor rows taken from the leaderboard as of October 9, 2026. A selection of averages:

Two points stand out. First, Bark 3.0 and Parakeet tie at 4.94% on the average, separated only at three decimals (4.937 against 4.941), so the headline is "same accuracy at a fifteenth of the size," not "more accurate." Second, the gap on AMI, a dataset of recorded meetings, is large: 7.82% against 9.42% for Parakeet and 13.63% for Whisper large-v3, which is the result Underdog highlights because meeting transcription is its use case. Note that "Phonon-2" in this table is a speech recognition model of that name; it is unrelated to the Gradium text-to-speech models we covered in our Phonon post.

The card also reports a disfluency test on 250 unscripted clips: Bark 3.0 at 3.15% versus Phonon-2 at 3.39%, with fillers counted. It says Bark 3.0 writes what was said, "um"s included. A separate Clean variant drops fillers for dictation.

Why the comparison needs care

• Self-scored. The card says the Bark rows use the leaderboard's scoring code and are "not on the leaderboard yet." Competitor numbers are the published rows as of October 9. Differences in normalization or decoding settings could matter, though the same code is reportedly used.
• A fine-tune of a fine-tune. Bark 3.0 builds on Parakeet through a derived model, so its accuracy is largely inherited. The headline innovation is compression and packaging: the card says weights are unpacked in memory, bit-identical to what the Python loader produces, and that an app can verify each file against a pinned size and SHA-256.
• Size is the download, not memory. On Windows, the card notes the loader expands packed weights to FP32 in memory, so download size is not the RAM or VRAM requirement.
• Long files. With stock mlx-audio, memory grows with file length: a 10-minute file peaked near 15 GB on a 16 GB M2. Split long recordings into pieces of a few minutes on 8 or 16 GB Macs.
• English only, with punctuation, casing and numerals following the original model's conventions.

For another on-device speech option and its caveats, see our post on Tether's 250M on-device speech recognition.

How to run it

Python with PyTorch (CUDA, CPU or MPS): download model.bark, bark_loader.py and the NOTICE file with the Hugging Face CLI, install the pinned dependencies listed on the card (transformers, torch 2.8.0 and a few audio libraries), and run python bark_loader.py model.bark recording.wav. In code, call load_model and transcribe. The transcribe function adds 0.25 seconds of silence before the audio, the setting the reported numbers use.

Apple silicon with MLX: install pinned mlx and mlx-audio, then run python bark_mlx.py recording.wav. The first run unpacks the weights into an MLX folder and caches it.

Mac with Core ML: GPU and Neural Engine packages exist for Apple Silicon on macOS 15 or later with Python 3.11. The card cautions that long-recording segmentation has not been qualified and first-use Core ML compilation can take several minutes.

iPhone and iPad: the card says the same Core ML model files apply on iOS 18 or later but states it is "not yet tested on an iPhone or iPad," and that an app must port the audio frontend and decoder to Swift.

Windows: a PyTorch path is tested on NVIDIA CUDA, with a CPU alternative. The card says this is not an ONNX or DirectML export.

In the Underdog app, a native Swift runtime reads the packed file directly with no Python and keeps audio on the device. Community conversions (MLX 4-bit and 8-bit, GGUF and ONNX) have already appeared on Hugging Face from third parties; treat those as unofficial.

Which Bark should you pick?

A trail of footprints, illustrating the step-by-step size and accuracy ladder of the Underdog Bark 3.0 model family

The family is built around a size and accuracy trade-off, according to the card, which says the Bark 3.0 family holds the accuracy frontier for open speech recognition at every size from 163 MB to 1.25 GB.

The Pro variant is reported to tie the best large model on the leaderboard average: Bark 3.0 Pro scores 4.286 against 4.291 for Hojo-ASR-V1, which is a 12 GB download. Again, those are differences in the third decimal, so read them as parity, not victory.

What is actually new here

Speech recognition has had a steady drift toward small, accurate, local models. Whisper large-v3 set the open standard, Parakeet and Canary pushed accuracy and speed with different architectures, and Qwen3-ASR and Granite Speech added multilingual and instruction-aware variants. Bark 3.0's pitch is packaging: a low-bit format that shrinks Parakeet's 2.5 GB to 163 MB without, per the card's numbers, losing average accuracy, plus a runtime that unpacks it fast enough to ship inside an app.

If those claims hold up on independent testing, the practical effects are:

• Bundling becomes feasible. A 163 MB asset can ship inside a mobile or desktop app without a separate model download step.
• Cloud transcription loses its cost argument for English. Local transcription removes per-minute fees and keeps audio on the device, which matters for meetings, medical notes and legal work.
• Latency drops. At about 41 times realtime on a laptop, a one-hour meeting would take on the order of a minute and a half, by the card's rate, though memory limits on long files mean chunking.

The caveat is that the model is English only, and meeting audio in the real world is messier than the benchmark's cleaned sets: the card notes it uses cleaned versions of AMI, Earnings-22, GigaSpeech and VoxPopuli.

Who should care

• Developers building private dictation or meeting notes who want a small, commercially usable model that runs on a laptop.
• Teams currently running Whisper large-v3 who care about speed and size: the card's claim of 41x realtime on an M2 and a 57x smaller download is the draw, with accuracy at least comparable on its chosen benchmarks.
• Not for: multilingual transcription, or workloads that need diarization, timestamps or translation, none of which the card describes.

What to check before adopting

1. Run your own audio, especially accented, noisy or domain-specific speech, through Bark 3.0, Parakeet and Whisper and compare word error rate.
2. Watch for the leaderboard submission: independent confirmation of the 4.94% average is the key missing piece.
3. Read the NOTICE file and comply with the CC-BY 4.0 attribution.
4. Test memory use on your target machine with your longest recordings.

Related reading

• Underdog private personal AI
• Underdog Saluki 2-bit GGUF models
• Gradium Phonon on-device TTS
• Tether on-device speech recognition
• Perplexity Computer fully local on Mac
• GPT-Live-1 voice API
• Official: Underdog Bark 3.0 on Hugging Face and NVIDIA Parakeet TDT 0.6B v3

Details are accurate as of October 22, 2026 and come from the model card. Benchmarks are self-reported.