# Handy: A Free, Offline, Open-Source Dictation App

CJ Pais built [Handy](https://handy.computer) after a finger injury made typing painful. He needed something that would **paste transcribed speech directly into any text field, work completely offline, and not send audio to a cloud server**. Nothing out there did all three, so he built it. The project has since accumulated over 23,000 GitHub stars under an MIT license, with frequent releases and a growing contributor base.

Handy runs on macOS, Windows, and Linux. Press a hotkey, speak, release, and the transcribed text appears wherever your cursor is. No account, no subscription, no data leaving your machine.

<iframe class="aspect-video h-auto" width="100%" height="315" src="https://www.youtube.com/embed/ZRsDQp9CrXc" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>


## Architecture

Handy is built with [Tauri](https://tauri.app), a framework for cross-platform desktop apps that uses a Rust backend and a web-based frontend. The Rust side handles audio capture, model inference, and system integration. The React/TypeScript frontend handles the settings UI. This combination keeps the binary small: the Windows installer is 12.6 MB.

![A screenshot of the Handy GitHub page shows the Architecture section, detailing its combination of a Rust backend and a React/TypeScript frontend built with Tauri.](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/f05d1e5b-93db-4507-661b-90e776a69e00/orig =1280x720)

The key libraries in the stack:

- **`transcribe-cpp` and `transcribe-rs`**: Run Whisper-family models (GGML/GGUF format) and Parakeet models respectively
- **`cpal`**: Cross-platform audio input, ensuring reliable microphone access on all three platforms
- **`vad-rs`**: Voice Activity Detection using Silero VAD, which filters out silence so the model only processes audio when you're actually speaking
- **`rdev`**: Global keyboard shortcuts that work across all applications
- **`rubato`**: Audio sample rate conversion for real-time audio streaming

The VAD component matters more than it might seem. By detecting silence and only passing actual speech to the transcription model, it significantly reduces CPU usage during pauses.

## Installation and configuration

Download from [handy.computer](https://handy.computer/download) for your platform. On first launch, grant microphone and accessibility permissions when prompted.

The settings window has a straightforward layout.

![The "General" settings tab in Handy, where users can configure the main transcription shortcut and set up Push To Talk mode.](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/5c8cf20a-eec3-4b16-1b7b-28e83e247c00/lg1x =1280x720)

The main options in the General tab:

**Transcribe Shortcut**: The global hotkey that triggers dictation. Default is `Option + Space` on macOS; you can set any combination you prefer.

**Push To Talk**: Controls how the shortcut works. With it enabled, you hold the key while speaking and release when done. With it disabled (toggle mode), one press starts recording and a second press stops it and triggers transcription. Push To Talk works better for short bursts; toggle mode is more comfortable for longer dictations.

**Sound Settings**: Microphone selection and audio feedback sounds that confirm when recording starts and stops.

## How it works

Place your cursor in any text field, press your hotkey, speak, and release. After a 2 to 5 second processing delay, the transcribed text is pasted at the cursor. The delay is real and worth setting expectations around: Handy isn't real-time streaming dictation. It processes audio after you stop speaking, then pastes the result. For most use cases this is fine, but if you need to see words appear as you speak, you'll want a different tool.

## Transcription models

The model selection is one of Handy's more compelling features.

![The "Models" tab in the Handy application showcases a list of downloadable transcription models with sliders for accuracy and speed.](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/2aafbe48-1acd-4d65-0c6d-b26c6ff5ec00/public =1280x720)

Each model in the list shows accuracy and speed ratings. The tradeoff is straightforward: larger models transcribe more accurately, especially on technical vocabulary, but take longer. Smaller models are faster but make more mistakes.

![An illustrative comparison showing how choosing a model in Handy, with its speed and accuracy sliders, is like picking a character in a racing game with different stats.](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/f45781ed-f45f-4d65-9f27-bdbe20c74200/lg1x =1280x720)

The main model families available:

**Parakeet models**: CPU-optimized and fast. The `Parakeet Unified EN 0.6B` runs at over 5x real-time speed on a mid-range i5 processor and faster still on Apple Silicon. Good for general use where you want low latency.

**Whisper models**: OpenAI's speech recognition models in various sizes (Small, Medium, Large). Higher accuracy than Parakeet, especially on complex or technical language, but slower. Excellent when precision matters more than speed.

**Moonshine models**: Another option for faster inference with reasonable accuracy.

**Specialized models**: Models optimized for specific languages including Russian, Ukrainian, and Chinese.

### Adding custom models

Handy supports custom Whisper models in GGML format.

![A side-by-side view of the file explorer showing the Handy models folder and the Handy app, demonstrating how to add custom models.](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/e7d15dbb-3b75-4bfa-3a83-a5ef59035d00/public =1280x720)

Drop your `.bin` model file into the Handy models directory:

- macOS/Linux: `~/Library/Application Support/com.pais.handy/models`
- Windows: use `New-Item -ItemType Directory -Force` to create the equivalent path if needed

Restart the app and your model appears in the downloaded models list.

## Performance comparison

A practical test using a complex technical sentence containing terms like `SQLite`, `COBOL`, `GPU cluster`, `LLM`, `Grok`, and `ChatGPT` showed a clear gap between tools.

Google Docs Voice Typing produced significant errors on all technical terms: `COBOL` became "Cobalt", `SQLite` became "sequel I", `LLM` became "element", `ChatGPT` became "Chad GBT". Punctuation was absent entirely.

Handy, using a Whisper model, correctly transcribed every technical term and added appropriate punctuation. The output was indistinguishable from what a commercial paid tool like WhisperFlow produced on the same audio.

## Honest limitations

Handy is version 0.8.x. The version numbering is the developer's candid way of signaling it's still being built.

**No auto-punctuation by default**: Output is relatively raw. You won't get sentences automatically capitalized and punctuated the way some commercial tools handle it. Some models do better than others on punctuation, but it's not consistent.

**2–5 second processing delay**: Not real-time. Audio is processed after you stop speaking.

**No AI editing or cleanup**: What gets transcribed is what gets pasted. There's no post-processing step that fixes grammar or rephrases awkward dictation.

**No mobile app**: Desktop only.

For users who need live streaming dictation, AI-assisted cleanup, or a polished consumer experience, there are commercial alternatives worth considering. For users who want a free, private, local, and extensible dictation tool that does exactly what it says, Handy is the clearest option in the field.

The [GitHub repository](https://github.com/cjpais/handy) has the source, installation instructions, and open issues. Development is funded through GitHub Sponsors with no paid tier.