Murmur

Local, offline dictation powered by Whisper — a free Wispr Flow alternative for macOS.

Press Option+Space anywhere, speak, press Option+Space again. Murmur transcribes your voice on-device using OpenAI's open-source Whisper model and pastes the text straight into whatever you're typing in. No cloud, no API keys, no subscription — nothing leaves your machine.

Features

• 🎙️ Global hotkey — Option+Space to start/stop dictation from any app
• ⌨️ Auto-paste — text lands in the focused field automatically, and your clipboard is preserved
• ⚡ GPU-accelerated — runs Whisper on the Apple GPU via MLX (~3× faster than CPU), falling back to CPU on Intel
• 🔒 100% local — audio never leaves your Mac; runs entirely offline after the first model download
• 🧰 Menu-bar app — lives quietly in the menu bar (the "M"), no dock icon
• 🎚️ Model picker — switch between Whisper tiny → large-v3 for your speed/accuracy tradeoff

Requirements

• macOS
• Python 3.9+
• FFmpeg (brew install ffmpeg) — required by Whisper for audio

Install

git clone https://github.com/egeozkoc/murmur.git
cd murmur
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

The first launch downloads the Whisper model weights (~140 MB for base), cached in ~/.cache/whisper/.

Run

Double-click Murmur.app. An "M" appears in your menu bar — no Terminal window, no Dock icon. That's it.

First-time setup (once):

1. On first launch, macOS asks for Accessibility — click Open System Settings and enable Murmur. Quit and relaunch Murmur so it takes effect.
2. Grant Microphone when macOS prompts on the first recording.

Accessibility is required for both the Option+Space hotkey and the Cmd+V that pastes your text; Microphone is required to record.

Murmur.app is a real, code-signed .app bundle, so macOS attributes the Accessibility grant to the app itself and it persists across launches. (Earlier versions shipped a Terminal-based launcher to work around this — no longer needed. Start Murmur.command still exists as a fallback for development.)

From the terminal (for development):

./venv/bin/python murmur.py

(Calling ./venv/bin/python directly avoids an active conda/base environment shadowing the venv.)

Building from source

Murmur.app is built with py2app in alias mode (it references this venv, so it runs on this machine without bundling ~500 MB of PyTorch) and signed with a stable identity so the Accessibility grant survives rebuilds.

One-time: create a self-signed code-signing certificate named Murmur Code Signing:

• Open Keychain Access → Certificate Assistant → Create a Certificate…
• Name: Murmur Code Signing, Identity Type: Self Signed Root, Certificate Type: Code Signing, then create it in your login keychain.

Then build + sign in one step:

./venv/bin/pip install py2app     # once
./build_app.sh

This produces a signed Murmur.app at the project root and registers it with macOS. Because it's signed with the same certificate each time, you don't need to re-grant Accessibility after rebuilding.

Logs

Murmur writes a timestamped log to ~/Library/Logs/Murmur.log — useful when launched from Finder, where console output isn't visible:

tail -f ~/Library/Logs/Murmur.log

Usage

1. Put your cursor in any text field.
2. Press Option+Space to start recording.
3. Speak.
4. Press Option+Space again to stop — the transcription is pasted in place.

You can also start/stop from the menu-bar icon, and pick a different Whisper model from the Model submenu (a checkmark shows the active one). Your choice is remembered across restarts (saved to ~/Library/Application Support/Murmur/config.json).

Forgot to click into a text field first? Use Copy Last Transcription in the menu to put your most recent dictation on the clipboard so it's never lost — then paste it wherever you like.

Model comparison

These are OpenAI's open-source Whisper models (multilingual). The menu exposes:

Model	Parameters	Speed	Accuracy	Notes
tiny	39M	Fastest	Basic
base	74M	Fast	Good
small	244M	Medium	Better
medium	769M	Slow	Great
turbo	809M	Fast	Near-best	default — large-v3-turbo; near-large-v3 quality, ~8× faster
large-v3	1550M	Slowest	Best	most accurate, heaviest

Default is turbo — the best speed/quality tradeoff for dictation. Pick a smaller model if you want lower latency, or large-v3 for maximum accuracy at the cost of speed.

Performance

On Apple Silicon, Murmur runs Whisper on the GPU via MLX (Apple's Metal framework) — about 3× faster than PyTorch on CPU, with identical accuracy. In a quick benchmark, ~11 s of speech transcribed in ~1.6 s on the GPU versus ~4.8 s on CPU. MLX weights download from Hugging Face on first use (cached in ~/.cache/huggingface, turbo is ~1.6 GB).

On Intel Macs (no MLX), the app automatically falls back to openai-whisper on CPU (weights cache in ~/.cache/whisper/).

Troubleshooting

• Hotkey does nothing — grant Accessibility permission to Murmur, then quit and relaunch.
• No audio / recording fails — grant Microphone permission and check your input device.
• Model download fails — needs internet for the first run only; weights cache in ~/.cache/whisper/.
• Slow transcription — use a smaller model or pass -l en in the CLI to skip language detection.

License

Uses OpenAI's Whisper (MIT License).