Global Dictation with Speech-to-Text

What This Is

I use a hotkey to dictate into my terminal, browser and notes. My original setup was a collection of Whisper scripts. It became unreliable, and my current Kubuntu setup uses Handy with Parakeet TDT 0.6B v3 GGUF (Q8_0), accelerated through Vulkan on the Radeon 860M in my ThinkPad T14s Gen 6 AMD. In use, I am finding it very quick and accurate.

Handy is the application that records audio, runs a model and inserts the result. Parakeet is the speech recognition model. Transcription runs locally after the model download. Handy can also run Whisper, so changing models does not require rebuilding the recording and paste workflow.

The model and backend matter: this replaces the older CPU-only Parakeet configuration previously described here. Voice activity detection is off because it discarded speech from my Bluetooth microphone; I start and stop recording with a global hotkey instead.

A missed paste is also recoverable. My setup leaves the transcript on the clipboard and retains recent recordings in Handy’s History tab. On KDE Wayland, disabling the floating overlay fixed failed pastes; a separate failure came from a muted microphone, even though the start and stop sounds played normally.

Jump to: Linux · macOS · Windows · Custom vocabulary · Model choice · Long recordings and speakers

Everything above this line is for humans to read. Everything below is a setup guide you can give to Claude Code or follow yourself.

Prerequisites

My tested Linux configuration uses Handy with Parakeet V3 GGUF and Vulkan. The macOS and Windows sections explain how to select the same GGUF model and verify the available accelerator; I have not tested those platforms. Download a build for your operating system and architecture from the official releases. You need a microphone, disk space for the application and model, and an internet connection for the initial download. Dictation then runs locally without a separate Python environment.

The current Linux configuration uses the native Handy v0.9.8 package on Kubuntu 26.04 with KDE Wayland. On a saved roughly 70-second recording, V3 GGUF Vulkan runs took 1.22–1.34 seconds to transcribe, while a separate verification run took about five seconds. These are measurements from one recording, rather than a general benchmark; my assessment of everyday speed and accuracy is subjective. The macOS and Windows instructions follow Handy’s documentation; I have not tested those platforms.

Part 1: Linux (Kubuntu / KDE Plasma)

Install Handy and select a model

Install the native package for your distribution from Handy’s release page. My installation runs /usr/bin/handy; the earlier AppImage launcher is no longer the setup I use.

Select Parakeet TDT 0.6B v3 GGUF (Q8_0) and let it download. The exact model ID is:

handy-computer/parakeet-tdt-0.6b-v3-gguf/parakeet-tdt-0.6b-v3-Q8_0.gguf

Set the transcribe.cpp accelerator to Auto (transcribe_accelerator=auto). In my installation, the load log confirms bound backend 'Vulkan0' and bound device 'AMD Radeon 860M Graphics (RADV KRACKAN1)'. Auto alone does not prove that a GPU is being used: check the model-load log for the actual backend and device. The separate ONNX Runtime setting (ort_accelerator=cpu here) does not control this GGUF backend.

Model availability and labels vary by build. If your model picker lacks this GGUF entry, check the available builds and model support before proceeding; selecting the older plain Parakeet V3 entry does not reproduce this configuration. Handy’s model documentation still describes Parakeet as CPU-only, whereas the installed build’s logs verify Vulkan for this GGUF model.

Select toggle recording and disable Voice Activity Detection (vad_enabled=false). Silero VAD discarded most speech from my DJI Mic 3 Bluetooth input; disabling it restored full sentences. Enable Launch on Startup and Start Hidden if you want Handy available after login. Keep Auto Submit and Post Processing off.

Configure insertion on Wayland

Ctrl+V automatic insertion was verified in Kate. [Personal: validated]

For Kitty, add map ctrl+v paste_from_clipboard to kitty.conf so it accepts Handy’s paste chord too; Ctrl+Shift+V remains available. [Generic: literature]

ydotool needs its daemon running and access to /dev/uinput. Follow your distribution’s packaging and the Handy paste instructions. Check for an existing installation before changing permissions or creating another service.

Kubuntu’s installed package supplies a user service. If your installation supplies that same unit, enable it with:

systemctl --user enable --now ydotool.service
systemctl --user status ydotool.service
ls -l /dev/uinput
id -nG

The service status should show active (running). The device permissions must allow your user to write to it, directly or through one of the groups shown by id -nG. A running service alone does not prove insertion works; test a real text field.

Set the shortcut

Use Handy’s built-in Transcribe shortcut as your global hotkey; in Handy’s settings, pick a shortcut that doesn’t clash with your apps. Press once to start and again to stop. Disable any extra KDE shortcut previously assigned to Handy so it does not retain a separate binding. [Generic: literature]

Keep the target field focused until transcription finishes. Handy sends a paste keystroke to the focused application; it does not guarantee that an editable field is selected. Auto Submit being off means Handy does not deliberately press Enter after insertion.

Recover a missed paste

Copy to Clipboard leaves the completed transcript available for manual paste. Use Ctrl+V in a normal text field or Ctrl+Shift+V in Kitty. Handy’s History tab provides another copy of recent completed transcriptions; this configuration keeps the latest five recordings. Star a recording you want to retain.

If you prefer to choose the destination after transcription, set the paste method to None for clipboard-only output. History contains local audio as well as text, so choose its retention settings to suit what you dictate. Paste methods · History

Troubleshoot by checking the transcript first

Sounds, but no text or new History entry: check the selected microphone and its system mute state. The sounds confirm that the shortcut activated, not that speech was captured. On a PipeWire desktop with PulseAudio compatibility:

pactl get-source-mute @DEFAULT_SOURCE@

Mute: yes means the default input is muted. If that is the intended microphone, unmute it in KDE’s audio controls or with:

pactl set-source-mute @DEFAULT_SOURCE@ 0

The audio contains speech, but the transcript omits it: check VAD first, particularly with Bluetooth input. In my tests, the older ONNX INT8 encoder also omitted passages from a roughly 70-second recording; replacing only that encoder with FP32 restored them. The current GGUF Q8_0 model uses a different backend and retained the missing passages. Compare History audio with the text before treating every omission as a microphone problem.

A transcript exists in History, but the field is empty: recover it from the clipboard, then check focus, overlay position and the paste settings. Disabling the overlay resolved this failure in the tested setup. Test insertion in both your terminal and a normal text field before assuming the keyboard shortcut is right everywhere.

To cancel a stuck or accidental operation:

handy --cancel

Part 2: macOS

Install Handy and select Parakeet V3 GGUF

Download the Apple Silicon or Intel Mac .dmg for your Mac from the official releases, open it and drag Handy into Applications. Launch Handy and grant Microphone and Accessibility access when prompted; you can manage these under System Settings → Privacy & Security. Installation and permissions

Select Parakeet TDT 0.6B v3 GGUF (Q8_0), using the exact model ID in the Linux section, and let it download. Set the transcribe.cpp accelerator to Auto. Handy’s macOS build enables Metal; check the model-load log for the bound backend and device rather than assuming Auto selected the GPU. Open the log directory from Handy’s About page. A Metal backend with the intended device confirms GPU use; CPU means this run is using the CPU.

If this GGUF model is missing from the picker, check your build’s model support before continuing. The older plain Parakeet V3 entry is a different configuration. On an Intel Mac, verify the actual backend and judge performance on your own recording.

In Settings → General, select your microphone and use toggle recording (turn Push To Talk off in builds with that label). Disable VAD to match my configuration, especially if Bluetooth speech is being dropped. The default Transcribe shortcut is Option+Space; click its shortcut field to choose another combination if it conflicts with an existing binding. Recording and shortcuts

Configure insertion and recovery

In Settings → Advanced, use these settings:

Enable Launch on Startup and Start Hidden if you want Handy available from the menu bar after login. Set a History limit that retains recent transcriptions. Output and startup settings

Test it and troubleshoot

Click into a blank note, press the Transcribe shortcut, speak a sentence and press the shortcut again. Keep the field focused until the text appears, then check that Cmd+V can paste the transcript again. Repeat with a longer paragraph and compare the History audio with its transcript for missing phrases. Confirm the log names the GGUF model and the backend you intended to use.

If recording produces no transcript, check Handy’s selected microphone, its mute state and Microphone permission. If History contains the text but insertion fails, check Handy’s Accessibility permission and the focused field, then recover the text with Cmd+V or copy it from History. Set paste method to None if you prefer manual insertion. Paste troubleshooting · History

Part 3: Windows 11

Install Handy and select Parakeet V3 GGUF

Download and run the Windows installer for your architecture from the official releases, then launch Handy from the Start menu. Alternatively, the community-maintained winget package is:

winget install --id cjpais.Handy -e

Handy handles recording, transcription and the global shortcut within the application. Installation options

Select Parakeet TDT 0.6B v3 GGUF (Q8_0), using the exact model ID in the Linux section, and let it download. Set the transcribe.cpp accelerator to Auto. The Windows x64 build enables Vulkan, so install the current graphics driver from your GPU or laptop manufacturer. Open Handy’s log directory from About and check the model-load entry: a bound Vulkan backend and the intended GPU confirm acceleration; CPU means the run is using the CPU.

Windows on ARM differs: the current native ARM64 build is CPU-only, and Handy also forces CPU when its x64 build runs under ARM64 emulation. Do not expect the Radeon/Vulkan result from my Linux laptop on those configurations. If the GGUF entry is absent, check the installed build’s model support before continuing; the older plain Parakeet V3 entry does not reproduce this setup. Backend selection

In Settings → General, choose your microphone and select toggle recording (turn Push To Talk off in builds with that label). Disable VAD to match my configuration, especially if Bluetooth speech is being dropped. The default Transcribe shortcut is Ctrl+Space; click the shortcut field to change it if another application uses that combination. Recording and shortcuts

Configure insertion and recovery

In Settings → Advanced, use these settings:

Enable Launch on Startup and Start Hidden if you want Handy in the system tray after login, and retain recent transcriptions through the History settings. Output and startup settings

Test it and troubleshoot

Open Notepad, press the Transcribe shortcut, speak a sentence and press it again. Keep the field focused until the text appears, then check that Ctrl+V pastes the transcript again. Repeat with a longer paragraph and compare the History audio with its transcript for missing phrases. Confirm the log names the GGUF model and the backend you intended to use.

If there is no transcript, check the selected microphone, its mute state and Windows microphone privacy settings. If History has the text but insertion fails, paste it manually or copy it from History. For Windows Terminal, Command Prompt or PowerShell, try Shift+Insert as the paste method. Windows blocks input from a normal process into an administrator window, so test in a normal window first. Clipboard-only output is available by setting paste method to None. Paste troubleshooting · History

Custom Vocabulary (Optional)

Handy custom words

Open Settings → Advanced → Custom Words and add the preferred spelling of names, project names and technical terms that are frequently misheard. Multiword entries are supported in v0.9.6. Start with a curated list rather than every capitalised word in your notes.

Obsidian
Syncthing
PostgreSQL
Example Project

The effect depends on the model. In the v0.9.6 implementation, Whisper receives the custom words as an initial recognition prompt. Parakeet instead uses correction after transcription, matching similar spellings and sounds over short phrases. This is not model training or an exact replacement dictionary: similar ordinary words can become names. Remove ambiguous entries or use fuller names. In text-correction checks, reducing Word Correction Threshold from 0.18 to 0.06 prevented unwanted substitutions in ordinary sentences while preserving useful corrections. This conservative setting also leaves more mistakes unchanged; it is a starting point to test with your own vocabulary.

Custom Words does not teach tone, sentence structure or a complete writing-style document. Handy has optional AI post-processing for rewriting; the provider, latency and privacy implications depend on its configuration. It is disabled in this setup.

Migrating the old Whisper vocabulary

My old list was stored at ~/.local/share/whisper-vocab.txt, one term per line. I imported the curated entries into Handy’s Custom Words. Handy does not automatically read or synchronise that file, so maintain the active list in Handy afterwards.

Choosing a Model

My default is Parakeet TDT 0.6B v3 GGUF (Q8_0) with Vulkan: it transcribes after I stop recording, has retained passages the older ONNX INT8 encoder omitted, and gives me useful punctuation. I am finding the working setup very quick and accurate, though I have not measured its accuracy against Whisper on matched recordings. Handy keeps the model loaded for five idle minutes in this configuration.

I also tested Parakeet Unified EN 0.6B GGUF (Q8_0), which processes speech while recording. A real-time replay of the same sample produced its transcript about 0.42 seconds after stop, with automatic paste disabled for that test. Its punctuation was lighter than V3 GGUF’s, so V3 GGUF remains my default. This is an installed alternative, not the active model.

If a name remains troublesome, compare the same recording with a Whisper model in Handy and judge the corrections and delay you actually experience. Handy model guide · WhisperX

Beyond Dictation: Longer Recordings with Speaker Diarisation

WhisperX is useful for meetings and interviews: it combines speech recognition, word alignment and optional speaker diarisation. Diarisation assigns speaker labels; it does not know the speakers’ names. Overlapping speech and uncertain labels still need review.

Use the project’s current installation and diarisation instructions for a separate environment. Its Python, PyTorch and gated-model requirements can change independently of Handy. Choose CPU or GPU dependencies deliberately, and do not reuse the dictation application’s environment. This replaces the older installation recipe on this page; those commands are not part of the Handy migration.

For a short message, use Handy. For a file where word timing or changes of speaker matter, use WhisperX. Their roles can coexist without maintaining a second global hotkey script.

Questions or improvements? Find me at hedwards.dev.