Utterform

Type anywhere. Speak naturally.

A focused desktop dictation app for Windows, macOS, and Linux.

Download · How it works · Privacy

Utterform records a short voice clip, transcribes it with OpenAI GPT Transcribe or local Whisper, optionally reshapes the result, then copies, saves, or types it at the cursor. The window can stay out of the way while a global shortcut controls the whole flow.

Utterform is under active development. 0.8.0 — Omarchy's dictation key makes Utterform a dictation backend for Omarchy: choose it in Setup → Defaults → Dictation, then press Alt + Space or hold Right Alt. The Apple-Silicon build is Developer ID signed and notarized; Windows remains unsigned. See the release notes and downloads. 1.0.0 release candidate 1 brings everything since — first-run assistant, Settings with search, ChatGPT text actions, Context, an action per app and audio files — and waits for acceptance on all three platforms: release notes, downloads.

How it works

1. Trigger	2. Speak	3. Keep working
Press Ctrl+Alt+D or click Record.	Use GPT Transcribe, GPT Live Transcribe, or offline Local Whisper.	Copy to the clipboard, save TXT/Markdown, or type directly into the focused app.

• Dictate anywhere. Start and stop from another application without bringing Utterform forward.
• Stay local when you want. Local Whisper with the Plain action keeps audio and text on the device.
• Shape the result. Clean, polish, summarize, or run prompts you can rewrite.
• Choose every destination. Clipboard, file, and typing at the cursor are independent and can be combined.
• Keep control. API keys use the operating system credential store; recordings are temporary and the local log never contains spoken or transcribed content.

Download

The current stable release is 0.8.0 — Omarchy's dictation key.

Platform	Download	Notes
Windows x86_64	Installer · Standalone	WebView2 required; builds are currently unsigned.
macOS Apple Silicon	DMG · App ZIP	Developer ID signed and notarized; macOS 11+.
Omarchy / Arch Linux x86_64	Install script	User-local install; system GTK/WebKitGTK runtime.

Verify downloads with SHA256SUMS.txt. See the 0.8.0 release notes for the current changes.

Windows — one-line install or update

Run in PowerShell (no administrator terminal required):

irm https://github.com/jli-software/utterform/releases/latest/download/install-windows.ps1 | iex

This downloads the latest stable setup, verifies its SHA-256, then opens the normal interactive installer. Quit Utterform before installing and start it normally afterwards. Prefer downloading manually? Download the setup EXE. Windows builds remain unsigned and may show a SmartScreen prompt.

Omarchy / Arch Linux

curl -fsSL https://github.com/jli-software/utterform/releases/latest/download/install-linux.sh | sh

This installs or updates the latest stable version in your user profile and checks the package SHA-256. Quit Utterform first, then launch it from the app menu.

Required runtime packages:

sudo pacman -S --needed webkit2gtk-4.1 gtk3 alsa-lib libayatana-appindicator

Set up in a minute

The first start asks four short questions: cloud or on this device, then the OpenAI key (Create key ↗ opens OpenAI's key page) or the local model, then your language as a code such as de and any names to spell right, and last whether text actions may use your ChatGPT subscription (experimental), plus the dictation key and start at login. Skip setup ends it at once and changes nothing. Nothing is stored, downloaded or registered before Finish, and everything can be changed later in Settings. An upgrade from an earlier version does not show it.

Tune it once, then stay in flow

Settings has a search field on top and five categories below it. Each setting is one row: a short name and its control. Type a word — key, mic, autostart, log — and the matching rows from every category appear, ready to change right there.

Category	Rows
Recording	Microphone, shortcut, sounds
Transcription	Engine (Cloud, Live, Local), OpenAI key, language, vocabulary, topic, local model
AI	Actions (built-in and your own prompts), provider (OpenAI key or ChatGPT), text model and thinking effort
Context	What the Context action may read: selection, clipboard; an action per app
Output	Typing method, keystroke delay, file folder, history
App	Theme, start at login, diagnostics

There is no Save button. Every change applies at once; text fields are written after a short pause in typing, and closing Settings writes whatever is still waiting. A short ✓ Saved confirms it. An entry that cannot be stored — a vocabulary term with < or >, a language that is not a code — stays at its field with the reason and is not saved. Explanations are tooltips; details such as the local model list, the text model's id and effort, or an action's prompt are one level down, behind a row with ›.

Every built-in action is readable and editable. Add your own prompt, or keep Plain for a transcript that never calls a text model.

Live dictation — Windows and Omarchy

In Settings → Transcription → Engine, choose Live (GPT Live Transcribe). The existing GPT Transcribe option keeps the complete-recording workflow unchanged. Both cloud models use your saved OpenAI key, language hints, vocabulary and recording context.

Focus a text field in another application, press your dictation key, speak, then press it again to finish. Text is appended at the current cursor while you speak — Plain transcription only, with no automatic corrections or final full-text paste. Start Live from the target with the shortcut, not by clicking Record inside Utterform.

• Windows: native Unicode input; no helper installation. Elevated programs cannot receive Live input from an ordinary Utterform process.
• Omarchy / Hyprland: keep the compositor binding documented below. Live uses a persistent Wayland virtual keyboard and Hyprland focus events; it does not need wtype. The existing finished-text typing option still uses wtype. Only a confirmed change of the active window, or the target window closing, stops Live; workspace, monitor, layer, launcher and config-reload events alone do not. Hyprland matches its own shortcuts against Utterform's keys by keycode, so Utterform keeps characters off the keycodes Omarchy binds and waits briefly after a stop request for the shortcut's modifier to be released. Each Live recording is numbered in the local log (Settings → App → Diagnostics) with its target window address, workspace id and the focus events it saw, without any text.
• macOS and other desktops: keep using GPT Transcribe or Local Whisper. Live support for macOS is deferred to a separate future release.

A confirmed window change permanently pauses insertion for that recording, while transcription can continue inside Utterform. Finish and recover the transcript there, or start a new recording from your target. No automatic replay on return. Line breaks become spaces; Live never presses Enter, Tab or Backspace. Clipboard/File options apply only on finish.

Do not move the cursor, change tabs/fields or type concurrently while dictating. Window observation cannot identify every in-app focus change, and native key acceptance does not prove an application inserted the text. A revised final transcript stays in Utterform; it does not rewrite already typed words. The Copy action copies the whole transcript, so check existing text before pasting it after a partial delivery.

This first Live release is intended for real-world testing on Windows and Omarchy. Automated checks do not replace microphone-to-field testing in your applications. See the 0.6.1 release notes and the 0.6.0 release notes for scope and test limitations.

Signal design

A focused monochrome interface: white and graphite, a geometric U mark, crisp controls, and a broad, flowing pixel ribbon with fine interwoven filaments driven by your real microphone level. Light, dark, and system appearance apply across recording, settings and menus. The ribbon fills the available recording width, including compact windows. Particles flow independently in response to speech, transitions through processing stay smooth, and the ribbon settles gently over about 1.8 seconds after completion. Pause still freezes the ribbon immediately; reduced-motion preferences keep it still, and hidden windows do no decorative animation work.

The new mark is included in the executable, tray, Windows setup/uninstaller, Linux desktop icon and macOS bundle. Reinstall using the normal installer to update the desktop integration; data and product identity stay the same. Linux refreshes its local icon cache, and Windows notifies Explorer after installation/removal.

Dictate from anywhere

Press one key, speak, press it again. The window never comes forward, so you stay in whatever you were typing in. How the key reaches Utterform depends on who owns the keyboard.

Windows, macOS and X11 — a reserved key combination. Ctrl+Alt+D by default. To change it, open Settings → Recording → Shortcut, click the shortcut field and press the combination you want — there is nothing to spell out. The key is read by its position on the keyboard, so the same physical key gives the same shortcut whatever your layout types; Escape keeps the current one and leaves Settings open. A key without Ctrl, Alt, Shift or Super/Cmd is refused, because reserving a bare key system-wide would stop it typing everywhere else, and a combination another application already holds is reported where you pressed it. On a Mac, Cmd is the key stored as Super. The same switch turns the key off entirely. Nothing to configure elsewhere.

Omarchy 4.5 and later — Omarchy's own dictation keys. On Omarchy the installer also registers Utterform as a dictation backend. Choose Utterform in the Omarchy menu under Setup → Defaults → Dictation; Omarchy then binds Alt + Space to start and finish, and holding Right Alt records while the key is held. A short press is not lost: letting go while the start sound still plays finishes the recording as soon as it runs. Choosing another backend there hands the keys back. The installer adds one row to ~/.config/omarchy/extensions/omarchy-menu.jsonc (a backup is kept next to it) and puts three omarchy-*-dictation-utterform commands next to ~/.local/bin/utterform. omarchy-remove-dictation-utterform removes exactly these again and leaves Utterform installed.

Wayland (Hyprland, Omarchy) — a compositor binding. Wayland gives no application the right to grab a global shortcut, so Utterform takes its orders from the command line instead and the single running instance receives them. Add one line to ~/.config/hypr/hyprland.conf:

bind = SUPER, D, exec, utterform --toggle

The command line works on every platform, from any launcher, script or panel button:

Command	Effect
utterform --toggle	Start recording, or finish the running one
utterform --start	Start recording
utterform --stop	Finish and process
utterform --cancel	Discard without transcribing
utterform	Show the window

If Utterform is not running yet, the command starts it and still records.

Start with your session

Settings → App → Start at login puts Utterform in your system's startup items. It starts hidden in the system tray: no window opens and nothing takes focus from what you signed in to do — open it from the tray when you want it. It is off until you turn it on, and turning it off removes the entry again.

System	What is created	Needs
Windows	A startup entry for your user	No administrator rights
macOS	A LaunchAgent for your user	Utterform installed in /Applications
Linux	An autostart entry in ~/.config/autostart	No systemd service

The switch shows what your system says, not a setting of ours: there is no autostart field in settings.json that could disagree with it. It is read each time Settings opens, written the moment you flip the switch, and read back afterwards: if the system did not take the change, the switch shows what it holds and says why. On Linux the entry points at the installed executable, whose path does not change when you update, so it survives a reinstall.

On Wayland (Hyprland, Omarchy) autostart only keeps Utterform ready in the tray; dictation is still started by the compositor binding above.

Because the window stays where it is, the sounds are the confirmation: a click when recording starts, a click when it stops, and a distinct chime once the text has been transformed and delivered. Turn them off under Settings → Recording → Sounds. The tray icon carries a small red dot while recording as well — on Windows 11, pin Utterform to the taskbar corner first, or the icon sits hidden behind the overflow arrow. If a sound stays silent, Settings → Recording → Sounds → Test plays all three with the window in the background and reports what each did; every sound also leaves an event in the local log, which Settings → App → Diagnostics opens or copies.

Typing at the cursor

Enable Type in the output bar (or press T) to have the finished text put into the window you were working in, next to clipboard and file. Clipboard, file and typing are independent, and typing happens last, so a failure there costs a warning and never the text.

Paste is the default. The whole text moves in one step, so nothing can be dropped or reordered on the way — the reason a terminal used to turn "Session" into "ession". Utterform sends the paste a terminal listens for — Ctrl+Shift+V on Linux, Shift+Insert on Windows — and the one every other window takes (Ctrl+V). Paste delivery leaves the text on the clipboard.

Keystrokes is available under Settings → Output → Type at cursor for windows that refuse a paste. It types character by character, with a leading Shift tap for the Wayland clients that swallow the first character and an adjustable delay (15 ms by default) for the ones that reorder fast input.

On Linux both methods need the session's own input tool, because a Wayland client cannot synthesize input for another window:

sudo pacman -S --needed wtype     # Wayland/Hyprland
sudo pacman -S --needed xdotool   # X11

On Windows nothing needs installing; Utterform uses SendInput directly, sending characters as Unicode so the active keyboard layout does not matter, and the paste chord the way a keyboard would press it. Windows Terminal, the console host behind cmd and PowerShell, mintty, PuTTY, ConEmu, Alacritty, WezTerm, Hyper and Tabby are recognised as terminals; Windows Terminal still shows its own warning before a paste with more than one line unless that is turned off in its settings. Windows refuses input from an ordinary program to a window running as administrator — an elevated terminal, say — and Utterform reports that as a delivery warning naming the program instead of pasting into nothing; the text is on the clipboard regardless. To type into an elevated window, start Utterform as administrator too.

On macOS nothing needs installing either: paste is ⌘V, which every Mac window takes, terminals included; keystrokes are posted one character at a time as Unicode, with the same delay setting as Linux. Both need Utterform under System Settings → Privacy & Security → Accessibility. The first delivery opens the system's request, Settings → Output → Type at cursor says so beforehand, and until it is granted the delivery is a warning with the text on the clipboard. See docs/MACOS.md.

Prompts you can rewrite

Utterform ships seven actions. Plain delivers what you said, word for word, and never reaches a text model. Clean, Polish, Summarize, Prompt, Email and Context each run a written instruction, and every one of them is yours to change under Settings → AI → Actions.

Pick an action on the left, rewrite its name or its instructions on the right. View the original shows the text Utterform ships before you write over it, and Reset brings it back. A dot marks the ones you have changed. Add prompt creates one of your own, which appears in the action menu beside the others.

Only what differs from the shipped text is stored, so a prompt you left alone still improves when Utterform does — and an instruction you cleared falls back to the shipped one rather than costing you the recording.

Under Settings → AI → Text model: the model that runs these prompts (gpt-5-mini by default) and its thinking effort — Auto, Minimal, Low, Medium or High. Auto leaves the model its own default; lower is faster and cheaper. Not every model offers every level, and one that does not know the level you chose refuses the request, in which case the plain transcript is delivered and the reason is shown.

On your ChatGPT subscription (experimental)

Settings → AI → Provider → ChatGPT runs these prompts on your ChatGPT subscription instead of the API, at no extra cost. It uses the login of the Codex CLI: install it and run codex login once; Utterform reads that login from ~/.codex/auth.json (or $CODEX_HOME) and renews it when it expires. Transcription still uses your OpenAI key or the local model. Text model then lists the models the Codex CLI offers; Auto takes the fastest.

OpenAI does not officially support other apps on this path and may block it, which is why it is marked Experimental. Utterform does not quietly fall back to your API key: if ChatGPT refuses, the reason is shown and the plain transcript is delivered.

Voice messages and recordings

Drop an audio file on the window, open one with the folder button next to Settings (or O), run utterform --file <path>, or choose Open with → Utterform in your file manager. The text goes to the history and the clipboard — and to a file when File is on — with the chosen action applied, the same as a dictation; it is never typed at the cursor.

WhatsApp and Telegram voice messages (.opus, .ogg), phone recordings (.m4a), MP3, WAV, FLAC, WebM and AIFF work, up to two hours. With GPT Transcribe, audio longer than twelve minutes is sent in parts of about ten minutes, cut at pauses, so OpenAI's 25 MB upload limit does not stop it. Utterform only adds itself to "Open with"; your default player stays as it is.

Context: say what to do with the selected text

Select some text — an email, a paragraph, a message — start a recording with the Context action and say what to do with it: "reply that Monday at ten works", "translate this into French", "make it shorter". The result arrives at the cursor. What you say is the instruction, the selected text the material.

The selection is read when the recording starts. On Linux Utterform reads the selected text directly (wl-paste --primary from wl-clipboard on Wayland, xclip or xsel on X11); it presses nothing in the other window. On Windows and macOS it uses the clipboard: copy the text first. When nothing is selected the clipboard is used, except for Utterform's own last text; with neither, the instruction runs on its own. Settings → Context switches either source off.

Only the Context action reads the selection or the clipboard, never plain dictation or another action. On Linux the primary selection is whatever you selected last, even in another window, so check what is selected before you use Context for something private.

An action per app

Under Settings → Context → Per app an app can have its own action: Email in Thunderbird, Plain in the terminal. The dictation key then takes that action in that app; everywhere else the action chosen in the window applies. + App lists the apps you dictated into lately, or type a name. When an app's action takes over, a short notification says which, and the window shows it while recording. A recording started from Utterform's own window, and live dictation, never follow an app's action.

Utterform knows the app in front on Linux under Hyprland, Sway and X11 (xprop), on Windows and on macOS. GNOME and KDE on Wayland do not say which window is focused, so there the feature stays off.

Vocabulary

Names, products and spellings a model would otherwise guess at go under Settings → Transcription → Vocabulary, one word at a time: type it and press Enter, remove it with ×. A pasted list keeps its lines. Write Careum there and it stops coming back as Kareum.

GPT Transcribe receives them as keywords, the parameter it offers for exactly this; local Whisper receives them as the text it starts from, which is Whisper's own way of biasing a spelling. They are hints either way — the model still transcribes what it hears. Context below it is free-form ("a standup about the billing rewrite") and reaches GPT Transcribe only.

A term containing < or > is refused by the transcription API, and it refuses the whole request with it, so Settings refuses such a term at the field rather than letting one stray character cost a recording; a term stored by an earlier version is marked red so it can be removed.

Platform notes

Windows has been used for real since 0.4.4 and 0.4.6 is confirmed working there: recording, the dictation key and changing it (Alt+C, for one), the sounds, the tray dot, and typing at the cursor into Windows Terminal, with the warning when a window runs as administrator. macOS is confirmed working since 0.7.0 beta 1, on a MacBook Air (M2, macOS 26) on 2026-09-10: the microphone dialog, GPT Transcribe and Local Whisper, the dictation key and changing it, and typing at the cursor. 0.6.1 and earlier never asked for the microphone because the bundle was signed without the entitlement the hardened runtime requires; 0.7.1 also renames the icon file so the Dock stops showing the logo macOS cached for an earlier version. If Ctrl+Alt+D is already taken on your system, Settings reports it where you pressed it; on a Mac it is ⌃⌥D, and Cmd in Settings means ⌘. The shortcut recorder and the startup switch in 0.7.2 are built and tested on all three platforms but have not yet been used on a real Windows or macOS desktop.

On macOS drag Utterform into Applications. The first recording asks for the microphone, and the first typing at the cursor asks for Accessibility. Since 0.7.5 the stable Developer ID signature identifies updates as the same app, and Apple notarizes the app before release. Windows builds remain unsigned and may trigger SmartScreen. Verify assets against SHA256SUMS.txt; do not disable system-wide security protections.

Push/PR CI runs Linux validation without release compilation. For a test binary — or to check a branch on every platform before tagging it — manually run Actions → Desktop builds on the PR branch and choose the first-test platform requested by Jonas (Linux by default), Windows, macOS, or explicitly all; it publishes nothing. Wait for user acceptance before merging and tagging, unless an immediate full release was explicitly requested. Tagged releases build all three supported targets once and publish only after all checks and packaging succeed.

Features

• Batch transcription with gpt-transcribe — no realtime session required
• Audio files: voice messages and recordings by drop, Open, --file or "Open with"
• Offline transcription through whisper.cpp, built for every supported desktop rather than for the machine that compiled it
• One-click, SHA-256-verified downloads for Tiny, Base, and Small multilingual models
• Plain, Clean, Polish, Summarize, Prompt, Email, and user-defined actions — every shipped prompt can be rewritten
• An action per app for the dictation key: Email in the mail client, Plain in the terminal
• A vocabulary of your own terms, and a reasoning effort for the text step
• Clipboard, TXT, Markdown, or combined output
• Selectable microphone with a system-default fallback
• Global dictation with a reserved key combination on Windows, macOS and X11, or a compositor binding on Wayland: either way without raising the window
• Optional typing of the finished text into the focused window, next to clipboard and file, as one paste or as keystrokes (Linux and Windows)
• A dictation key recorded by pressing it, read by physical key so the layout cannot change it
• Optional start with the user session on Windows, macOS and Linux, hidden in the tray
• Focused-window shortcuts and a compact system tray presence
• Single instance: launching Utterform again reveals the running window instead of starting a second one
• Tray left click opens the window on every platform, double click on Windows and macOS, middle click on Linux; right click keeps the menu
• Background recording across app switches and close-to-tray, with a native ten-minute cutoff
• Signal interface in white and graphite, with a microphone-responsive monochrome contour field, optional start/stop clicks and a distinct completion chime after successful processing and delivery
• Borderless window on Omarchy; standard window controls elsewhere
• Pause/resume without finishing or adding silence; automatic processing after 10 minutes of active recording
• Floating-friendly layout down to 360 × 400; grouped Stop/Pause controls
• Latest text collapsed by default; copy stays visible with a brief checkmark confirmation after actual clipboard success
• Light, dark, and system themes
• API keys stored in the operating system credential store
• Last 100 texts kept locally across restarts, with short titles, European dates/24-hour times, elapsed minutes today, and copy-again controls (can be disabled)

Keyboard shortcuts

Shortcuts work while the Utterform window is focused.

Key	Action
Space	Start or finish recording (also while paused)
P	Pause or resume the current recording without processing it
Escape	Discard the active or paused recording
1–6	Select Plain, Clean, Polish, Summarize, Prompt, or Email
C	Toggle clipboard output
F	Toggle file output
O	Open an audio file to transcribe
Ctrl+Shift+C / Cmd+Shift+C	Copy the displayed text again (latest by default)

Global dictation is separate from these: see Dictate from anywhere. An already-started recording continues when you switch apps, minimize, or close the window to tray (including Omarchy's Super+W). Reopen from the tray to pause or finish it, or let the ten-minute active-recording limit stop capture. A paused recording remains paused across app switches and close-to-tray. Paused audio is discarded, not stored or sent; the microphone device stays open so resuming works consistently across platforms. Processing resumes when the WebView is available. Tray Quit discards active audio and exits; simply launching Utterform does not start recording.

Privacy model

• GPT Transcribe: the temporary audio recording is sent to OpenAI — for an opened audio file, a decoded copy of its audio.
• Local Whisper + Plain: audio and text stay on the device.
• Local Whisper + transformed action: audio stays local; transcribed text is sent to OpenAI.
• Context action: the selected or copied text (up to 20,000 characters) is sent to the text model with your instruction. No other action reads the selection or the clipboard.
• Action per app: the names of up to eight apps you dictated into are kept in settings.json on this device, to choose from in Settings. They are not logged.
• Temporary recordings are deleted after processing or cancellation.
• The OpenAI API key is never written to settings.json; it is stored through the native OS keyring.
• The last 100 completed texts are stored unencrypted on this device in history.json, including clipboard-only output. Titles are generated locally, without an AI call. Disable future storage or clear existing history in Settings; exported files and clipboard contents are not cleared.
• Text history paths: Linux ~/.local/share/software.jli.utterform/history.json (or $XDG_DATA_HOME), macOS ~/Library/Application Support/software.jli.utterform/history.json, Windows %LOCALAPPDATA%\\software.jli.utterform\\history.json.
• A local diagnostic log records what happened, never what was said: recording, transcription, transformation and delivery outcomes, durations, device and application names, HTTP statuses and error categories. It contains no transcripts, history, clipboard or file contents, audio, prompts, vocabulary, recording context, window titles, API keys or raw responses, and redacts home directories. Nothing is uploaded; see Support and diagnostics.

Support and diagnostics

Settings → App → Diagnostics offers three immediate actions; the row's tooltip shows where the log is.

• Copy (Copy diagnostics) puts a report of at most 256 KiB on the clipboard — a short header (version, OS, run, whether the previous run ended cleanly) followed by the newest log lines, sanitized again. This replaces what the clipboard held; paste it wherever you want to share it.
• Log (Open log file) opens the current log in the system's default application.
• Folder (Open log folder) shows the file in Finder, Explorer or the Linux file manager, or opens its folder where the desktop cannot select a file.

The log lives in the operating system's log directory, and the Diagnostics row shows its actual path as a tooltip. Tauri resolves it to Linux ~/.local/share/software.jli.utterform/logs/utterform.log (or $XDG_DATA_HOME), macOS ~/Library/Logs/software.jli.utterform/utterform.log and Windows %LOCALAPPDATA%\software.jli.utterform\logs\utterform.log. At 2 MiB it is rotated, and only the two newest rotated files are kept, so it never takes more than about 6 MiB. The utterform.log that 0.7.8 and earlier wrote next to the history is left in place and never written again; a copied report includes its newest lines when there is room.

An error message that ends in (ref 1a2b3c4d-7) names the log event describing it; quote it when you report a problem. A Rust panic, an unexpected interface error and a previous run that did not exit cleanly are recorded too. A crash of the process itself — a killed process, a native driver fault — can only show up as an unclean exit; no crash dumps are collected.

Development

Requirements:

• Node.js 22+
• Rust 1.88+
• CMake and a C/C++ toolchain for whisper.cpp
• Platform dependencies required by Tauri 2

On Debian/Ubuntu, the native dependencies include:

build-essential cmake clang libasound2-dev libayatana-appindicator3-dev
librsvg2-dev libssl-dev libwebkit2gtk-4.1-dev

Run the app:

npm install
npm run tauri dev

Run checks:

npm run check
npm test
npm run build
npx playwright install chromium
npm run test:e2e
cargo fmt --manifest-path src-tauri/Cargo.toml -- --check
cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets -- -D warnings
cargo test --manifest-path src-tauri/Cargo.toml

Architecture

The Rust core owns audio, secrets, network access, model files, transcription, and delivery. The Svelte frontend only drives the UI and receives non-sensitive results.

Microphone → temporary WAV → TranscriptionProvider
                              ├─ GPT Transcribe
                              └─ local whisper.cpp
                           → optional TextTransformer
                           → Clipboard / TXT / Markdown

See docs/ARCHITECTURE.md for boundaries and design decisions and docs/DEVELOPMENT.md for the shared development workflow and handoff.

License

MIT