[opensourcedex]

Handy is a free, open source input & dictation project written in Rust and released under MIT. It has 31,791 GitHub stars, 2,896 forks and 158 open issues, and was last pushed 3 days ago. On this registry it ranks #1 of 6 tracked projects in Input & Dictation, with 5 head-to-head comparisons available. It gained 350 stars over the last 6 tracked days.

Handy — Press a key, speak, release. Text appears instantly.

What is Handy?

What it is

Handy is a cross-platform desktop application for offline speech-to-text transcription. It runs entirely on the user’s machine, capturing audio via microphone input and converting speech to text using local machine learning models without any cloud dependency. Built with Tauri and Rust, it targets Windows, macOS, and Linux, and emphasizes simplicity, privacy, and extensibility over raw accuracy or feature breadth.

The project solves the problem of lacking truly open, self-hostable speech transcription tools that respect user privacy. Existing solutions either require internet access, charge for access, or are not designed for easy modification or integration. Handy fills this gap by providing a minimal, forkable core that works offline and integrates with system text fields via configurable keyboard shortcuts.

Key capabilities

  • Transcribes speech in real time using local Whisper-family models (Small/Medium/Turbo/Large) with optional GPU acceleration
  • Supports Parakeet V3, a CPU-optimized model with automatic language detection
  • Uses Silero for Voice Activity Detection (VAD) to filter silence and reduce noise
  • Operates in three modes: hold-to-record, tap-to-toggle, or hold-only/toggle-only variants
  • Pastes transcribed text directly into any active application via system clipboard injection
  • Configurable keyboard shortcuts and global hotkey handling via rdev
  • Extensible architecture via Tauri commands and external integrations like Raycast

Who uses it and how

  • Accessibility users rely on it for hands-free text input without sending voice data to third parties
  • Developers extend it locally using its Rust backend and Tauri plugin system for custom workflows
  • Privacy-conscious users deploy it in air-gapped or sensitive environments where cloud transcription is prohibited

Getting started

Download prebuilt binaries from GitHub releases or the official site; install via Homebrew (brew install --cask handy) on macOS or winget (winget install cjpais.Handy) on Windows. Launch the app, grant microphone and accessibility permissions, configure shortcuts in Settings, and begin transcribing.

When to use it — and when not to

Handy is ideal when offline operation, privacy, or extensibility are priorities over transcription accuracy or advanced features like speaker diarization. It trades raw performance for modularity: users must manage model downloads, GPU setup, and system permissions themselves. It does not replace paid services requiring high-throughput or multi-speaker transcription, nor does it provide hosted infrastructure or API access.

project readme (upstream, from github) — read inline

Handy

Discord

A free, open source, and extensible speech-to-text application that works completely offline.

Handy is a cross-platform desktop application that provides simple, privacy-focused speech transcription. Press a shortcut, speak, and have your words appear in any text field. This happens on your own computer without sending any information to the cloud.

Why Handy?

Handy was created to fill the gap for a truly open source, extensible speech-to-text tool. As stated on handy.computer:

  • Free: Accessibility tooling belongs in everyone's hands, not behind a paywall
  • Open Source: Together we can build further. Extend Handy for yourself and contribute to something bigger
  • Private: Your voice stays on your computer. Get transcriptions without sending audio to the cloud
  • Simple: One tool, one job. Transcribe what you say and put it into a text box

Handy isn't trying to be the best speech-to-text app—it's trying to be the most forkable one.

How It Works

  1. Press a configurable keyboard shortcut: hold it to record and release to stop, or tap it to toggle recording on and off (Hold-only and Toggle-only modes are also available)
  2. Speak your words while the shortcut is active
  3. Release and Handy processes your speech using Whisper
  4. Get your transcribed text pasted directly into whatever app you're using

The process is entirely local:

  • Silence is filtered using VAD (Voice Activity Detection) with Silero
  • Transcription uses your choice of models:
    • Whisper models (Small/Medium/Turbo/Large) with GPU acceleration when available
    • Parakeet V3 - CPU-optimized model with excellent performance and automatic language detection
  • Works on Windows, macOS, and Linux

Quick Start

Installation

  1. Download the latest release from the releases page or the website
    • macOS: Also available via Homebrew cask: brew install --cask handy
    • Windows: Also available via winget: winget install cjpais.Handy
      Note: The Homebrew cask and winget package are not maintained by the Handy developers.
  2. Install the application
  3. Launch Handy and grant necessary system permissions (microphone, accessibility)
  4. Configure your preferred keyboard shortcuts in Settings
  5. Start transcribing!

Development Setup

For detailed build instructions including platform-specific requirements, see BUILD.md.

Integrations

Install handy Raycast Extension

Control Handy from Raycast — start/stop recording, browse transcript history, manage dictionary, switch models and languages.

Source · by @mattiacolombomc

Architecture

Handy is built as a Tauri application combining:

  • Frontend: React + TypeScript with Tailwind CSS for the settings UI
  • Backend: Rust for system integration, audio processing, and ML inference
  • Core Libraries:
    • transcribe-cpp: Local speech recognition with Whisper-family models (GGML/GGUF)
    • transcribe-rs: CPU-optimized speech recognition with Parakeet models
    • cpal: Cross-platform audio I/O
    • vad-rs: Voice Activity Detection
    • rdev: Global keyboard shortcuts and system events
    • rubato: Audio resampling

Debug Mode

Handy includes an advanced debug mode for development and troubleshooting. Access it by pressing:

  • macOS: Cmd+Shift+D
  • Windows/Linux: Ctrl+Shift+D

CLI Parameters

Handy supports command-line flags for controlling a running instance and customizing startup behavior. These work on all platforms (macOS, Windows, Linux).

Remote control flags (sent to an already-running instance via the single-instance plugin):

handy --toggle-transcription    # Toggle recording on/off
handy --toggle-post-process     # Toggle recording with post-processing on/off
handy --cancel                  # Cancel the current operation

Startup flags:

handy --start-hidden            # Start without showing the main window
handy --no-tray                 # Start without the system tray icon
handy --debug                   # Enable debug mode with verbose logging
handy --help                    # Show all available flags

Flags can be combined for autostart scenarios:

handy --start-hidden --no-tray

macOS tip: When Handy is installed as an app bundle, invoke the binary directly:

/Applications/Handy.app/Contents/MacOS/Handy --toggle-transcription

Known Issues & Current Limitations

This project is actively being developed and has some known issues. We believe in transparency about the current state:

Bluetooth Headset Microphones (macOS)

Using a Bluetooth headset microphone on macOS may temporarily reduce playback quality or volume while recording because Bluetooth switches to bidirectional audio. Keep your headphones as the output device and select your Mac's built-in or an external microphone in Handy to avoid this.

fn and Globe Key Shortcuts (macOS)

Shortcuts that include the fn (Globe) key only work on Apple keyboards — your Mac's built-in keyboard or an Apple external keyboard. They will never trigger on a third-party keyboard, even while it is connected to the same Mac.

This is a hardware limitation rather than a Handy bug. fn is not part of the standard USB HID keyboard specification: Apple reports it through a vendor-specific usage that macOS honors only from Apple devices, while third-party keyboards handle their Fn key entirely in firmware and send nothing to the computer. There is no event for Handy to listen for.

If you switch between a MacBook keyboard and an external one, pick a shortcut built from standard modifiers (ctrl, option, shift, command) or a regular key instead.

Major Issues (Help Wanted)

Whisper Model Crashes:

  • Whisper models crash on certain system configurations (Windows and Linux)
  • Does not affect all systems - issue is configuration-dependent
    • If you experience crashes and are a developer, please help to fix and provide debug logs!

Wayland Support (Linux):

  • Limited support for Wayland display server
  • Requires wtype or dotool for text input to work correctly (see Linux Notes below for installation)

Linux Notes

Text Input Tools:

For reliable text input on Linux, install the appropriate tool for your display server:

Display Server Recommended Tool Install Command
X11 xdotool sudo apt install xdotool
Wayland wtype sudo apt install wtype
Both dotool sudo apt install dotool (requires input group)
  • X11: Install xdotool for both direct typing and clipboard paste shortcuts
  • Ubuntu 26.04: Has Wayland display server by default. wtype does not work, you need to install ydotool and configure systemd as described here.
  • Wayland: Install wtype (preferred) or dotool for text input to work correctly
  • dotool setup: Requires adding your user to the input group: sudo usermod -aG input $USER (then log out and back in)

Without these tools, Handy falls back to enigo which may have limited compatibility, especially on Wayland.

Other Notes:

  • Runtime library dependency (libgtk-layer-shell.so.0):

    • Handy links gtk-layer-shell on Linux. If startup fails with error while loading shared libraries: libgtk-layer-shell.so.0, install the runtime package for your distro:

      Distro Package to install Example command
      Ubuntu/Debian libgtk-layer-shell0 sudo apt install libgtk-layer-shell0
      Fedora/RHEL gtk-layer-shell sudo dnf install gtk-layer-shell
      Arch Linux gtk-layer-shell sudo pacman -S gtk-layer-shell

    • For building from source on Ubuntu/Debian, you may also need libgtk-layer-shell-dev.

readme truncated — read the full docs on github

Frequently asked questions

Is Handy free to use?

Handy is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Handy do?

Press a key, speak, release. Text appears instantly.

What is Handy written in?

Handy is primarily written in Rust. Its source is publicly available at https://github.com/cjpais/handy, and it has 31,791 GitHub stars.