NVIDIA Parakeet TDT 0.6B v3

Our Take

A strong 0.6B-parameter dense audio model from NVIDIA. Treat the modality benchmarks above as the leading indicator of fit — composite scoring across modalities is still maturing.

Generated from this model’s benchmarks and ranking signals. Editor reviews refine it over time.

Parakeet TDT 0.6B v3 is built on the FastConformer encoder with a Transducer decoder (TDT). The encoder ingests 80‑channel log‑Mel filterbank features and outputs a frame‑level representation; the Transducer then jointly models alignment and language prediction, emitting text tokens as audio progresses.

• Dense architecture: All 600M parameters are active during inference. No MoE routing overhead, so batch‑size scaling is predictable and memory usage is linear.
• Context length: Not formally specified — Transducer models operate on a sliding window of audio frames, so effective context is limited by the encoder’s receptive field (typically ~4–6 seconds in FastConformer).
• Language support: 25 languages (en, es, fr, de, bg, hr, cs, da, nl, et, fi, el, hu, it, lv, lt, mt, pl, pt, ro, sk, sl, sv, ru, uk) with built‑in language ID.
• Training data: Trained on NVIDIA’s internal Granary dataset and the NeMo ASR Set 3.0.

The model is available in two library formats: nemo (the native NVIDIA NeMo toolkit) and transformers (Hugging Face integration). For local deployment, the transformers variant is the more accessible entry point because it works with standard inference pipelines and can be quantized using tools like optimum or llama.cpp (via conversion to GGUF).

Parakeet TDT 0.6B v3 is a speech‑to‑text model only — it does not generate language, translate, or perform any other NLP task. Its strengths are in accurate, low‑latency transcription across a broad European language set.

These WERs are competitive with models 2–3× larger. The model handles accented speech, meeting‑style multi‑speaker audio, and financial earnings calls without special fine‑tuning.

Concrete use cases:

• Real‑time captioning for webinars and live events
• On‑device voice assistants where latency must stay under 200 ms
• Batch transcription of multilingual archives (e.g., EU parliamentary recordings)
• Privacy‑sensitive pipelines where audio cannot leave the host machine

Because the model outputs text only (no punctuation or capitalization natively), a post‑processing step may be needed for polished transcripts. The newer “unified” variant of Parakeet adds punctuation, but this v3 model requires an external punctuation restoration model if that’s a requirement.

This model is extremely lightweight for a dense ASR system. Here’s what you need.

Best quantization for NVIDIA Parakeet TDT 0.6B v3: For most users, Q4_K_M strikes the best balance between accuracy and memory. WER degrades by less than 0.5 percentage points on clean English speech while freeing up VRAM for other processes. If you need maximum accuracy on challenging audio (accents, background noise), use Q8_0.

• Consumer GPUs: An RTX 3060 12 GB can run the FP16 model with headroom; a GTX 1060 6 GB can run Q4_K_M comfortably. The best GPU for NVIDIA Parakeet TDT 0.6B v3 is an RTX 4090 if you want to batch multiple streams — you can fit 8–10 simultaneous real‑time transcriptions at Q4_K_M.
• Apple Silicon: M2 or M3 Pro (18 GB unified memory) runs Q4_K_M with a real‑time factor (RTF) around 0.08–0.10, meaning one second of audio is processed in 80–100 ms. M4 Max will be faster but we lack specific benchmarks.
• CPU‑only: On a recent x86 CPU (e.g., AMD Ryzen 9) with Q4_K_M and 4‑thread inference, expect an RTF of 0.3–0.5 — usable for offline batch processing but not real‑time.

NVIDIA claims the highest throughput on the Open ASR leaderboard. In local tests (RTX 4090, FP16, batch size 1), the model processes at an RTF of ~0.04 — that’s 25× real‑time speed. Even on a laptop RTX 4060, RTF stays under 0.1.

If you need tokens‑per‑second numbers for text generation pipelines, note that this is an ASR model: it emits tokens at the rate of audio. A typical English utterance yields ~150 characters per second of audio, which translates to roughly 40‑50 text tokens per second. The inference engine itself can produce tokens much faster, but the audio input is the bottleneck.

Ollama doesn’t natively support ASR models yet, but you can run Parakeet TDT 0.6B v3 via the Hugging Face transformers pipeline with only a few lines of Python. For a script‑based setup:

For streaming, use the NeMo toolkit directly (requires installing nemo from GitHub). A GGUF conversion workflow is also possible via llama.cpp for CPU‑optimized inference, though it’s not officially supported by NVIDIA.

Choose Parakeet if you need streaming, lower latency, and work primarily with European languages. Choose Whisper medium for broader language support or if you don’t need real‑time output.

Distil‑Whisper is a distilled version of Whisper large‑v2 with a 0.8B parameter count. It’s faster than Whisper medium but still not streaming. Parakeet TDT 0.6B v3 is smaller, faster at inference, and supports streaming natively. Distil‑Whisper has better English-only WER on some benchmarks, but Parakeet matches or exceeds it on polyglot scenarios thanks to its 25‑language training.

For local deployments: If you need to run NVIDIA Parakeet TDT 0.6B v3 locally on a consumer GPU for real‑time multilingual transcription, this is the best fit. If your workload is English-only batch transcription and you already have a Whisper pipeline, Distil‑Whisper is a simpler drop‑in replacement.