# NVIDIA Parakeet vs Whisper on Mac: Choose a Local Transcription Model

> NVIDIA Parakeet vs Whisper on Mac: compare four checkpoints including Parakeet v3, languages, published accuracy, and runtimes such as MLX Whisper.

NVIDIA Parakeet TDT can look like the right Whisper alternative until it misses your language or workflow. The runtime on your Mac matters as much as the checkpoint.

**Short answer:** Choose Parakeet TDT v3 if your audio is in one of its 25 supported European languages and you want a 600M-parameter model with word timestamps. Choose Whisper large-v3 when you need broad language coverage or translation into English; choose large-v3-turbo when you want a smaller Whisper checkpoint. In the Open ASR Leaderboard paper’s English tables, Parakeet v3 has lower average WER than both Whisper checkpoints, and on short-form audio it runs 17–23 times faster on the same GPU; on five European languages it ties Whisper large-v3 on WER. Those GPU speeds do not predict performance on your Mac, so pick a runtime, then compare both models on the clips you actually transcribe.

## What is NVIDIA Parakeet TDT, and how does it differ from Whisper?

Parakeet TDT uses a FastConformer audio encoder and a Token-and-Duration Transducer decoder. Whisper uses an encoder-decoder Transformer that generates text one token at a time. TDT predicts how long a token covers and can skip those audio frames while decoding. [The TDT paper](https://proceedings.mlr.press/v202/xu23g/xu23g.pdf) describes that frame-skipping mechanism; [the Whisper paper](https://proceedings.mlr.press/v202/radford23a/radford23a.pdf) describes its encoder-decoder design.

![Diagram comparing Whisper’s autoregressive decoder with NVIDIA Parakeet TDT’s token-and-duration frame skipping](/blog/nvidia-parakeet/architecture.svg)

That architecture helps explain Parakeet’s published throughput; it does not prove better transcripts for your audio. Whisper covers 99 languages according to the [large-v3 model card](https://huggingface.co/openai/whisper-large-v3), and the [Whisper README](https://github.com/openai/whisper/blob/main/README.md) documents speech translation into English. [Parakeet v3 detects one of its supported languages automatically](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3), and its model card warns that accuracy varies with accent, noise, domain, and speech type. Don’t infer that either model never invents words during silence; the benchmark figures below do not measure that behavior.

## How do Parakeet v2, v3, Whisper large-v3, and turbo compare?

The Open ASR Leaderboard paper (arXiv v4, March 30, 2026) reports all four checkpoints on short-form English and three of them on long-form English. WER is lower-is-better; RTFx is how many seconds of audio the model transcribes per second of compute, so higher is faster.

| Checkpoint             | Parameters | Languages   | License                                                | English short-form WER / RTFx | English long-form WER / RTFx |
| ---------------------- | ---------: | ----------- | ------------------------------------------------------ | ----------------------------: | ---------------------------: |
| Parakeet TDT v2        |       600M | English     | CC BY 4.0                                              |                 6.05% / 3,390 |    not in the paper’s subset |
| Parakeet TDT v3        |       600M | 25 European | CC BY 4.0                                              |                 6.32% / 3,330 |                10.7% / 1,000 |
| Whisper large-v3       |      1.55B | 99          | MIT in OpenAI’s repo; HF card metadata says Apache-2.0 |                   7.44% / 146 |                 11.2% / 68.6 |
| Whisper large-v3-turbo |       809M | 99          | MIT                                                    |                   7.83% / 200 |                  11.0% / 148 |

On the paper’s multilingual table, which averages German, French, Italian, Spanish, and Portuguese, Parakeet v3 and Whisper large-v3 both score 4.81% average WER, at an RTFx of 1,720 and 111. Parakeet is ahead on German and French, Whisper on Italian, Spanish, and Portuguese. The scores come from Tables 3–5 of the [leaderboard paper](https://arxiv.org/abs/2510.06961), which runs every model on one NVIDIA A100-SXM4-80GB, at batch size 64 when memory allows and smaller batches otherwise. Treat RTFx as a same-hardware comparison, not an Apple Silicon estimate, and check the live leaderboard for newer rows.

[The v2 card](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v2) lists English-only transcription, while [NVIDIA’s v3 card](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3) names 25 languages: Bulgarian, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Italian, Latvian, Lithuanian, Maltese, Polish, Portuguese, Romanian, Russian, Slovak, Slovenian, Spanish, Swedish, and Ukrainian.

[OpenAI’s Whisper README](https://github.com/openai/whisper/blob/main/README.md) says the weights and code use MIT. The Hugging Face [large-v3 card](https://huggingface.co/openai/whisper-large-v3) currently labels its metadata Apache-2.0, so check the governing files for your intended distribution rather than relying on a comparison table alone. Turbo’s [model card](https://huggingface.co/openai/whisper-large-v3-turbo) lists MIT.

[Both Parakeet cards](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v2) document automatic punctuation and capitalization plus word-level timestamps. Whisper provides timestamped segments; [mlx-whisper’s README](https://github.com/ml-explore/mlx-examples/blob/main/whisper/README.md) documents word-level timestamps in its transcription output. Large-v3-turbo is a pruned large-v3 with four decoder layers instead of 32, according to its model card. Its smaller size trades some accuracy for throughput.

## Which model should I choose for languages, translation, or long recordings?

Use your required language and output first, then treat benchmark scores as a tie-breaker.

| Pick                   | When it fits                                                                                  | Cost or limit                                                                                                                                                                                   |
| ---------------------- | --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Parakeet TDT v2        | English-only transcription with punctuation and word times                                    | No multilingual coverage                                                                                                                                                                        |
| Parakeet TDT v3        | One of its 25 listed European languages; you want the TDT architecture and word times         | Cannot transcribe Hindi, Thai, Japanese, Arabic, or Chinese as supported languages; the model card says it detects the language without a prompt, so plan to check misdetections on short clips |
| Whisper large-v3       | A language from Whisper’s 99-language list, or translation of non-English speech into English | 1.55B parameters; larger checkpoint                                                                                                                                                             |
| Whisper large-v3-turbo | Whisper language coverage with a pruned 809M checkpoint                                       | Turbo is not trained for translation; use full large-v3 for that task                                                                                                                           |

For long recordings, distinguish model limits from the runtime’s chunking. [NVIDIA says Parakeet v3 supports up to 24 minutes with full attention on an 80 GB A100, or up to three hours with local attention](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3). [V2’s card](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v2) says up to 24 minutes per pass. Whisper’s [original paper](https://proceedings.mlr.press/v202/radford23a/radford23a.pdf) describes 30-second input segments; its [official README](https://github.com/openai/whisper/blob/main/README.md) documents the long-audio transcription path. On a Mac, test the runtime’s memory use and chunk behavior with a full-length recording before choosing a production workflow.

## How can I run Parakeet or Whisper locally on a Mac?

Prerequisites: FluidAudio’s Swift package declares macOS 14+ and Swift tools 6.0. MLX paths target Apple Silicon, and a [parakeet-mlx issue](https://github.com/senstella/parakeet-mlx/issues/16) reports a macOS 14 failure caused by an API available in macOS 15, so use macOS 15+ for that path unless you verify a compatible MLX version. whisper.cpp supports Intel and Apple Silicon Macs. The package READMEs do not pin a common set of Python/MLX versions.

The commands below are **docs-only**: their READMEs document them, but we did not install or run any model for this article. First runs may download gigabytes of weights, so check the chosen model’s disk and memory needs first.

**Parakeet through Core ML and FluidAudio:** choose this Swift runtime when you want its Core ML pipeline, which can use Apple’s Neural Engine. In a FluidAudio checkout, the documented CLI form is:

```sh
swift run fluidaudiocli transcribe meeting.wav
```

Expected result: a transcript is printed for the WAV file; the first model load downloads the Core ML assets. The [FluidAudio README](https://github.com/FluidInference/FluidAudio) documents this path and its v3 model. This requires a Swift project or the repository checkout; it is not a general-purpose shell package install.

**Parakeet MLX:** choose this Python CLI for an Apple Silicon GPU path. Install `ffmpeg` first, as the README requires, then run:

```sh
brew install ffmpeg
uv tool install parakeet-mlx -U
parakeet-mlx meeting.wav --output-format txt
```

Expected result: a text transcript file for `meeting.wav`; the default model is `mlx-community/parakeet-tdt-0.6b-v3`. The [parakeet-mlx README](https://github.com/senstella/parakeet-mlx) documents installation, output formats, and the default checkpoint.

**MLX Whisper:** choose this route if you want Whisper on the Apple Silicon GPU and a Python API. Install and transcribe with a converted turbo checkpoint:

```sh
brew install ffmpeg
python -m pip install mlx-whisper
mlx_whisper meeting.wav --model mlx-community/whisper-large-v3-turbo
```

Expected result: the CLI writes a transcript file; the [MLX Whisper README](https://github.com/ml-explore/mlx-examples/blob/main/whisper/README.md) documents the package and CLI, and the [converted turbo checkpoint](https://huggingface.co/mlx-community/whisper-large-v3-turbo) is available from the MLX Community. For word timestamps, use its Python API with `word_timestamps=True`.

**Whisper through whisper.cpp:** choose this C/C++ runtime for a native CLI with Metal and optional Core ML encoder support. From its repository:

```sh
git clone https://github.com/ggml-org/whisper.cpp
cd whisper.cpp
sh ./models/download-ggml-model.sh base.en
cmake -B build
cmake --build build -j --config Release
./build/bin/whisper-cli -f samples/jfk.wav
```

Expected result: the sample transcript appears in the terminal. This quick start uses `base.en`, an English-only 74M-parameter checkpoint; pick a supported multilingual GGML model for a Whisper large-v3 comparison. The [whisper.cpp README](https://github.com/ggml-org/whisper.cpp) documents Metal and Core ML support. To build its optional Core ML encoder on Apple Silicon, follow the same repository setup, then run:

```sh
python3.11 -m pip install ane_transformers openai-whisper coremltools
./models/generate-coreml-model.sh base.en
cmake -B build -DWHISPER_COREML=1
cmake --build build -j --config Release
./build/bin/whisper-cli -m models/ggml-base.en.bin -f samples/jfk.wav
```

Expected result: the terminal prints a transcript and reports that the matching Core ML encoder loaded. The first load may compile the model for the Neural Engine. The README says this encoder can run more than 3× faster than CPU-only execution, but gives no matched Mac benchmark in that statement.

The [FluidAudio benchmark log](https://github.com/FluidInference/FluidAudio/blob/main/Documentation/Benchmarks.md) reports Parakeet v3 at 155.6× overall RTFx and 2.5% average WER on the 2,620-file, 5.40-hour LibriSpeech test-clean set, measured on a 2024 M4 Pro with 48 GB RAM and macOS 26.0.

That result belongs to FluidAudio’s setup; neither MLX README publishes a controlled Mac speed figure. These numbers do not form an apples-to-apples runtime comparison. All commands here remain unverified on this machine.

On macOS 14, a [parakeet-mlx issue](https://github.com/senstella/parakeet-mlx/issues/16) reports a crash on a Metal API added in macOS 15; upgrade the OS or use a compatible MLX version. If streaming `add_audio()` raises a `TypeError`, [another issue](https://github.com/senstella/parakeet-mlx/issues/49) says to convert NumPy input with `mx.array(...)`.

If whisper.cpp’s Core ML model fails to load, match its encoder bundle to the selected checkpoint; one [Mac issue](https://github.com/ggml-org/whisper.cpp/issues/2802) collects run-time Metal kernel errors on Apple Silicon, so note your macOS and Xcode versions if you hit one. These are reported cases, not universal failures.

## What should I test before replacing Whisper?

Run the same audio through each candidate with the same normalization and note both transcript corrections and wall-clock time.

Use 10–20 clips from your own work: quiet dictation, background noise, names or technical terms, short pauses, and a long recording. Keep each reference transcript.

For each runtime, record the model/version, language, audio duration, first-run download, time to first text, total time, peak memory if available, and word errors. Compare punctuation separately because the leaderboard normalizes punctuation and casing away. Repeat each clip twice so model loading is not mistaken for transcription speed.

If you need a fixed output language, custom vocabulary, or reliable behavior on silence, include those exact cases. [NVIDIA’s model card](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3) warns that words absent from its language model may be missed; Vext’s product implementation also uses a separate optional vocabulary booster. Our earlier [on-device speech recognition note](/blog/why-we-run-speech-recognition-fully-on-device) explains why we keep the audio path local, but it is not a substitute for measuring your own terms and accents.

## What does this choice look like in Vext?

We build Vext, a Mac voice-to-text app that uses Parakeet TDT v3 through FluidAudio and Core ML on Apple’s Neural Engine. Its Parakeet download is about 483 MB and covers the same 25 European languages; other languages route to Apple Speech, and Vext does not bundle local Whisper.

We have also written about [Vext’s two-pass diarization and language support](/blog/vext-1-2-0-two-pass-diarization-and-five-languages). Its README says “~150x realtime” without recorded test conditions; the closest measured figure is FluidAudio’s own 155.6× on an M4 Pro above, for the library Vext runs, not for Vext itself.

If your language is in Parakeet v3’s list, start with Parakeet and a Mac runtime you can maintain. If you need Whisper’s broader language support or translation-to-English, use large-v3; if you need the smaller Whisper variant and do not need translation, compare turbo. Then keep the winner only if it improves your transcripts on your own audio.

— Don

---

_Try the same clips with both engines and share your model, runtime, and hardware notes with us on [GitHub](https://github.com/Muvon)._
