Run NVIDIA Parakeet locally on Apple Silicon: MLX, Core ML and NeMo
Run NVIDIA Parakeet TDT 0.6B locally on a Mac: parakeet-mlx CLI and API, FluidAudio Core ML, NeMo on CPU, speed vs Whisper, the 25 v3 languages and errors.
NVIDIA's Parakeet TDT 0.6B runs well on an Apple Silicon Mac, and the fastest way to try it is pip install parakeet-mlx followed by parakeet-mlx audio.wav. This guide covers the three working routes, MLX through parakeet-mlx, Core ML through FluidAudio, and NVIDIA's own NeMo toolkit on the CPU, with the verified install lines, the flags that matter, audio preparation, what speed to expect against whisper.cpp, the language list for the v3 model, and the errors people hit. Everything runs offline after the one-time model download.
If you are deciding between the two model families rather than setting one up, read Whisper vs Parakeet first.
What Parakeet TDT is
Parakeet is NVIDIA's family of open speech recognition models, trained and released through the NeMo toolkit. The two models this guide is about are:
nvidia/parakeet-tdt-0.6b-v2: English only, 600 million parameters.nvidia/parakeet-tdt-0.6b-v3: 25 European languages, same size, and it detects the language of the audio itself, so there is no language flag to set.
Both use a FastConformer encoder and a TDT decoder. TDT stands for token-and-duration transducer, from the paper "Efficient Sequence Transduction by Jointly Predicting Tokens and Durations": instead of emitting one token per audio frame the decoder also predicts how many frames to skip, which is a large part of why the model is so quick. Output includes punctuation and capitalization, and both models produce word and segment timestamps. Input is 16 kHz mono audio; the model cards list WAV and FLAC.
The models are released under CC-BY-4.0 on Hugging Face, which permits commercial use with attribution. The v3 card reports a mean word error rate of 6.32% and an RTFx of 3,332.74 on the Hugging Face Open ASR leaderboard; the v2 card reports 6.05% and an RTFx of 3,380. Those speed figures were measured with a batch size of 128 on data-center GPUs and do not transfer to a laptop, but the ranking against Whisper does, as the speed section explains. The v3 card also says the model needs at least 2 GB of memory to load and handles audio up to 24 minutes with full attention, or up to about three hours with local attention.
Three ways to run it on a Mac
| Route | Runtime | Install effort | Hardware used | Best for |
|---|---|---|---|---|
| A: parakeet-mlx | MLX (Python) | One pip or uv command | GPU via Metal | Command-line transcription, scripts, subtitles |
| B: FluidAudio | Core ML (Swift) | Swift package, swift run |
Neural Engine | Building a Mac or iOS app |
| C: NeMo | PyTorch (Python) | Large dependency tree | CPU, MPS partly | Matching NVIDIA's reference exactly |
Route A: parakeet-mlx
parakeet-mlx by senstella is an implementation of Parakeet for Apple Silicon on MLX, Apple's array framework. It is on PyPI as parakeet-mlx, requires Python 3.10 or newer, and is Apache 2.0 licensed. The CLI decodes audio through ffmpeg, so install that first:
brew install ffmpeg
Then install the package. The README recommends uv; plain pip works too:
uv tool install parakeet-mlx -U # CLI only, isolated
# or
pip install parakeet-mlx -U
Transcribe a file:
parakeet-mlx interview.mp3
On the first run it downloads the model from Hugging Face. As of writing the default is mlx-community/parakeet-tdt-0.6b-v3, a 2.51 GB safetensors file in float32; the English-only conversion is mlx-community/parakeet-tdt-0.6b-v2 at 2.47 GB. Both carry the original CC-BY-4.0 license. The output format defaults to SRT, written next to the input.
The flags you will actually use:
--model mlx-community/parakeet-tdt-0.6b-v2selects a different conversion.--output-format txt(alsosrt,vtt,json, orall) and--output-dir ./out.--highlight-wordsadds word-level highlighting to SRT and VTT output.--chunk-duration 120and--overlap-duration 15control how long files are split; these are the defaults in seconds.--fp32runs in full precision; the default--bf16is faster and uses less memory.--decoding beamwith--beam-sizeenables beam search instead of greedy decoding.--verboseprints progress.
A subtitle job for a folder of recordings in one command:
parakeet-mlx *.m4a --output-format vtt --highlight-words --output-dir ./subs
The Python API is a few lines:
from parakeet_mlx import from_pretrained
model = from_pretrained("mlx-community/parakeet-tdt-0.6b-v3")
result = model.transcribe("audio_file.wav")
print(result.text)
print(result.sentences) # AlignedSentence objects with start, end and tokens
result.sentences gives sentence-level timing, and each sentence carries its tokens with their own timestamps. Check the README for the current flag list; the project moves quickly.
Route B: FluidAudio (Core ML)
FluidAudio by FluidInference is a Swift SDK for local audio models on Apple devices, with inference on the Neural Engine. It ships Core ML conversions of Parakeet TDT v3 (and v2 for English), plus voice activity detection, speaker diarization and text-to-speech. It is Apache 2.0 and requires Swift 6.
It is a library first, but the repository includes a command-line target you can run without writing Swift:
git clone https://github.com/FluidInference/FluidAudio.git
cd FluidAudio
swift run fluidaudiocli transcribe audio.wav
swift run fluidaudiocli transcribe audio.wav --model-version v2
The first swift run compiles the package, which takes a few minutes, and the first transcription downloads the model from Hugging Face; the repositories are FluidInference/parakeet-tdt-0.6b-v3-coreml and FluidInference/parakeet-tdt-0.6b-v2-coreml. Core ML then compiles the model for your chip on first load, which is another one-time wait. The README claims roughly 190 times real time on an M4 Pro, or about 19 seconds for an hour of audio, once everything is warm.
To use it in your own app, add the package and call the ASR manager:
// Package.swift
dependencies: [
.package(url: "https://github.com/FluidInference/FluidAudio.git", from: "0.12.4"),
],
let models = try await AsrModels.downloadAndLoad(version: .v3)
let asrManager = AsrManager(config: .default)
try await asrManager.loadModels(models)
let result = try await asrManager.transcribe(samples) // 16 kHz mono Float samples
print(result.text)
The version pin and the exact API change between releases, so copy the current snippet from the README rather than from here. The Documentation folder in the repository has the CLI and API references.
Route C: NeMo on the CPU
NVIDIA's NeMo toolkit is the reference implementation and the one the model cards document. It is a heavy install: PyTorch plus a long list of audio and training dependencies, and the model card's install line pulls all of it.
python3 -m venv nemo-env && source nemo-env/bin/activate
pip install -U "nemo_toolkit[asr]"
As of writing the NeMo repository asks for Python 3.12 or newer, and its README spells the package nemo-toolkit; both spellings resolve on PyPI. Then the transcription snippet from the model card:
import nemo.collections.asr as nemo_asr
asr_model = nemo_asr.models.ASRModel.from_pretrained(model_name="nvidia/parakeet-tdt-0.6b-v3")
output = asr_model.transcribe(["interview.wav"])
print(output[0].text)
# with timestamps
output = asr_model.transcribe(["interview.wav"], timestamps=True)
On a Mac this runs on the CPU by default. NeMo's documentation says the mps device works with PyTorch 2.0 or newer if you set PYTORCH_ENABLE_MPS_FALLBACK=1, because not every operation is implemented on Metal yet, and then ask for the device in the script or with allow_mps=true in NeMo's own evaluation scripts. Expect it to be much slower than routes A and B and to use more memory. It is the route to choose when you need behavior identical to NVIDIA's, for instance to compare word error rates, or to run the change_attention_model call that switches the encoder to local attention for multi-hour files.
Audio preparation
All three routes want 16 kHz mono. parakeet-mlx converts through ffmpeg for you, FluidAudio's CLI handles common formats, and NeMo expects WAV or FLAC at the right rate. Converting first removes a whole class of errors and is a one-liner:
ffmpeg -i input.m4a -ar 16000 -ac 1 -c:a pcm_s16le input.wav
For a folder:
for f in *.mp3 *.m4a; do
[ -e "$f" ] || continue
ffmpeg -i "$f" -ar 16000 -ac 1 -c:a pcm_s16le "${f%.*}.wav"
done
Speed: Parakeet against whisper.cpp large-v3-turbo
The Open ASR leaderboard is the common reference. Its RTFx column (hours of audio per hour of compute, higher is faster) puts Parakeet TDT 0.6B v2 at 3,380 and v3 at 3,332.74, against 68.56 for Whisper large-v3 on the same hardware. large-v3-turbo narrows that with a smaller decoder, but the gap is still an order of magnitude, and the reason is structural: Whisper's decoder generates one token at a time with attention over the whole encoder output, while a TDT decoder skips ahead by predicted durations.
On a Mac the absolute numbers are far lower and depend on the chip, memory, and whether the model is warm. Rough expectations from published runs and typical reports, for an hour of clean audio:
| Setup | Hour of audio takes | Notes |
|---|---|---|
| parakeet-mlx, bf16, M-series | Under a minute on recent chips | Plus model load each run |
| FluidAudio, Core ML, M4 Pro | About 19 seconds (README claim) | After one-time Core ML compile |
whisper.cpp large-v3-turbo, Metal |
A few minutes | See the whisper.cpp guide |
| NeMo on CPU | Considerably longer | Reference behavior, not speed |
Measure your own with time on a file you know. The Whisper vs Parakeet comparison goes into accuracy as well as speed.
Language coverage
Parakeet v2 is English only. The v3 model card lists these 25 languages, with automatic detection:
| Language | Code | Language | Code |
|---|---|---|---|
| Bulgarian | bg | Latvian | lv |
| Croatian | hr | Lithuanian | lt |
| Czech | cs | Maltese | mt |
| Danish | da | Polish | pl |
| Dutch | nl | Portuguese | pt |
| English | en | Romanian | ro |
| Estonian | et | Russian | ru |
| Finnish | fi | Slovak | sk |
| French | fr | Slovenian | sl |
| German | de | Spanish | es |
| Greek | el | Swedish | sv |
| Hungarian | hu | Ukrainian | uk |
| Italian | it |
That is the European set plus Russian and Ukrainian. There is no Chinese, Japanese, Korean, Arabic, Hindi, Turkish or any other language outside the table; audio in those languages produces nonsense, not an error. Whisper's multilingual models cover roughly a hundred languages and remain the local choice for anything outside this list.
Known limitations
- Timestamps vary by tool. NeMo returns char, word and segment timestamps with
timestamps=True, and parakeet-mlx exposes token timings through its result objects and--highlight-words. Check the FluidAudio documentation for what its result type carries; not every wrapper surfaces word timing. - Long files are chunked. parakeet-mlx splits at 120 seconds with 15 seconds of overlap by default, and merges the pieces; a word on a boundary can occasionally be dropped or doubled. NeMo with full attention handles about 24 minutes in one pass on a large GPU and less on a Mac; beyond that you need local attention or your own chunking.
- Memory. The float32 weights are about 2.5 GB on disk, and loading briefly needs that plus working space, so plan for 2 to 3 GB during load and less once the model settles into bf16. An 8 GB Mac copes if little else is running.
- No prompt or vocabulary hint. Unlike Whisper's
--prompt, the Parakeet CLIs have no way to steer spelling of names and jargon. Fix those in post, or choose Whisper when a vocabulary list matters. - Cold starts. Every route loads a 2.5 GB model per process. For a batch of files, transcribe them in one invocation (parakeet-mlx accepts several paths) rather than in a shell loop.
Common errors
ffmpeg: command not found or "CLI won't work properly". parakeet-mlx decodes audio through ffmpeg. brew install ffmpeg and open a new terminal.
No module named mlx or a wheel that will not install. MLX only builds for Apple Silicon Macs on a recent macOS. An Intel Mac, or a Python running under Rosetta, cannot use route A; check python3 -c "import platform; print(platform.machine())" prints arm64.
Very slow first run. That is the model download (about 2.5 GB) and, for FluidAudio, the one-time Core ML compile. The second run is the real speed.
Gibberish on a language you expected to work. The language is outside the 25 in the table, or you loaded the English-only v2 conversion. Pass --model mlx-community/parakeet-tdt-0.6b-v3 explicitly.
A sentence missing or repeated near the two-minute mark. Chunk boundary. Raise --chunk-duration if memory allows, or increase --overlap-duration, then re-run.
Process killed or "out of memory" during load. Close memory-hungry apps, use the default bf16 rather than --fp32, and avoid running two model loads at once.
If you'd rather not maintain this
Frequently asked questions
Is Parakeet faster than Whisper on a Mac?
In every local benchmark the transducer architecture is several times faster than Whisper at similar accuracy, and on the Open ASR leaderboard the gap is more than an order of magnitude. On Apple Silicon a warm Parakeet through MLX or Core ML transcribes an hour of audio in well under a minute on recent chips, where whisper.cpp with large-v3-turbo needs a few minutes.
Does Parakeet support languages other than English?
The v3 model handles 25 European languages including Russian and Ukrainian, detected automatically, and the v2 model is English only. Neither covers Chinese, Japanese, Korean, Arabic, Hindi or other languages outside Europe. For those, Whisper's multilingual models are the local option.
Can I use Parakeet commercially?
The NVIDIA model cards for both v2 and v3 state the CC-BY-4.0 license, which allows commercial use as long as you credit the source. The MLX and Core ML conversions on Hugging Face carry the same license, and the parakeet-mlx and FluidAudio code is Apache 2.0.
How much memory does Parakeet TDT 0.6B need?
The model card asks for at least 2 GB to load, and the float32 weights are about 2.5 GB on disk. In practice budget 2 to 3 GB during load and somewhat less at run time in bf16. It runs on an 8 GB Mac; 16 GB gives comfortable room for long files and larger chunks.
