# How the Parakeet Transcription Engine Differs from Whisper in Meetily

> Discover the key differences between the Parakeet transcription engine and Whisper in Meetily. Learn how Parakeet optimizes for real-time performance on CPU and GPU while Whisper focuses on accuracy yielding higher latency.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: deep-dive
- Published: 2026-07-19

---

**The Parakeet transcription engine in Meetily uses int8-quantized NVIDIA NeMo ONNX models optimized for real-time CPU and GPU inference, while Whisper relies on OpenAI's pretrained ONNX models that prioritize accuracy at the cost of higher latency and resource usage.**

Meetily supports two on-device speech-to-text (STT) engines: **Parakeet** and **Whisper**. Both run through the Tauri backend, yet they differ sharply in architecture, model management, and performance characteristics. Understanding these distinctions helps you choose the right engine for your hardware and latency requirements.

## Architecture and Model Foundations

### Parakeet: NVIDIA NeMo ONNX with Quantization

Parakeet is built around compact, quantized ONNX models from the NVIDIA NeMo ecosystem. According to the Meetily source code, the core Rust engine lives in [`frontend/src-tauri/src/parakeet_engine/parakeet_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/parakeet_engine/parakeet_engine.rs), where it handles model discovery, validation, and loading.

At startup, the engine scans a dedicated `parakeet` folder and validates required files before loading the model with the appropriate quantization type, either `Int8` or `FP32`. This logic appears in lines 14 through 48 of [`parakeet_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/parakeet_engine.rs). The default model, `parakeet-tdt-0.6b-v3-int8`, runs at approximately 20× real-time speed while retaining high accuracy.

### Whisper: OpenAI Pretrained Models

Whisper serves as the baseline STT engine in Meetily. It leverages the `whisper-rs` crate to load OpenAI's pretrained ONNX models stored under `frontend/models/` in development, or the platform-specific app data directory in production. The Rust backend exposes Whisper functionality through generic Tauri command wrappers such as `invoke('whisper_transcribe_audio')`.

Whisper offers multiple model sizes—`tiny`, `base`, `small`, `medium`, and `large`. Larger variants deliver higher accuracy at the expense of significantly increased latency and resource consumption.

## Performance and Latency

**Parakeet** delivers true real-time transcription. Its int8-quantized models process audio roughly 20× faster than real time on modern CPUs and GPUs, making the engine ideal for live captioning scenarios.

**Whisper** operates near real-time for smaller models like `tiny` or `base`, typically processing 1–2 seconds of audio per wall-clock second on a modern GPU. On CPU, latency increases several fold, and larger models such as `medium` or `large` can introduce substantial delays.

## Model Management and Download Experience

### Parakeet Built-in Download Pipeline

When a Parakeet model is missing, the engine downloads individual ONNX files directly from Hugging Face or the Meetily CDN. The download manager, implemented starting at line 292 in [`parakeet_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/parakeet_engine.rs), supports resume capabilities, progress callbacks, and corruption detection. The TypeScript front-end exposes model metadata and helper functions in [`frontend/src/lib/parakeet.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/lib/parakeet.ts).

Meetily also provides a dedicated UI component, [`frontend/src/components/ParakeetModelManager.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/components/ParakeetModelManager.tsx), for selecting and downloading models. Before recording begins, [`frontend/src/hooks/useRecordingStart.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/hooks/useRecordingStart.ts) verifies that the selected transcription engine is ready.

### Whisper Manual Setup

Whisper models require manual placement or a one-time download. Meetily does not provide a built-in download UI for Whisper models in the same way it does for Parakeet. Users must ensure the correct ONNX files exist in the expected directory before invoking transcription.

## Footprint and Accuracy Trade-offs

- **Parakeet download size**: 0.65 GB for int8 variants up to 2.55 GB for FP32 models, as defined in [`frontend/src/lib/parakeet.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/lib/parakeet.ts) at lines 65 through 86.
- **Whisper download size**: 0.1 GB for `tiny` to over 5 GB for `large`.
- **Parakeet accuracy**: Int8-quantized models retain more than 90% of FP32 accuracy.
- **Whisper accuracy**: Very high with `large` and `medium` models; noticeably lower with `tiny` and `base`.

## Code Examples

### Initializing and Loading a Parakeet Model

The TypeScript API in [`frontend/src/lib/parakeet.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/lib/parakeet.ts) provides a streamlined interface for model initialization:

```typescript
import { ParakeetAPI } from '@/lib/parakeet';

// Initialise the backend
await ParakeetAPI.init();

// Choose the recommended model for the current system
const modelName = 'parakeet-tdt-0.6b-v3-int8';

// Download if needed
await ParakeetAPI.downloadModel(modelName);

// Load the model into the Rust engine
await ParakeetAPI.loadModel(modelName);

```

### Transcribing Audio with Whisper

Whisper transcription is triggered through Tauri command bindings exposed in [`frontend/src/lib/whisper.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/lib/whisper.ts):

```typescript
import { invoke } from '@tauri-apps/api/core';

// `audioSamples` is a Float32Array of 16 kHz PCM data
const transcript = await invoke<string>('whisper_transcribe_audio', {
  audioData: Array.from(audioSamples)  // Tauri expects a plain array
});
console.log('Whisper result:', transcript);

```

## Summary

- **Parakeet** uses NVIDIA NeMo ONNX models with int8 quantization in [`frontend/src-tauri/src/parakeet_engine/parakeet_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/parakeet_engine/parakeet_engine.rs) to achieve real-time, low-latency transcription on modest hardware.
- **Whisper** relies on OpenAI pretrained models accessed via `invoke('whisper_transcribe_audio')`, favoring accuracy over speed, especially with larger variants.
- Parakeet offers a built-in download manager with resume support and a dedicated UI component, while Whisper requires manual model management.
- Choose **Parakeet** for live captioning and constrained environments; choose **Whisper** when transcription fidelity is paramount and GPU resources are available.

## Frequently Asked Questions

### Does Meetily download Parakeet models automatically?

Yes. If a Parakeet model is missing, the backend downloads individual ONNX files from Hugging Face or the Meetily CDN with resume support and progress callbacks. This logic resides in [`frontend/src-tauri/src/parakeet_engine/parakeet_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/parakeet_engine/parakeet_engine.rs) starting at line 292.

### Which engine uses less disk space in Meetily?

Parakeet's default int8 model requires approximately 0.65 GB, while Whisper's `tiny` model uses only 0.1 GB. However, Whisper's `large` model exceeds 5 GB, whereas Parakeet's largest FP32 variant caps at 2.55 GB according to [`frontend/src/lib/parakeet.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/lib/parakeet.ts).

### Can Parakeet run on CPU-only machines?

Yes. Parakeet's int8-quantized ONNX models are optimized for CPU-friendly inference and do not require a GPU. Whisper can also run on CPU, but latency increases significantly with model size.

### When should I switch from Whisper to Parakeet in Meetily?

Switch to Parakeet when you need instant transcription during live meetings or when running on hardware without a dedicated GPU. Stick with Whisper's larger models for offline processing of longer recordings where maximum accuracy is the priority.