# Super STT: A Linux dictation daemon that types into any focused app

> Super STT is a Rust-based speech-to-text daemon for Linux that injects transcribed text into the focused application via an open HTTP protocol. It supports local and cloud models, and its main trade-off is a system-wide installer and a young release history.

**jorge-menjivar/super-stt** — Super STT let's you speak, and your words are typed straight into whatever app is focused

- Repository: https://github.com/jorge-menjivar/super-stt
- Stars: 77 · Forks: 5
- Language: Rust
- License: GPL-3.0
- Published: 2026-08-27 · Updated: 2026-08-27 · Language: en
- Canonical page: https://hysenlabs.com/projects/jorge-menjivar-super-stt

## What Super STT actually does

Super STT solves a narrow but annoying problem: getting transcribed speech into whatever application currently has focus on a Linux desktop. The README describes it as making speech-to-text with automatic text input trivial on Linux. You bind a shortcut, speak, and the daemon types the transcription into your editor, browser, chat window, or terminal. There is no copy-paste step. The target user is someone who wants dictation without per-application plugins or manual clipboard juggling. The project is built in Rust, which is relevant for memory safety and startup time, though the README does not give benchmarks. The core is a background daemon that holds a model in memory and an HTTP protocol that clients use to request transcriptions. The desktop app, CLI, and COSMIC applet are all clients of that daemon, not separate implementations. That architecture is what makes the project interesting beyond a simple dictation tool.

## The daemon and the open protocol

The daemon is model-agnostic. It installs speech models from a library of backends, loads one, and keeps it warm so transcription starts without a long cold start. The protocol is documented and runs over a local socket. Any app in any language can request transcriptions, stream live audio visualizations, or drive recording. Per-app consent is built into the protocol, which is a sensible privacy feature. The README stresses that the desktop app, CLI, and COSMIC applet are just the first clients. That means the protocol is the real product boundary. If you are a developer, you could write a custom client that talks to the daemon without touching the Rust code. The protocol is published at a URL under the project's GitHub Pages, and the README invites anyone to add a model backend. This is a genuinely open design, not just an open-source app with a closed API. The daemon runs unprivileged in your user session, while the installer places files system-wide with root ownership. That split is worth noting: the heavy component does not need root at runtime.

## Installation and first run

The quick install is a curl pipe to bash, which will be familiar to many Linux users and a red flag to others. The command is: curl -sSL https://raw.githubusercontent.com/jorge-menjivar/super-stt/main/install.sh | bash. Append -s -- --beta for the beta channel. Building from source requires the build prerequisites listed in CONTRIBUTING.md and uses just install after cloning. Either method gives you the daemon, the stt CLI, a consent helper, the desktop app, and on COSMIC a panel applet. Everything is wired as a systemctl --user service. The installer asks for sudo because files are root-owned, but the daemon itself runs unprivileged. On COSMIC, the installer offers to bind Super+Space to stt record --write. On other desktops, you add a custom shortcut yourself. The basic usage is stt record --write. That command asks the daemon to start transcribing from your mic, and after silence or a second trigger, it types the result into the focused app. Stop mode can be set per-recording with --stop-mode manual_only, for example. The default stop mode is Silence + Manual, which stops on silence or a second shortcut press. Write method is Auto by default, trying the XDG Desktop Portal, then ydotool, then direct Wayland input. If auto-detection picks wrong, you can force a specific method in Settings.

## Model library and GPU handling

Models come from a library of backends you install on demand. The README lists local options: Voxtral mini and small, which need an NVIDIA GPU with CUDA; Qwen3-ASR 0.6b and 1.7b, which run on CPU or NVIDIA GPU; and Whisper tiny through large, where tiny and base are good CPU defaults. Online providers include Mistral, OpenAI, and Deepgram, each with their own API keys stored in the system keyring. GPU acceleration is a property of the model, not a separate build. The daemon downloads the build matched to your NVIDIA GPU automatically, assuming you have an up-to-date driver. This is a clean approach: you do not manage multiple app builds for CPU versus GPU. The catalog is published live at jorge-menjivar.github.io/super-stt/index.json, and anyone can publish a model backend. That means the model list you see in the app is not fixed; it can grow over time. The README calls this a snapshot, so the actual catalog may differ by the time you install. For a user, the key decision is whether you have a GPU and which model fits your hardware. For a developer, the catalog is a distribution mechanism that could be extended.

## Text injection: the fragile part

The write method is where Super STT can fail, and the README is honest about it. Auto mode tries the XDG Desktop Portal first, then ydotool, then direct Wayland input. Each method has different prerequisites and permissions. The XDG Desktop Portal is the most standard path on modern Linux, but not every portal implementation supports text injection. ydotool requires a daemon running as root or appropriate permissions, which can be a setup hurdle. Direct Wayland input depends on the compositor exposing the right interfaces. The README says you can force a specific method in Settings if auto-detection picks wrong, which implies auto-detection can indeed pick wrong. This is a real limitation: the daemon can transcribe perfectly, but if text injection fails, the result goes nowhere. The project's reliance on systemd user services also means it will not work on systems without systemd, such as some minimal or containerized environments. The README does not mention a fallback for copying to clipboard, which would be a natural escape hatch. That omission is a gap for users who hit injection failures.

## Licence, maintenance, and upgrade cost

Super STT is GPL-3.0, so any derivative work must also be GPL-3.0. That is a strong copyleft licence, which matters if you plan to embed the daemon or protocol in a proprietary product. The project has a recent release history: v0.2.3 from August 2026, with v0.2.2 and a beta before that. The version numbers are low, indicating early-stage development. The README does not mention a migration path or upgrade notes between versions. The installer is a curl script, so upgrading likely means re-running it, but the README does not describe an update command. The daemon is a systemd user service, so upgrades may require restarting the service. The project is not archived, and the last push is recent, so maintenance appears active. However, the lack of a documented upgrade procedure is a cost you should factor in. The protocol is documented, which helps if you build a client, but the protocol itself could change between versions. Given the early release numbers, expect breaking changes.

## Alternatives and how they differ

The most direct alternative is a desktop dictation tool like WhisperDesktop or a browser-based dictation extension. WhisperDesktop, for example, runs Whisper locally but does not inject text into any focused app; it typically copies to clipboard or types into a specific field. Super STT's differentiator is the daemon plus protocol, which allows any app to request transcription, not just the built-in client. Another alternative is a text expansion tool with a speech-to-text plugin, but those are usually tied to a specific application. On Linux, there is also the built-in speech recognition in GNOME Shell, but it is limited to certain apps and does not offer a model library. Super STT's approach is to separate the engine from the client, so you can use the same daemon with a custom client or a different model. That is a real architectural difference. The trade-off is complexity: you run a daemon, manage a systemd service, and handle model installation, whereas a simple tool like a browser extension has no daemon and no protocol.

## Who should adopt it and what to verify first

Super STT is for Linux users who spend a lot of time typing and want a universal dictation shortcut. It is also for developers who want a speech-to-text backend they can integrate into their own apps via the HTTP protocol. The per-app consent mechanism is a thoughtful touch for privacy. Before adopting, verify three things. First, confirm your desktop supports one of the injection methods: XDG Desktop Portal, ydotool, or direct Wayland input. Second, check the current model catalog at the published index to see if your preferred backend is available and whether it requires a GPU. Third, test the systemd user service on your distribution, especially if you use a non-systemd init. The project is young, so expect rough edges and possible protocol changes. If you need a production-grade dictation tool with a stable API, this may not be ready. If you are comfortable with a curl installer, a systemd service, and a growing model library, Super STT is worth a trial. The open protocol is the strongest reason to try it, because it turns a dictation app into a platform.

## Conclusion

Adopt Super STT if you are a Linux user who wants a single shortcut to dictate into any app, with the flexibility to switch between local and cloud models. Skip it if you need a mature, battle-tested tool or if you cannot run a systemd user service. Before adopting, verify that your desktop supports the XDG Desktop Portal or ydotool for text injection, and check the current model catalog at the published index to confirm your preferred backend is available. The project is under active development, so test the beta channel only if you accept frequent changes.

## FAQ

### What does the Super STT daemon do on Linux?

It is a model agnostic background service that installs speech models from a library of backends, local or cloud, loads one and keeps it warm for instant transcription. You pick the model that fits your hardware and can swap it whenever you like.

### How does Super STT type text into other applications?

A write method setting decides, and its default, Auto, picks the first method the session supports: the built-in Wayland virtual keyboard, then the XDG Desktop Portal, then ydotool. A specific method can be forced in Settings when auto-detection picks the wrong one.

### Which Super STT models run without a GPU?

Whisper tiny and base are named as good CPU defaults, and Qwen3-ASR at 0.6b and 1.7b runs on a CPU or an NVIDIA GPU. Voxtral in its mini and small sizes needs an NVIDIA GPU with CUDA. Acceleration is a property of the model rather than a separate build of the app.

### Does Super STT work with online speech APIs?

Yes, with your own API key, which is stored in the system keyring such as GNOME Keyring or KWallet. The providers named are Mistral with voxtral-mini-latest and a realtime Voxtral model, OpenAI with gpt-4o-transcribe, gpt-4o-mini-transcribe and whisper-1, and Deepgram with nova-3.

### Where does the Super STT installer put files on Linux?

Under /usr/local, root-owned: binaries in /usr/local/bin, the systemd user unit in /usr/lib/systemd/user, desktop entries in /usr/local/share/applications, icons in /usr/local/share/icons/hicolor/scalable/apps, logs in ~/.local/share/stt/logs, and a runtime directory under /run/user/. Copy and remove steps ask for sudo while systemctl --user calls stay unprivileged.

## Sources

- [Official README](https://github.com/jorge-menjivar/super-stt#readme)
- [Project repository](https://github.com/jorge-menjivar/super-stt)
- [Release notes](https://github.com/jorge-menjivar/super-stt/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jorge-menjivar-super-stt