NVIDIA Parakeet CTC 1.1B

NVIDIA Parakeet CTC 1.1B is an English automatic speech recognition (ASR) model designed for high-accuracy, non-autoregressive transcription. Developed jointly by NVIDIA NeMo and Suno.ai, it uses a FastConformer-CTC architecture with 1.1 billion dense parameters — meaning every parameter is active during inference, no routing or sparsity tricks. This model targets practitioners who need reliable, low-latency speech-to-text on their own hardware, without relying on cloud APIs.

Parakeet CTC 1.1B sits at the top end of the Parakeet family, which also includes a 0.6B variant. It competes with other open-weight ASR models like OpenAI Whisper large-v3 (1.5B parameters) and Meta’s Wav2Vec2-XLSR-53. Where Whisper uses a transformer encoder-decoder with autoregressive decoding, Parakeet CTC uses a connectionist temporal classification (CTC) head on a FastConformer encoder — this makes inference significantly faster because it decodes in a single forward pass rather than token-by-token. The tradeoff is that CTC models typically require a language model for best accuracy, though Parakeet CTC 1.1B already delivers state-of-the-art results without an external LM.

Trained on a 64,000-hour dataset combining public and proprietary English speech (including LibriSpeech, Fisher, Switchboard, Common Voice, VoxPopuli, and more), this model handles diverse accents, noise conditions, and domains — from clean read speech to conversational meetings and financial earnings calls.

Parakeet CTC 1.1B is built on the FastConformer architecture, an optimized variant of the Conformer model that uses a 2D-convolutional subsampling frontend and a stack of conformer blocks with self-attention and depthwise convolutions. The “Fast” prefix refers to architectural changes that reduce computational overhead without sacrificing accuracy — specifically, using grouped convolutions and a more efficient attention mechanism.

The model uses a CTC decoder, which outputs a sequence of character-level probabilities. During inference, the CTC algorithm collapses repeated characters and removes blanks to produce the final transcript. This is inherently non-autoregressive: the entire audio is processed in one shot, and the decoder produces all output logits in parallel. This makes Parakeet CTC 1.1B much faster than autoregressive models like Whisper, especially on longer audio clips.

Key specs:

• Parameters: 1.1B (dense, all active)
• Architecture: FastConformer encoder + CTC decoder
• Modality: Audio → text (English only)
• Context length: Not officially specified, but FastConformer can handle up to ~30 seconds of audio effectively (longer clips can be chunked)
• License: CC-BY-4.0 — free for commercial use, no restrictions
• Framework: NVIDIA NeMo (PyTorch), also available via Hugging Face Transformers

The model was trained using mixed precision (FP16/BF16) and supports inference in FP16 or FP32. It does not require a separate language model, though one can be added for marginal WER improvements.

Parakeet CTC 1.1B excels at transcribing English speech with exceptional accuracy across a wide range of scenarios. The published Word Error Rates (WER) on standard benchmarks tell the story:

These numbers are competitive with or better than Whisper large-v3 on most benchmarks, particularly on clean read speech and academic datasets. The model handles meeting transcription, lectures, phone conversations, financial earnings calls, and general dictation with high reliability. It is robust to background noise, music, and silence — a result of the diverse 64k-hour training set.

Concrete use cases:

• Real-time captioning for video or live events (low latency due to CTC)
• Meeting transcription for local tools (e.g., Otter.ai alternative)
• Voice-controlled applications where latency matters
• Medical dictation (with fine-tuning on domain data)
• Podcast and media transcription for searchable archives
• On-device speech-to-text for edge devices with a GPU

Because it’s English-only, it’s not suitable for multilingual transcription. If you need multilingual support, Whisper large-v3 is a better choice.

This is where Parakeet CTC 1.1B shines — it’s designed for efficient local inference. The CTC decoder means you don’t need an autoregressive beam search, which cuts inference time dramatically.

The model consumes about 2.1 GB of VRAM in FP16 (1.1B parameters × 2 bytes). In FP32, that doubles to ~4.2 GB. With typical inference overhead (activations, buffers), expect:

Minimum: Any GPU with 4 GB VRAM can run FP16 with chunked audio (e.g., GTX 1050 Ti). Realistically, you want at least an RTX 3060 12GB or M1 Mac with 16GB unified memory for comfortable operation with full-length audio.

Recommended: An RTX 4090 or M4 Max (64GB unified) will run FP16 inference on 30-second clips in under 100ms. For production batch processing, a Tesla T4 (16GB) or RTX 4070 is sufficient.

Because CTC decoding is non-autoregressive, the bottleneck is the encoder forward pass. On typical consumer hardware:

• RTX 3090 / 4090: ~200-300 tokens per second (audio seconds processed per second of wall time)
• RTX 3060 12GB: ~80-120 tokens/s
• M1 Max (32-core GPU): ~100-150 tokens/s
• M4 Max: ~180-250 tokens/s

These numbers are for FP16 inference with a batch size of 1. With batch processing (multiple audio clips), throughput scales nearly linearly up to VRAM limits.

For most local users, FP16 offers the best balance of accuracy and speed. The model’s WER degradation at INT8 is minimal (<0.5% absolute), making INT8 a good choice if VRAM is tight. INT4 quantization is possible with tools like bitsandbytes or NVIDIA TensorRT, but expect a WER increase of 1-2% — acceptable for less critical applications.

Ollama does not yet support Parakeet CTC models natively (it focuses on LLMs). Instead, use NVIDIA NeMo or the Hugging Face Transformers pipeline. The quickest local setup:

1pip install nemo_toolkit[asr]
2python -c "from nemo.collections.asr.models import EncDecCTCModelBPE; model = EncDecCTCModelBPE.from_pretrained('nvidia/parakeet-ctc-1.1b')"

Or via Transformers:

1from transformers import pipeline
2pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-ctc-1.1b")

• Apple Silicon: Works via PyTorch MPS backend. M1/M2/M3/M4 with unified memory are excellent — the model fits entirely in memory and runs fast.
• Windows/Linux: CUDA required. RTX 20xx and newer are ideal. Older GTX cards (10xx series) work but slower.
• No GPU? CPU inference is possible but very slow (~0.5x real-time). Not recommended for interactive use.

• Accuracy: Parakeet CTC 1.1B matches or beats Whisper on clean English benchmarks (e.g., LibriSpeech clean 1.83% vs Whisper’s ~2.0%). On noisy or accented speech, Whisper sometimes edges ahead due to its larger training set (1M+ hours) and multilingual support.
• Speed: Parakeet CTC is 2-5x faster on the same hardware because of CTC vs autoregressive decoding. For real-time applications, Parakeet wins decisively.
• Multilingual: Whisper supports 99 languages; Parakeet is English-only.
• VRAM: Parakeet is smaller (1.1B vs 1.5B) and uses less memory, especially in FP16.
• License: Both are permissive (CC-BY-4.0 for Parakeet, MIT for Whisper). No restrictions.

When to choose Parakeet: You need low-latency English transcription, are constrained on VRAM, or want faster inference on consumer GPUs.

When to choose Whisper: You need multilingual support, or you need the absolute best accuracy on very noisy or accented speech (though the gap is small).

• Accuracy: Parakeet is dramatically better — Wav2Vec2-XLSR-53 achieves ~8% WER on LibriSpeech clean vs Parakeet’s 1.83%.
• Speed: Wav2Vec2 is also CTC-based, so similar speed characteristics, but smaller model means faster inference.
• Use case: Wav2Vec2 is better for fine-tuning on low-resource languages (it was pretrained on 53 languages). Parakeet is strictly English.

When to choose Parakeet: You need state-of-the-art English ASR without fine-tuning.

The smaller sibling. Parakeet CTC 0.6B uses half the parameters, requires ~1.2 GB VRAM in FP16, and runs about 1.5x faster. WER is about 1-2% higher on most benchmarks. Choose the 0.6B if you’re on a low-end GPU or need maximum throughput; choose the 1.1B for maximum accuracy.