Talk to Your Terminal

Watch it work

Detailed prompts get better answers from a CLI agent, and detailed prompts run three hundred words — typing that all day is drudgery. Dictation resolves the trade-off: speak the intent at length, type only what must be exact (paths, flags, slash commands), and let a small cleanup model make the result readable. The 2026 streaming models transcribe while you talk, so the wait after you stop is about one second however long you spoke, and a month of heavy use (662 dictations, 54,796 words) cost about $8.

The full argument, the latency measurements, and the caveats: Talk to your terminal (Pixels & Patterns).

What you are installing

Two small public repositories, one per platform. Neither is an application or a package. Each is a reproducible configuration pattern: hotkey-triggered recording, streaming OpenAI transcription, a constrained LLM cleanup pass, and a calibration loop that teaches the setup your vocabulary and style over time.

The pipeline is the same on both: a hotkey starts recording, audio streams to the transcription model while you speak, a second tap commits the buffer, a small LLM repairs the transcript, and the result is pasted at your cursor in whatever window has focus.

Install manually Linux

Prerequisites: Hyprland, upstream hyprwhspr installed and working, an API key. Four steps: copy the files, fix two paths, add your key, start the service.

# 1. Clone and copy the config into place
git clone https://github.com/scdenney/hyperwhspr
cd hyperwhspr
mkdir -p ~/.config/hyprwhspr ~/.config/systemd/user ~/.claude/commands
cp config/config.json config/cleanup.py config/vocab.md ~/.config/hyprwhspr/
cp config/hyprwhspr.service ~/.config/systemd/user/
cp claude/commands/hypr-calibrate.md ~/.claude/commands/
chmod +x ~/.config/hyprwhspr/cleanup.py

# 2. Point two paths at your machine (see README step 2)
#    config.json:  "post_transcription_hook": "/home/YOU/.config/hyprwhspr/cleanup.py"
#    cleanup.py:   #!/home/YOU/.local/share/hyprwhspr/venv/bin/python

# 3. Store your key and install the hook dependency
mkdir -p ~/.local/share/hyprwhspr && chmod 700 ~/.local/share/hyprwhspr
printf '{"openai":"YOUR_OPENAI_API_KEY"}\n' > ~/.local/share/hyprwhspr/credentials
chmod 600 ~/.local/share/hyprwhspr/credentials
~/.local/share/hyprwhspr/venv/bin/pip install httpx

# 4. Start the service
systemctl --user daemon-reload
systemctl --user enable --now hyprwhspr

Test: focus any text field, tap SUPER+ALT+D, speak, tap again. Full details, backends, and the known-issues table are in the README.

Install manually macOS

Prerequisites: Homebrew and an API key. The installer script does everything scriptable; five manual steps remain, and macOS makes you click through its permission prompts.

# Prerequisites
brew install sox
brew install --cask karabiner-elements hammerspoon

# Clone and run the idempotent installer
git clone https://github.com/scdenney/macwhspr
cd macwhspr
./setup.sh

Then, in order (the script prints these too):

1. Store your API key in the Keychain: security add-generic-password -U -s macwhspr -a openai -w 'sk-...'
2. Free the Globe key: System Settings → Keyboard → "Press 🌐 key to:" → Do Nothing.
3. Enable the Karabiner rule (Complex Modifications → "macwhspr: Fn/Globe tap → F18") and grant its permissions.
4. Reload Hammerspoon (menu bar icon → Reload Config) and grant Accessibility.
5. Start the daemon: launchctl bootstrap gui/$UID ~/Library/LaunchAgents/com.macwhspr.daemon.plist

Test: focus any text field, tap Globe, speak, tap again. Full details in the README.

Or have an agent install it Claude Code / Codex

Both READMEs are written so a coding agent can run the install. Paste the matching prompt into Claude Code or Codex and supervise. Two things stay with you on purpose: your API key never passes through the conversation, and on the Mac the GUI permission prompts need a human at the screen.

Linux

Install hyperwhspr from https://github.com/scdenney/hyperwhspr: clone the
repo and follow the README's Install section. If upstream hyprwhspr is not
installed, install it first from https://github.com/goodroot/hyprwhspr.
Substitute my real home directory for the YOUR_USER placeholders in step 2.
Skip the API key line in step 3; I will create the credentials file myself.
Finish by running `systemctl --user status hyprwhspr` and showing me the
result.

macOS

Install macwhspr from https://github.com/scdenney/macwhspr: install the brew
prerequisites from the README, clone the repo, run ./setup.sh, then walk me
through the remaining manual steps one at a time. Skip the Keychain command
in step 1; I will add the API key myself. Steps 2-4 are System Settings,
Karabiner, and Hammerspoon permission prompts that I have to click, so tell
me what to do and wait for my confirmation. Finish by starting the daemon
(step 5) and showing me `launchctl print gui/$UID/com.macwhspr.daemon`.

The agent handles cloning, file copies, path edits, dependencies, and service setup; you add the key and click the prompts. Either way the finish line is the same: an observable status check, then a first dictation.

After the install

The cleanup stage is the underrated half, and it is where the setup becomes yours. Every raw and cleaned transcript pair is logged, and the /hypr-calibrate command (installed on both platforms) reviews those logs and proposes edits to a vocabulary file: words the transcriber keeps missing, preferred spellings of names, troublesome romanizations, habits worth preserving. The system gets better at being you over time.

Costs are small enough that latency, not money, is the deciding factor. Measured on identical clips, the streaming backend returns the transcript about one second after you stop talking whether you spoke for 6 seconds or 94; the batch fallback's wait grows with the length of the dictation.