The details — how Parleq works

Capture

on-device

AVAudioEngine taps the system microphone at the hardware sample rate and converts each buffer in-line to 16 kHz mono Int16 — the format the local ASR model expects. Audio is accumulated as raw samples in process memory; nothing is ever written to disk.

Bluetooth-aware

When the system default input is Bluetooth, Parleq overrides to the built-in mic so your music stays in A2DP instead of dropping to HFP/SCO mid-dictation.

Pre-warm

The audio unit is instantiated at app launch and a 250 ms silent capture cycle runs once after the speech model finishes loading. This pays the cold-start cost so your first real dictation isn't a 90 ms first-buffer stub.

Live level meter

Per-buffer RMS is computed on the audio thread and pushed to the overlay so the sound-wave bars animate with your actual voice.

Hears you — or says so

If the microphone stops delivering audio mid-dictation, the overlay warns you ("not hearing your mic") instead of you finding out only when nothing pastes.

Survives device changes

If another app flips your input to a multi-channel format, or your audio device changes mid-dictation, Parleq rebuilds the capture on the fresh format and keeps the audio you already spoke — no more silently-empty captures. Lost one anyway (a hasty Esc, a wrong key)? Hold the hotkey and tap R to re-run your last dictation.

Transcribe

on-device · Apple Neural Engine

The audio buffer is handed directly to Parakeet TDT v3 (CoreML) running on the Apple Neural Engine, in-process. Typical latency is ~64 ms for a 5-second clip after the model is warm. The model resides at ~150 MB and downloads from Hugging Face on first launch.

Custom dictionary biasing

Terms you've added in Settings are passed to FluidAudio's CTC keyword-spotting + rescoring pass, which runs after the TDT transcription. Aliases for variant spellings ("parlay", "parlez") all match the canonical "Parleq" — the rescorer always emits the canonical form.

Per-term opt-out

A term whose phonetics overlap a common word (and so triggers false positives at the speech-recognition layer) can be marked LLM-only. The transcribe stage skips it; the LLM hint still applies.

Tell sound-alikes apart by voice

Some names sound almost exactly like an everyday word — a product called "Keavi" against the fruit "kiwi", or "Claude" against "clawed." You can optionally teach a term in your own voice: read a few short sentences aloud once, and Parleq learns the sound of you saying it. On later dictations it disambiguates by sound — recovering the right name, and, just as importantly, leaving the common word alone when that's what you actually said. Entirely on-device, no LLM, no cloud. Opt-in per term — try the interactive Voice enrollment demo on the homepage explorer.

Local-only, no listening sockets

No cloud transcription. No per-call cost. No cold-start delay once the model has loaded. Audio bytes never leave your Mac — they aren't even handed across a process boundary. Parleq has no listening sockets bound on the default ASR path; reviewers can verify with `lsof -i -nP -a -p $(pgrep -n ParleqApp)`.

Clean up

Instant · Polished · Raw

Cleanup turns the raw transcript into finished text — the raw shows in the overlay first, and the cleaned text replaces it progressively as it arrives. How much cleanup happens is up to you: three modes.

Instant is a fast, deterministic on-device pass — spoken numbers become digits, spoken punctuation (say “comma”, “period”, or “question mark” and it writes the mark), names and jargon from your dictionary are fixed by how they sound, split compounds rejoined — with no network and no wait. Polished hands the transcript to a real model for the full treatment (fillers, casing, self-corrections, tone): your own cloud (Gemini, OpenAI, Bedrock, Vertex, or Azure) or an on-device model via Apple MLX — Gemma 4 E4B or the lighter Qwen3-4B (one-time ~2.4–4 GB download depending on model; 8 GB+ RAM). Raw skips cleanup and pastes the transcript exactly as the on-device speech model emitted it.

Press Enter while the raw is still showing to accept it as-is; press Enter once cleanup is under way and Parleq finishes the pass and pastes the complete cleaned text — never a half-streamed fragment.

Pluggable providers

Eight options: Lightweight (a fast deterministic on-device corrector built on Concord by Keavi — no download, no RAM floor, but no free-form rewriting), On-device LLM (Gemma 4 E4B or the lighter Qwen3-4B via Apple MLX — no network boundary, no per-call cost, one-time ~2.4–4 GB download depending on model, 8 GB+ RAM), Google Gemini direct API (default — free tier^†, ~500–700 ms TTFT), OpenAI direct API (GPT-4o / GPT-4.1 family), Google Vertex AI (Gemini + Claude on GCP with IAM + audit logs), AWS Bedrock (Claude or GPT-OSS via your AWS account), Azure OpenAI (GPT-4o / GPT-4.1 + reasoning models on Microsoft's contract), or skip cleanup entirely and paste raw ASR. The choice is made in Settings or via the first-run setup wizard. For IT-deployed Macs, the provider and allowed model list can be pinned centrally via an MDM-managed configuration profile so users cannot change it.

Auth flexibility per provider

Each cloud supports both pasted API keys (stored in the macOS Keychain) and your existing CLI session — gcloud Application Default Credentials for Vertex (or service-account JSON), AWS SSO / static IAM keys / scoped Bedrock API keys for Bedrock, az login or resource keys for Azure. Parleq never stores long-lived cloud session tokens directly; the AWS/GCP/Azure CLIs handle refresh through their own caches.

Skippable

Re-run the setup wizard (menu bar → Run Setup…) and choose "None — skip cleanup", or set llm.provider to "none" in ~/.parleq/config.json (IT can pin it via managed configuration). The in-app Settings picker lists only real providers. Parleq will then paste the raw transcript exactly as the on-device speech model emitted it. Useful when transcript content must never leave the device.

Custom dictionary hint

Your dictionary feeds a smart-vocabulary addendum to the cleanup prompt — terms with optional context blurbs and aliases. The LLM judges topic alignment and prefers your canonical spellings without force-correcting genuine homophones.

Learns from your corrections

When you repeatedly fix the same name or phrase, Parleq notices. The opt-in "Learn from corrections" feature keeps short correction snippets in memory (never written to disk) and occasionally asks your already-configured cleanup model to suggest dictionary improvements — no new service, no new network destination. High-confidence spelling fixes apply automatically (and are revertible); the rest appear as suggestions to accept or dismiss.

Catches self-corrections and spelled-out words

Say "scratch that", "no wait", or "I mean Rob" and Parleq drops the retracted words, keeping only your final intent (conservatively — when it can't tell whether you're correcting or listing both, it leaves your words alone). Spell a word aloud — "M I R A" — and it assembles the letters into the single word and capitalizes it correctly: a name stays a name, an acronym like URL stays all-caps. Most useful for fixing a name the speech model misheard.

Refinement

When the overlay is already open, the next hotkey press re-runs this stage with a different system prompt that takes your speech as an edit instruction over the existing text. Try the interactive refine-loop demo on the homepage explorer.

Paste

on-device

On accept (auto-timer or manual hotkey tap), the cleaned text pastes into whatever app was focused when you pressed the hotkey originally — not whatever happens to be focused at accept time. CGEventTap synthesizes the keystrokes; the trailing-space heuristic adds a space after the pasted text by default.

Focused-app capture

The original target is captured at hotkey-down. If your focus drifted while dictating, the paste still lands in the right window.

Trailing-space override

Specific apps (your terminal, terminal-based editors, anything that handles its own spacing) skip the trailing space. Configurable per-app in Settings.

Recent Dictations

Your recent cleaned dictations are kept in process memory and listed in the Parleq window's Recent Dictations section (hold the hotkey and tap P to open it). Copy any entry back to the clipboard, or paste it into the app you were just in, if a paste landed somewhere unexpected. The text is never written to disk; wiped on app quit.

The details, stage by stage.

Capture

Transcribe

Clean up

Paste

Every gesture, in one place.

Dictate

Refine

While dictating, refining, or reviewing

Reviewing your text

What stays on your Mac.

Persisted

Never on disk