digimata/parrot: a push-to-talk dictation daemon for Apple Silicon Macs

What parrot solves, and who it is actually for

Most dictation tools ask you to decide when recording starts and when it stops. Parrot removes both decisions. The README describes the whole interface as the fn key: hold it, speak, release, and the transcript appears at the cursor. There is no record button, no stop button, and no send step. That constraint is the product.

The target user is narrow. Parrot requires macOS 14 or newer on Apple Silicon, M1 or newer, because transcription runs on the Apple Neural Engine through CoreML. The README states the installer refuses to run on Intel. So this is not a tool for a mixed fleet of Macs, and it is not a tool for anyone still on an older macOS release.

The second half of the audience is privacy-motivated. Transcription happens on-device, which means audio does not go to a server. For someone dictating into a Slack thread or a private note, that is the difference between a tool they can use and one they cannot.

How the daemon works: hotkey, mic, model, cursor

The stack listed in the README is short and each piece has one job. AVAudioEngine captures the microphone. CGEventTap registers the global hotkey, which is why the fn key works while another app has focus. WhisperKit runs Whisper inference through CoreML on the Neural Engine. CGEvent injects the resulting text at the cursor position. A borderless, click-through NSWindow draws the small pill at the bottom of the screen while the mic is hot.

That division explains the permission model. A global hotkey and text injection into another application both require accessibility access, and microphone capture requires mic access. The README says parrot setup grants both and downloads the model. If either permission is missing, the hotkey or the insertion step fails even though the process is running.

The data flow is local end to end. Audio goes from AVAudioEngine into WhisperKit, text comes out, and CGEvent types it. Nothing in the described stack posts audio to a remote endpoint. The README gives a typical latency of 200 to 300ms between release and the transcript appearing, which is a claim from the project rather than an independent measurement.

One design detail worth noting: the default model is not named in the README, but parrot --model whisper-large-v3-turbo is documented as the bigger, multilingual, slower-first-run option. That phrasing implies the default is something smaller and English-oriented.

Installing parrot and dictating your first sentence

The README gives a one-line install. The script lives at the project's homepage and drops the binary in /usr/local/bin/parrot. Builds are unsigned, so the installer also strips the quarantine extended attribute. The README explicitly invites you to inspect the script before running it, which is reasonable advice for any curl pipe into sh.

curl -fsSL https://digimata.github.io/parrot/install.sh | sh
parrot setup
parrot install --launch-at-login

The first command installs the binary. The second is the one-time setup: it grants microphone and accessibility permissions and downloads the model. The third is optional and registers a LaunchAgent so parrot runs in the background at login and lives in the menu bar. Skip it if you would rather start parrot manually.

Before dictating, confirm the environment is sane. The doctor subcommand checks permissions and the fn key setting:

parrot doctor

On most modern Macs fn sits at the bottom left. If your keyboard is configured to change input source or show emoji and symbols when fn is pressed, setup tells you how to flip it back to a plain fn key. Fix that before blaming the daemon.

Now the actual first use. Click into any text field with a blinking cursor, hold fn, say a sentence, and release. A pill appears at the bottom of the screen while the mic is hot, and the transcript types itself in when you release. To run it in the foreground instead of as a daemon, just run parrot in a terminal tab and quit with Ctrl+C. To swap the push-to-talk key, the README documents parrot --hotkey right-option, and parrot --no-overlay disables the indicator pill.

Unsigned builds, Intel exclusion, and the fn key dependency

Three constraints stand out, and none of them are hidden.

First, the builds are unsigned. The installer works around this by removing the quarantine attribute, which is exactly the kind of step that makes a security-conscious engineer pause. The README acknowledges this and points you at the script. If your organization requires signed and notarized binaries, parrot does not meet that bar today, and no release note in the repository says otherwise.

Second, Apple Silicon is a hard requirement. The README ties this to CoreML and the Neural Engine, and says the installer refuses to run on Intel. This is not a performance preference you can override with a flag; it is a gate in the installer.

Third, the interface depends on one key. The README warns that if fn is repurposed for input source switching or emoji, parrot setup will tell you how to change it back. That is a fixable conflict, but it is a conflict: you are choosing between parrot's push-to-talk and whatever else fn was doing. The documented alternative is parrot --hotkey right-option, so the dependency is on a single global hotkey rather than on fn specifically.

The README does not document rollback beyond parrot install --uninstall, which removes the LaunchAgent. It says nothing about what happens to downloaded models or the binary itself on removal.

Parrot against a cloud dictation service

The obvious comparison is a cloud dictation service, the kind that streams audio to a server and returns text. The difference is architectural, not cosmetic. A cloud service can offer larger models and better accuracy on hard audio, and it can run on any machine with a browser. Parrot trades that ceiling for locality: the model runs on your Neural Engine, audio stays on the Mac, and there is no account, no API key, and no network round trip in the described path.

That trade has a cost. A cloud service does not care whether your Mac is Intel or Apple Silicon, and it does not need accessibility permissions to type into another app, because you usually paste the result yourself. Parrot needs both the hardware and the permissions. It also inherits the model's limits: the README's own flag description calls whisper-large-v3-turbo bigger, multilingual, and slower on first run, which implies the default configuration is optimized for speed over breadth of language coverage.

There is also a category difference. Parrot is a daemon with a global hotkey, not an app with a window. If you want a transcript you can edit before it lands, parrot is the wrong shape. It types immediately on release.

Licence, maintenance, and what upgrading costs you

Parrot is MIT licensed. In practice that means you can read the source, modify it, and redistribute it, including in commercial settings, provided the copyright notice and permission notice are preserved. That is the general shape of MIT; it is not legal advice, and if you are embedding parrot in a product you should read LICENSE in the repository rather than this paragraph.

The repository is not archived, and the last push was on 2026-07-30. The most recent tagged release is v0.0.5 from 2026-05-10, with v0.0.4 and v0.0.3 both tagged earlier the same day. That version numbering, still at 0.0.x, is a reasonable signal about how the project positions itself: pre-1.0, with the interface settled but the packaging still rough around the edges, as the unsigned-build note suggests.

Upgrade cost is low in the ordinary case. There is a single SPM executable target, the install path is a curl script, and parrot install --uninstall removes the LaunchAgent if you want out. The friction is in the surrounding environment rather than the binary: every upgrade that touches permissions or the model may require another parrot setup run, and the quarantine-stripping installer is a step you would want to re-inspect rather than run blindly. If you build from source, swift build -c release followed by .build/release/parrot --help is the documented path.

Editorial conclusion

Parrot suits engineers on Apple Silicon who want dictation that never leaves the machine and who are comfortable with a curl | sh installer and an unsigned binary. It is the wrong choice on Intel Macs, on macOS below 14, and for anyone who needs a signed, notarized app or a fallback when the fn key is remapped. Before adopting it, run parrot doctor to confirm permissions and the fn key setting, and read install.sh yourself since the installer strips the quarantine attribute.

Frequently asked questions

Official sources

1. digimata/parrot on GitHub
2. License: MIT
3. Project website
4. README
5. Releases