Which terminal apps does Keebye support?

Keebye has no per-terminal plugin. It recognizes common terminal focus for its insertion plan, but terminal behavior varies; test the exact app and remote stack you use.

Why chunked typing instead of paste?

Terminals are a special case for text insertion, and long pasted text can get mangled on the way in. Chunked synthetic typing sends the text as keystrokes in measured pieces, so a long prompt arrives intact.

Does it work over SSH or inside tmux?

Enable type mode to send Unicode keystrokes without using the clipboard. It is designed for SSH and tmux, but you should test your shell, TUI, and remote configuration directly.

Can I run commands by voice?

No — Keebye is dictation, not voice control. It has no voice commands or command modes; it transcribes what you say into text at your cursor, and you decide what to run.

Does it work offline?

Fully. Once the model download completes (a one-time step), speech-to-text runs on-device, dictation needs no network connection, and there is no telemetry.

Voice Dictation for the macOS Terminal

Dictate into a macOS terminal with a terminal-aware paste plan or opt-in Unicode type mode for SSH, tmux, and paste-hostile targets.

Why dictate into a terminal

Terminals are where the typing load moved. Agent CLIs like Claude Code live there, and driving them means writing paragraph-length prompts into a shell input dozens of times a day. Long commands, commit messages, and instructions to an agent are all faster to speak than to type — if the text can survive the trip into a TTY.

That's the catch. Terminals are hostile territory for naive text insertion: what works fine in a text editor can arrive mangled in a shell. Most dictation tools weren't built with this in mind. Keebye was — terminal insertion is the workload it was designed around.

How it works

Focus your terminal, hold Right ⌘, speak, and release. Paste mode is the default and uses a terminal-aware insertion plan. For SSH, tmux, non-QWERTY layouts, or a target where paste is unreliable, select type mode in settings; Keebye then sends Unicode keystrokes in conservative chunks without touching the clipboard.

Type mode is designed to cross the same focused terminal path as ordinary text entry. Shells and TUIs can still filter or rate-limit synthetic input, which is why the real acceptance test is your own stack.

There is no per-app plugin to configure. Speech-to-text runs on-device (Parakeet for English by default), works offline after the one-time model download, and sends no telemetry.

Setup in two minutes

Install Keebye and grant it Accessibility (so it can type into your shell) plus microphone access. The hotkey defaults to Right ⌘; Fn and Right ⌥ are the built-in alternatives if that key is taken. Turn on launch-at-login so it's ready when your first shell is.

Then feed the custom dictionary. Terminals are jargon-dense: repo names, branch names, CLI tools, and flags you say all day. Adding recurring terms reduces corrections, but commands and identifiers still require review.

Limits, honestly

The transcript lands only after you release the key — Keebye transcribes in batch, not as live captions scrolling into your shell while you talk.

Keebye types text; it is not a voice-command layer. There are no spoken commands or macros — what you say becomes text at the cursor, and running it stays your call.

Keebye is macOS only.

Now replay the failure that brought you here: copy a SHA, focus the SSH or tmux pane, dictate the long redirect in type mode, and confirm both the text and clipboard survive. The deeper mechanism is in Dictation that survives the terminal; the local-first comparison is Keebye vs Superwhisper.