# Whisper Dictation on Linux: What Actually Works (2026)

Canonical: https://vibetyper.com/blog/whisper-dictation-linux
Description: Whisper transcribes files brilliantly and is not a dictation tool. What you need to add to make it type into any app on Wayland or X11, and the shortcuts.
Published: 2026-08-02T10:00:00.000Z
Updated: 2026-08-02T10:00:00.000Z
Tags: linux, whisper, voice-typing, dictation, wayland, open-source, whisper-cpp, faster-whisper

Whisper solved transcription. It did not solve dictation, and the gap between those two things is why so many Linux setups stall halfway.

Whisper takes an audio file and returns text. Dictation means: press a key anywhere, speak, and have punctuated text appear at the cursor in whatever window you are looking at. Whisper is one of the four parts you need. This is what the other three are, and what to install depending on how much assembly you want to do.

## TL;DR

- **Whisper alone is not a dictation tool.** You need capture, a trigger, and text injection around it.
- **Fastest local route:** [Handy](https://github.com/cjpais/Handy) or [Speech Note](https://flathub.org/apps/net.mkiol.SpeechNote). Both wrap Whisper-class models with the rest already wired up.
- **Best raw speed on an NVIDIA GPU:** faster-whisper.
- **No Python, or old hardware:** whisper.cpp.
- **You want to build it yourself:** whisper.cpp plus a hotkey script plus `ydotool`/`dotool`. Budget an evening.
- **You do not want to build anything and can accept cloud:** Vibe Typer.

## The four parts of a dictation tool

1. **Capture**: get audio from the microphone while a key is held. PipeWire on any current distro; `parec`, `sox` or `pw-cat` at the command line.
2. **Recognition**: Whisper. This part is solved and free.
3. **Injection**: put the resulting text into the focused window. **This is the hard part on Linux.**
4. **A trigger**: a global hotkey your desktop environment routes to the right script.

Every guide that ends at step 2 leaves you with a transcript in a terminal, which is not what you wanted.

## Which Whisper

### whisper.cpp

A C/C++ port with no Python dependency. Runs on CPU, CUDA, Vulkan and Metal. MIT licensed. This is the one to use on a machine without a discrete GPU, or where you do not want a Python environment in the loop.

```bash
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp && cmake -B build && cmake --build build -j --config Release
bash ./models/download-ggml-model.sh base.en
```

It ships a `stream` example that approximates live transcription. Be clear about what that is: it is a demo of continuous transcription, not a dictation front-end. There is no hotkey and no injection.

### faster-whisper

A Python library built on CTranslate2, roughly 4× the throughput of reference Whisper on an NVIDIA GPU with int8 quantisation. If you have the GPU, this is the fastest path to a good transcript.

```bash
pip install faster-whisper
```

The trade is a Python environment and CUDA libraries you now maintain.

### Which model size

`base.en` is the sensible default for dictation. `small.en` is better on accents and technical vocabulary and still fast on modern hardware. `medium` and above are for transcribing recordings, not for a tool you want to respond in under a second; the latency stops feeling like typing.

English-only variants (`.en`) beat the multilingual model of the same size if you only dictate English. If you switch languages, you need the multilingual one and should expect it to be slower.

## Injection: the part that actually stops people

Getting text into the focused window is where Linux dictation setups die, and it is Wayland's doing, deliberately. Wayland's security model stops one client synthesising input into another, which is a good decision for security and an inconvenient one here.

Check what you are running first:

```bash
echo $XDG_SESSION_TYPE
```

**On X11** it is easy. `xdotool type "$text"` works, and always has.

**On Wayland** your options are:

- **`ydotool`**: goes through `/dev/uinput`, below the display server, so it works everywhere including TTYs. Needs a daemon with access to that device, which is a genuine privilege decision.
- **`dotool`**: the same `uinput` approach with a simpler interface. Same permission question.
- **`wtype`**: the clean protocol-level answer, and it **does not work on GNOME**. Mutter does not implement the virtual-keyboard protocol it needs, and there is no sign that is changing. Since GNOME is the default on Ubuntu and Fedora, this rules `wtype` out for most desktops.
- **Clipboard + paste**: put the text on the clipboard with `wl-copy` and synthesise Ctrl+V. Works widely, but it clobbers your clipboard and fails in terminals where paste is Ctrl+Shift+V.

There is no option here that is both universal and free of caveats. That is the honest state of it in 2026.

## The shortcut: tools that ship all four parts

If you want Whisper-class accuracy without wiring the pipeline yourself:

**[Handy](https://github.com/cjpais/Handy)** is MIT licensed, cross-platform, runs Whisper locally, push-to-talk, handles injection. The closest thing to "Whisper dictation, installed."

**[Speech Note](https://flathub.org/apps/net.mkiol.SpeechNote)** is a Flatpak with a GUI, many engines including Whisper, fully offline, and it will read text back too. Its own window rather than system-wide injection, so it suits composing-then-pasting more than typing directly into an IDE.

**[OpenWhispr](https://openwhispr.com/)** and **Whispering** are Electron and desktop wrappers around the same idea, both open source.

**[nerd-dictation](https://github.com/ideasman42/nerd-dictation)** is worth naming even though it is VOSK rather than Whisper, because its Python post-processing hook is the best scripting story on Linux. Lower accuracy, no punctuation, total control. We compared it in detail in [nerd-dictation vs Vibe Typer](/blog/nerd-dictation-vs-vibe-typer).

## Rolling your own: what it looks like

If you do want to build it, the working pattern is:

1. A hotkey bound in your DE that runs a script on press and release.
2. On press, start `pw-cat --record` to a temp WAV.
3. On release, stop it and pipe the file to `whisper-cli` or faster-whisper.
4. Take the output, strip the timestamps, and hand it to `ydotool type` or `wl-copy` + paste.

That works and plenty of people run it. Things that will eat your evening: the hotkey release event (many DEs only bind press), the `uinput` permissions, `.wav` sample-rate mismatches, and Whisper's habit of emitting `[BLANK_AUDIO]` or hallucinating a "Thanks for watching!" on silence, which you have to filter, or it types it.

## Where Vibe Typer sits, and where it does not

We should be direct: [Vibe Typer](/voice-typing-linux) is not a Whisper wrapper you run locally. It streams audio to a backend and returns punctuated, formatted text. It is a single AppImage, it handles injection natively on Wayland and X11 including GNOME, and there is nothing in the four-part pipeline for you to assemble.

**If offline is a requirement, it is the wrong tool** and one of the local options above is right. We would rather say that here than have you find out after installing it. If offline is a preference and you would rather not spend the evening on `uinput` permissions, that is the trade we are offering.

```bash
chmod +x VibeTyper.AppImage
./VibeTyper.AppImage
```

## FAQ

**Does Whisper run in real time on Linux?**
Not truly streaming, out of the box. whisper.cpp's `stream` example chunks audio and re-transcribes, which approximates it. For dictation you do not need streaming; you need a fast turnaround after you stop speaking, and `base.en` or `small.en` on decent hardware gives you that.

**Do I need a GPU?**
No. `base.en` on whisper.cpp is comfortable on a modern CPU. A GPU with faster-whisper mainly buys you the ability to run a larger model at the same latency.

**Why does my transcript have "Thank you" at the end of silent clips?**
A known Whisper artefact: it hallucinates common phrases from its training data on near-silent input. Filter short outputs and use a voice-activity gate before transcribing.

**Which is better, whisper.cpp or faster-whisper?**
faster-whisper if you have an NVIDIA GPU and do not mind Python. whisper.cpp everywhere else, and on principle if you want one binary with no runtime.

For the complete field of Linux dictation tools, with a Wayland column on each, see [Linux dictation software: 14 tools that actually run](/blog/best-ai-voice-typing-apps-linux). For the input-injection problem specifically, [voice typing on Wayland](/blog/voice-typing-wayland-linux) goes deeper.