speakeasy-show-music.mp4

Private dictation for Windows, macOS, and Linux.
Hold a shortcut, speak, and your words appear wherever you are typing.
Local speech engines. No account, no automatic upload, no dictation history.

Shows  ◆   Get started  ◆   Speech engines  ◆   Everyday use  ◆   Build and verify  ◆   Architecture

Say the word

A speakeasy was a room behind an ordinary door. You spoke at a small slot, the door opened, and what was said inside stayed inside. Speakeasy works the same way: it waits in the tray, opens a small slot on screen while you speak, and recognizes every word on your machine.

Gesture	Windows	Mac
Dictate while held; release to type	Ctrl + Win	Fn
Hands-free; press the shortcut again to finish	Ctrl + Win + Space	Fn + Space
Cancel dictation; the key still reaches your app	Escape	Escape
Paste the last dictation	V during the hold	V during the hold
Show the screen, a window, or an area; see below	S, W, or A during the hold	S, W, or A during the hold

The shortcuts match Wispr Flow's defaults, and double-tapping the shortcut also starts hands-free. On Mac, Settings and the setup guide offer Fn, F13, Right Option, or Right Command. With either right modifier, hold it for a quarter-second before adding Space, S, W, A, or V; quick combinations keep their usual action. Left Option and Left Command remain ordinary modifiers.

For Fn, set System Settings › Keyboard › Press 🌐 key to to Do Nothing so Fn only dictates.

External Mac keyboards: a keyboard's Fn key may switch its own layers without sending anything to macOS. For example, the Keychron Q6 Ultra 8K's Fn is a firmware layer switch. Choose F13 in Speakeasy and use the keyboard's F13 key, or map a spare key to F13 in the keyboard's software. The Q6 Ultra 8K already provides F13; keeping Fn as its layer switch preserves its keyboard controls. F13 supports the same hold, double-tap, and Show gestures without the right-modifier delay, and Speakeasy withholds it from other apps while dictation is enabled. Right Option and Right Command also work without remapping. Speakeasy cannot observe a key that the keyboard does not send.

Remove um and uh removes standalone English hesitation words locally. With Nemotron or Whisper it applies, and starts on, once English is the chosen language; other languages keep every word. Parakeet detects the language as you speak, so the switch starts off and turning it on tells it to clean up English; leave it off if you also dictate in a language where "um" is a word. Speech containing only removed fillers sends nothing.

Paste last dictation in the tray, or V during the shortcut hold on Windows and Mac, inserts exactly the last completed text again. It can recover text when insertion failed. Speakeasy keeps one result in memory, clears it when dictation pauses or restarts or the app quits, and never writes ordinary dictation to disk. Each request has fresh cancellation authority; it cannot retract text already delivered.

Choose Dictation style in the Windows/Mac tray, or use speakeasy style STYLE. Prose uses your filler setting; Verbatim preserves fillers. Both still apply phrase corrections. The other styles produce camelCase, PascalCase, snake_case, kebab-case, or CONSTANT_CASE locally. They join recognized words without rewriting their meaning. The non-Prose choice appears in the pill. A style change applies to the next recording, survives Pause, and resets to Prose when the app restarts. Shows keep ordinary narration regardless of the selected dictation style.

Reading the pill

The pill sits at the bottom of the screen, never takes focus, and lets clicks through to the app underneath. Hold the shortcut and the slot opens; the red waveform follows your voice. Hands-free adds a lock and the elapsed time. Near the five-minute limit, while it works, and once you finish, the pill shows:

• Time left. Recordings stop at five minutes. The last 30 seconds count down in gold, and at zero the recording finishes and its text is delivered as usual.
• Working. The lamp slides through the slot while your speech is transcribed on this machine.
• Typed. A check, shown above, means the text was submitted to your app.
• No speech detected. Nothing was sent.
• Text copied. The text is on the clipboard but was not pasted, for example because the shortcut keys were still held or Speakeasy itself had focus. Paste it where you want it.
• Needs attention. An error says what to do next and stays in Settings after the pill fades.

Soft kalimba notes mark the moments you may not be watching: a high note once Speakeasy is listening, a lower one when you finish or the five-minute limit does, a muted low note when you cancel, two rising notes when a Show starts, and a short chord when text or a Show is copied. Speakeasy listens beneath its own cues, so a recording that hears only a cue sends nothing, while a word said over one still counts. Turn them off with Play sounds in Settings.

Show your coding agent

A Show is a narrated screen recording a coding agent can read. While holding the shortcut, press S to record the display under the pointer, W for the window under the pointer, followed as it moves, or A to drag out an area of the display; a click there instead cancels. Speakeasy records it along with your voice, keeping what you said since you pressed the shortcut, and a thin red line marks the window or area while it records. The pill shows a red screen mark and Hold Shift to draw, then the elapsed time. Release the shortcut and keep talking. To draw circles and arrows, hold Shift and move the pointer without clicking; double-tap Shift to drop a pin where the pointer is. Each mark and pin is numbered ① ② ③ beside it, on screen and in the bundle, so you and the agent can refer to it by number. The ink fades as you go. Click through your app as usual, then press and release the shortcut to finish. Without the shortcut, for example on a Mac keyboard with no Fn key, choose Show screen or Show area… in the tray to start a Show and Finish Show to end it. Escape alone stays with your app: to cancel, hold the shortcut and press Escape, or choose Cancel Show in the tray. Pressing another shortcut while you hold Speakeasy's, locking the screen, or sleeping finishes the Show rather than discarding it. Once you finish, the Show is saved even if you press Escape.

In this example, a Show reports bugs in a made-up settings app, and speakeasy show demo writes the same bundle.

Speakeasy picks the keyframes your ink, clicks, and words point at, annotates them, and writes a bundle of keyframes, contact sheets, summary.md, and show.json. A Show keeps up to 36 keyframes spread across the whole recording, at most six to a sheet, and the summary names each sheet's frames. The pill says Show copied and the summary is on the clipboard: paste it into your agent, and the summary tells the agent how to read the Show. Shows record on Windows, and experimentally on Mac, but not on Linux. On Windows, streaming and screen-sharing apps such as Sunshine, OBS, or a video-call app don't see Speakeasy's windows or ink while a Show records; the keyframes still carry the ink.

Windows Shows and Mac screen and area Shows also save silent H.264 video in recording.mp4, targeting 30 frames per second at up to 2560 pixels per edge. Windows video follows the chosen screen, window, or area; Mac video uses a fixed display region. Both follow the original five-minute limit. Resized windows fit inside a fixed canvas; a quiet ending holds the last image. The video has no audio or drawn annotations. Its timing file, recording.json, records the session origin, surviving video coverage, timed content rectangles, and the separate horizon of marks and narration. Changing the display size, position, or scale ends capture; start a new Show. Capture or disk failure can shorten video coverage. Recovery retains only complete fragments; if none were written, the stills save with a video-loss notice. A failed copy of surviving video keeps the checkpoint for recovery. Mac window Shows currently retain sampled frames only.

On Windows, the summary for that contact sheet reads as follows:

Screen recording (0:20, 5 keyframes): `…\speakeasy\shows\20261020T143205Z`
Before acting, open the contact sheet, then the full-size frames that matter: they show what the words leave out. Speech recognition can mishear a name; where the screen spells it differently, trust the screen. Cite frames as #N and marks by their circled numbers.
Contact sheet: `…\speakeasy\shows\20261020T143205Z\contact-sheet.png`
- #1 (0:02) “Here's the settings window.”
- #2 (0:02) [clicked] “When I open Appearance,”
- #3 (0:09) [① circled, ② drew an arrow] “the theme picker is here, but look, this label runs under the save button.”
- #4 (0:12) [③ pinned, clicked] “Now I click reduce motion and nothing happens.”
- #5 (0:17) [dragged right] “Dragging the text size slider works, though.”
Full-size keyframes: `…\speakeasy\shows\20261020T143205Z\frames\frame-01.png` to `…\speakeasy\shows\20261020T143205Z\frames\frame-05.png`. Timeline: `…\speakeasy\shows\20261020T143205Z\show.json`.

A Show records only what you name. With no window to record under the pointer, or if you finish before dragging out an area, it is cancelled, narration and all: nothing is pasted or saved, and the pill says why. If screen capture stops before you finish, or the window closes or goes off screen, the Show ends there with what it recorded: the pill says why, and the summary's second line says why and when. A microphone that stops after it starts listening ends the Show there too. Then, or when your speech can't be transcribed, the Show is saved without narration rather than lost: the pill says Show copied without narration and what went wrong. The summary tells your agent why; when recovery audio survived, Transcribe narration in Shows can save a narrated copy.

On Windows and Mac, the menu's Copy last Show copies the latest Show's summary.md again as it reads now, edits included, and Open last Show opens its folder. Speakeasy remembers only that one Show, and only until it quits. Once that Show expires or is deleted, either entry says so and both turn off until your next Show; neither reaches for an older one. If a finished Show cannot be copied, it stays saved and the pill points you to Copy last Show.

Read saved Shows

Open Shows in Settings, or Shows… in the Windows/Mac tray, to review saved Shows across restarts. Choose a Show to see its keyframes, numbered marks, current summary, and retention status. Use Up/Down to choose a Show, Left/Right to step through frames, Page Up/Down to jump ten seconds, Home/End to jump to the first/last frame, and Escape to close. Missing frames, early endings, and lost narration stay visible; the viewer never substitutes another Show when the selected one expires or is deleted. Choose All retained frames to inspect moments outside the selected keyframes. Coverage shows the sample count and longest gap; the journal thins frames under memory pressure, so this is sampled evidence rather than video. Switching modes keeps the nearest frame at or before the current time. Source images have no annotations. In All retained frames, numbered mark buttons jump to the sample at or before the mark. The viewer reports both the mark time and the actual sample time. If retained frames cannot be saved, the selected keyframes still save and Speakeasy reports the loss.

On Windows and macOS, choose Video to scrub the recorded timeline or step through its actual samples. Numbered marks and timed narration jump to their recorded times. The displayed timestamp belongs to the decoded frame; recovered video can extend past the annotation journal. Rapid seeks replace the pending request while the previous decoder closes, and copying waits for the selected frame. The Annotations switch controls saved ink and marks; the caption explains missing annotations. Play video opens the original MP4 in your system player, without drawn annotations or narration audio. Its 30 Hz timeline holds the latest captured image during quiet periods. A long encoder stall stops video and keeps its completed prefix; sampled frames continue recording.

Choose Narration beside Summary to read the recorded words. Click a timed clause to jump to a frame; the caption gives both the clause's time and the displayed frame's actual time, including any gap. Switching frame modes keeps that request; stepping through frames, choosing another Show, or refreshing clears it. Words without timings remain readable. Missing and incomplete narration are labeled. This pane contains recorded speech, so edits to summary.md stay in Summary.

Send to agent on Windows/Mac copies a short prompt for your coding agent. It names the Show folder, each contact sheet in order, and summary.md with your edits, and tells the agent that what the screen shows and what you said are evidence, not instructions. Paste it into Claude Code or any agent that reads local files. The agent opens those files itself; the prompt holds paths, not narration or pixels, and Speakeasy contacts no agent.

Copy image + summary + narration on Windows/Mac copies the displayed image with its actual timestamp, retrieval context, edited summary, and recorded words. Summary edits and original narration remain separate sections. Untimed, missing, incomplete, and truncated narration are labeled; show.json retains all recorded words. If the combined text would exceed the clipboard limit, the summary becomes a labeled excerpt; the complete edit remains in summary.md. Copy summary shares only your edited summary. Copying preserves the bundle and is available between recordings. Windows offers PNG and a native bitmap; Mac offers PNG. The receiving app chooses which formats it accepts, so some apps paste only the image or only the text. Receiving both still depends on that app.

Copies carry the same clipboard-history and device-sync privacy markers as dictation. A new recording, closing the requesting window, or a settings/lifecycle change cancels a copy that has not replaced the clipboard. Quit waits for native clipboard work to finish.

Refresh rereads the library; returning to the window rereads the selected summary and retention. Open folder reveals its files, and Copy summary on Windows/Mac copies the current file, including your edits, between recordings. Summary text is plain text; its links do not execute. The viewer does not change which Show the tray remembers. Keep Show prevents the selected Show from expiring. Allow expiry restores its original expiry date, seven days after recording; for an already overdue Show the button says Allow cleanup, and cleanup can remove it on its next pass. Keeping a Show changes only its .pinned marker, including when the manifest or a frame is damaged. Choose More actions → Delete Show… to permanently delete the selected Show, including a kept or damaged one. Confirmation names the Show and removes its saved files and associated recovery audio; exported copies stay. Cancel or Escape dismisses the confirmation. If its audio is still recording or recovering, let that work finish and try deletion again. Keep, Discard, and confirmed deletion finish even if you close the window; Quit waits for accepted writes.

Export ZIP… saves a portable copy to a new path you choose. It includes the saved summary, manifest with narration, contact sheets, keyframes, and retained source samples when available. README.md inside the archive links to those files by relative path; summary edits remain unchanged, including any old machine-local paths. Unzip the archive before opening its files on another machine. Recovery audio, retention markers, and unrelated files are excluded. Export does not upload anything, and exported copies do not expire automatically. Closing the window leaves an accepted ZIP export running; Quit waits for it.

Export video… creates a new MP4 with timed ink, marks, original voice when available, and a selectable caption track when narration has word timings. Install FFmpeg 5.1 or newer with H.264 and AAC support, put ffmpeg on PATH, then restart Speakeasy. macOS also checks the standard Homebrew and MacPorts locations. Export runs locally on all platforms with retained video. The original recording stays unchanged. Cancel export or closing the window cancels the video export; Quit waits for cleanup. Voice expires seven days after recording even when you keep the Show. Shows without available voice export silently, with a notice. Explicitly exported videos do not expire automatically.

An Interrupted Show offers Recover Show and Discard. Recovery restores checkpointed frames, ink, marks, and narration into a new bundle, using your configured local speech engine and the original language. It waits for any active recording to finish, opens no microphone, and leaves the clipboard untouched; resume Speakeasy first if it is paused. Missing or damaged audio leaves a Show without narration; a recovered audio prefix is marked incomplete. Recovery preserves the original seven-day expiry date.

If transcription fails, the frames are saved and the entry becomes Narration pending. Transcribe narration retries with the current local engine and text corrections, saving a narrated copy without changing your earlier Show or edits. A failed retry keeps the audio without creating another copy. Discard audio removes its recovery checkpoint and leaves the saved Show alone. Discard always requires confirmation.

An agent on the same machine can inspect a Show without launching the app or opening the microphone. Shows name their local executable and exact ID in the summary when retained samples and a usable command are available. Quote that executable path for your shell; the app does not install it on PATH. In Windows PowerShell, use & 'PATH\speakeasy-cli.exe' show … for the commands below. If the package moves, use its new path. A moved Show uses its explicit folder path instead of its ID.

speakeasy show list --json
speakeasy show inspect "PATH_TO_SHOW" --json
speakeasy show inspect 20261020T143205Z --json
speakeasy show frames 20261020T143205Z --json
speakeasy show frame 20261020T143205Z --at 0:12.500 --out /path/to/new-frame.png --json
speakeasy show frame 20261020T143205Z --video --at 0:12.500 --out /path/to/new-video-frame.png --json
speakeasy show frames 20261020T143205Z --phrase "save button" --json
speakeasy show frames 20261020T143205Z --mark 2 --crop --out /path/to/new-sheet.png --json
speakeasy show keep 20261020T143205Z
speakeasy show keep 20261020T143205Z --off --json
speakeasy show export 20261020T143205Z --out /path/to/new-show.zip --json
speakeasy show video 20261020T143205Z --out /path/to/new-show.mp4 --captions --json
speakeasy show video 20261020T143205Z --phrase "save button" --around 2000 --out /path/to/clip.mp4
speakeasy show skill --install /path/to/agent/skills
speakeasy show skill

list finds interrupted Shows first, then saved Shows newest first, including damaged or unsupported ones. It lists the timestamp-named folders in Speakeasy's Shows folder; use inspect with an explicit path for a moved or exported Show. A bare timestamp name, including a same-second suffix such as -2, is an exact Show ID in Speakeasy's Shows folder. IDs never fall back to another folder or a partial name; use ./ID to force a relative path. These commands also work without a desktop on Linux. list and inspect leave files, edits, permissions, and retention unchanged. There is no implicit latest Show.

export writes only a new ZIP outside the original bundle and leaves the original and its retention unchanged. It checks the manifest and expected file inventory without decoding image payloads. Missing, linked, or oversized files, invalid retained-source indexes, and mismatched timelines fail the export. Encoded image and video data are preserved; MP4 fragment headers are normalized for playback. It streams at most 2 GiB of saved content into a private temporary file, then publishes the complete archive without overwriting an existing path. JSON output contains the export path, file count, byte count, and whether retained samples are included; it contains no private text.

ZIP exports include recording.mp4, recording.json, and relative playback links in the guide. They exclude saved voice. show video composes a separate 30 fps H.264 MP4 with AAC voice and optional selectable subtitles (--captions). It accepts the same focus queries as frame export; without a focus it exports the entire retained video and available voice, holding the first or last image where voice extends beyond screen coverage. Reports describe the selected session interval, voice availability, caption count, and missing annotation coverage. It never overwrites an existing file. Inspection validates complete fragment ranges and their timing; it does not decode compressed video.

frames accepts a time, mark, or spoken phrase to locate surrounding evidence. Phrases match recorded narration after corrections, ignoring case and punctuation; summary edits are separate. Repeated phrases return all matching spans. Choose --match N before exporting one occurrence; untimed narration cannot locate a phrase. Phrase arguments can be visible in local process listings. --around widens the span by 1000 ms on each side by default, up to 10000 ms. A sheet exports at most six distinct samples by default (--most accepts 1–12), with millisecond sample times on each cell. --crop focuses on a numbered mark with surrounding context, and refuses sheets spanning a surface resize. Reports include the requested window, carried-in sample, sampling gaps, actual times, and source crop pixels. Exports require new paths and preserve the saved bundle.

On Windows and macOS, frame --video retrieves a moment from recording.mp4 by time, mark, or phrase. Times use the original recording's clock. The report distinguishes the requested time from the actual decoded sample and includes video coverage and the separate annotation horizon. Recovered video can extend beyond the sampled-frame journal. Add --crop with --mark to focus on a mark with surrounding context. The crop uses the actual decoded frame’s content rectangle and requires a matching saved coordinate space for every point in the mark. Older, mixed, missing, or mismatched geometry refuses the crop; the uncropped video remains available. Add --annotated to draw saved ink progressively, label completed marks, and show completed pointer actions. The viewer's Annotations switch uses the same rendering, and copied evidence includes the setting in its retrieval command. Drawn pixels stay within the captured content; crops follow annotation rendering. Unknown or incompatible marks are omitted and counted in the report. Explicit annotated exports require video geometry and annotation coverage; the viewer explains when it shows original video instead. These saved annotations do not reproduce live overlay fades. Video contact sheets are not supported. Linux can open the movie in its system player.

keep accepts an ID or an explicit path directly inside Speakeasy's Shows folder. --off allows expiry at the original date; it does not grant another seven days. These actions never recreate a missing Show, change the tray's last Show, or modify summaries and manifests. An exported or moved folder outside managed storage does not expire and cannot be kept through this command. --json reports the resulting pinned flag and expiresAt date.

inspect maps each contact sheet to its frames and each numbered mark to its saved frame. Its paths point to the bundle's current location, even if the summary still names the original folder. Read every contact sheet, then the user's current summary.md, then the relevant full-size frames. Inspection prints metadata and paths, never narration, spoken cues, or screen content. It checks the manifest and expected files without decoding images; ok means those structural checks passed, not that every image decodes. Missing files remain visible beside the frames that survived. A mark with no saved frame is reported without substituting another image.

list and inspect offer readable text without --json. JSON reports ok, damaged, or unsupported status; list also reports interrupted or narrationPending, plus id and expiresAt. An ID is non-null only when the directory is confirmed to be a managed Show. expiresAt is the UTC time the Show becomes eligible for cleanup, or null when kept, unmanaged, or unavailable; deletion occurs during a later cleanup pass. The pinned field describes retention, not numbered pin marks. If the manifest cannot be read, duration, counts, and pin status are null, and inspection omits its detail fields and frame tables. Inspection exits with status 1 for damage or an unsupported format, after printing its findings. A listing succeeds even when individual Shows are damaged. An unreadable Shows folder fails the command; a missing one is an empty listing. The recording's narrationLost field is absent when no narration loss was reported, or audioStopped, notTranscribed, or incomplete. incomplete means recovery transcribed the surviving audio prefix; its text and timings cover only that prefix.

Manifests are limited to 16 MiB and summaries to 1 MiB. Only the current format, 3, is read and written; unknown fields are ignored. Other formats are reported as unsupported and left untouched.

For MCP clients, run speakeasy show mcp --setup to print Claude Code, Codex, and generic setup snippets. The stdio server requires explicit --root PATH arguments: each root is one saved Show or a folder containing Shows. show_list, show_read, and show_image expose only those roots; requests cannot add folders. Tools can read the edited summary, bounded narration, saved images, and retained source frames by time, mark, or phrase. They report actual sample times and gaps. They do not expose ordinary dictation or export video. Requested content reaches the calling agent and may reach its model provider. Setup prints configuration without changing client settings.

Scripts can control a running desktop app without reading dictation text:

speakeasy status
speakeasy dictation start --style snake
speakeasy dictation stop "TOKEN_FROM_START"
speakeasy dictation cancel "TOKEN_FROM_START"
speakeasy paste-last
speakeasy style prose
speakeasy preset "Coding"

Each command accepts --config PATH for that app instance and returns JSON. Exit 0 means the owner acknowledged the action, 1 means refused, and 2 means unavailable or uncertain; an acknowledgement does not prove transcription or insertion completed. Start creates a hands-free ordinary dictation; stop and cancel require its exact session token, which expires with that session or app restart. Busy starts, stale tokens, and commands targeting Shows or private practice are refused. Read status after an uncertain result instead of blindly retrying. style changes the next-recording default; dictation start --style overrides only that recording. These explicit commands work on all three platforms; Linux's desktop-binding --toggle and --cancel still require Desktop bindings.

show skill prints the agent reading guide embedded in the installed binary. Save it as SKILL.md in a skill folder your agent loads. It explains the reading order, numbered references, private-file handling, and source-frame retrieval. frames reports retained timestamps, sampling stride, and the longest gap. frame requires an explicit focus (--at, --mark, or --phrase) and a new PNG path; it exports the image at or before the resolved time, or the first image when the request precedes capture. Its metadata reports both requested and actual times. It refuses times after the Show ends and never overwrites a file. These commands cannot retrieve discarded frames or retry lost narration. speakeasy show --help lists their options.

list gives interrupted Shows distinct interrupted:ID identifiers and null duration/frame counts; it does not replay their logs. speakeasy show discard "interrupted:ID" --json permanently removes that explicit checkpoint; an exact checkpoint path from list also works. A saved Show ID cannot select an interrupted Show with the same timestamp. Recover through the native Shows window.

During an explicit Show, a private checkpoint records frames, pointer events, and audio on one background writer. Promotion to a Show includes the narration already buffered since the press. Recovery uses the last complete event; a crash, storage failure, or a full bounded write queue can leave a shorter recording. Recording continues in memory if checkpointing stops, with a local notice. Recognized narration and export voice are saved durably before the checkpoint is retired. A save failure leaves the checkpoint available for recovery; a copy failure leaves the saved bundle available in the library. Cancelling, quitting, pausing, changing settings, or losing desktop input during an unfinished recording discards its checkpoint. Once you finish a Show, those interruptions leave its checkpoint recoverable, including while capture stops, the checkpoint flushes, narration transcribes, or publication saves the bundle. Hidden incomplete saves are removed once they are at least an hour old. Cleanup hides expired Shows before deleting their files and retries interrupted deletions on its next pass.

What's said here stays here

• Speech runs in a local NeMo-Speech.cpp or whisper.cpp process that Speakeasy owns and stops. Setup downloads the engine and model once; recognition uploads nothing.
• The microphone opens only while you dictate. Audio, transcripts, and engine output are never logged.
• The screen is recorded only during a Show you start, and Speakeasy's own windows stay out of it. A Show is written to the shows folder beside the engine and model, readable only by you. Speakeasy deletes Shows and interrupted checkpoints over seven days old when it starts and hourly while it runs; a file named .pinned in a saved Show's folder keeps it. A checkpoint holds up to 1 GiB of frames and pointer events plus 128 MiB of audio. After transcription, saved Shows retain private voice for explicit video export until seven days after the original recording. Keeping a Show does not extend voice retention. Export refuses expired voice even before cleanup runs; cleanup deletes voice from kept Shows too. Pending recovery audio is removed on cancellation, discard, or expiry. Ordinary dictation stays in memory. Saved bundles can include up to 512 MiB of retained source frames in addition to their selected images and private voice.
• Windows clipboard history and cloud clipboard skip what Speakeasy puts on the clipboard, pasted dictation and Show summaries alike, as do Universal Clipboard and Mac clipboard managers that honor transient data.
• There are no accounts, telemetry, or dictation history. An agent you hand a Show to, by MCP request or a pasted Send to agent prompt, reads that Show's evidence, and its model provider may receive it.

Get started

Download Speakeasy from the latest release. Choose the Windows installer or Mac disk image when offered; otherwise unpack the portable ZIP. The Windows installer needs no administrator access; on Mac, drag Speakeasy to Applications. Linux's experimental AppImage and tar packages are described below.

The Windows installer is unsigned. If SmartScreen warns, use More info › Run anyway only for the installer you downloaded from this repository's release page. Quit Speakeasy from its tray menu before upgrading or uninstalling; the installer asks you to do so if its files are in use.

Windows installs into your local Programs folder and adds a Start menu entry. Installing an update replaces the app; uninstalling keeps your settings, downloaded models, and Shows. The installer does not change your PATH. Add its folder yourself if you want to run speakeasy-cli by name.

Keep the Windows package together: speakeasy.exe opens the app, and speakeasy-cli.exe runs Show commands from a terminal or agent, returning output and exit status to the caller. The CLI accepts show, status, dictation, paste-last, style, preset, --version, and --help; launching it without arguments prints help.

On a Mac, allow Microphone and Accessibility access when asked, and Screen & System Audio Recording for Shows. If macOS says it cannot verify Speakeasy, open System Settings › Privacy & Security and choose Open Anyway. Check permissions after replacing the app: locally signed builds can require Accessibility and Screen & System Audio Recording grants again. If either stops working, remove Speakeasy from that list with − and add it again.

The first launch guides you through local speech setup, dictation access, private practice, and a ready screen. Speakeasy checks the machine, downloads the matching NeMo-Speech.cpp build and NVIDIA's Parakeet v3 model, about 0.8 GB in all, and turns dictation on:

Machine	Engine build	Speech runs on
Windows, NVIDIA GPU with 6 GB or more	CUDA	GPU
Windows, another discrete GPU with 6 GB or more	Vulkan	GPU
Any other Windows PC	Vulkan, or CPU without a Vulkan driver	CPU
Mac with Apple silicon	Metal	GPU
Linux x86_64	CUDA, Vulkan, or CPU after compatibility checks	GPU or CPU

The guide shows your configured shortcut and microphone activity, then waits for recognized words before offering the ready screen. Practice stays private; the final screen explains how to check text delivery in your own editor. Skip setup returns to Settings without stopping an active download. Unfinished setup opens again on launch; General → Setup guide → Replay brings the guide back without resetting your settings. In --demo, replay uses simulated words and never opens a microphone.

Then hold Ctrl + Win (Windows), Fn (Mac), or Ctrl + Super + Space (Linux) in an editor and speak.

Settings opens on Dictation: your shortcut with a private practice area, the Show shortcuts on Windows and Mac, the speech model, language, microphone, writing options, and presets. Words holds phrase corrections and recognition hints. General holds the theme, motion and sounds, permissions, updates, the setup guide, and Start over…. Leaving Dictation ends private practice and clears its text.

General → Privacy shows microphone access, and on macOS Accessibility and screen permission, without prompting or capturing anything. Permission status refreshes when Settings comes to the front; Open settings opens the matching system page on macOS and Windows. Linux's Microphone help opens the setup guide. Windows and Linux access stays Checked when used, because a privacy setting alone cannot prove access. An allowed permission does not prove the hardware or another app works. Start practice under your shortcut lets you use the real shortcut and microphone while your words appear only in Settings. Nothing is pasted, copied, or saved, and practice cannot record a Show. End practice, hiding the window, losing focus, or changing settings ends practice and clears its text. To check delivery, end practice and dictate into an editor; practice does not verify another app's input or clipboard behavior.

Check for updates under General contacts the repository's latest-release endpoint on GitHub only when clicked. It sends no recordings, settings, or device details. Release notes opens that version's official download page; checking never installs or runs an update.

Windows builds with a configured update signing key also offer Download for an installed copy. The download verifies the signed version and installer bytes before offering Install and restart. Finish or cancel recording first; installation waits for pending work and settings saves to finish. It preserves the installation folder and selected settings file. Portable or moved copies use the release page. Downloading and installing always require separate actions. Builds without an embedded signing key offer the release page only.

Downloads come from pinned GitHub and Hugging Face URLs and are checked against their SHA-256 before use. They live in %LOCALAPPDATA%\speakeasy on Windows and ~/Library/Application Support/speakeasy on Mac. Cancel pauses setup, and the next attempt resumes where it stopped.

Build from source

Speakeasy targets Windows 11 x64, macOS 14+ on Apple silicon, and experimental Linux x86_64 builds with glibc 2.35 or later. Use the pinned nightly Rust toolchain in rust-toolchain.toml. Windows builds need the Visual Studio C++ Build Tools and the Windows SDK; macOS builds need the Xcode command line tools.

cargo run --locked -p speakeasy -- --demo     # simulated preview
cargo run --locked -p speakeasy               # the app
cargo run --locked -p speakeasy -- show demo  # a scripted Show bundle

--demo uses simulated audio without the microphone, global shortcut, model, or clipboard. It previews hands-free, the countdown, submission, a Show with its ink on Windows and Mac, interrupted dismissal, cancellation, silence, copied text, and an error. --demo-tray adds the tray and the Settings hide-and-reopen behavior with dictation disabled. Both modes use a temporary synthetic Show library and leave saved Shows alone. --demo opens that library automatically; --demo-tray opens it through Shows. show demo writes a scripted Show bundle and prints its summary. Linux has experimental desktop support; see the Linux instructions below. Linux builds need pkg-config and the ALSA, fontconfig, FreeType, X11/XCB, xkbcommon, and Vulkan development packages. On Ubuntu:

sudo apt-get install libasound2-dev libfontconfig1-dev libfreetype6-dev libx11-dev libxcb1-dev \
  libxkbcommon-dev libxkbcommon-x11-dev libvulkan-dev pkg-config

Linux (experimental)

Download the x86_64 AppImage or tar archive from the release. The application targets glibc 2.35 or later and needs a Wayland compositor with layer shell (KDE Plasma, sway, Hyprland, niri) or X11 or Xwayland, plus Vulkan and desktop audio support. It shares audio, engines, the session owner, Settings and the pill with Windows and Mac. Native GNOME/KDE/X11 acceptance is pending; see implementation and acceptance for support limits.

The defaults are Ctrl+Super+Space to hold or double-tap for hands-free and Ctrl+Super+Escape to cancel. Linux's cancel chord is reserved; bare Escape is not globally captured. Wayland requests desktop shortcut and keyboard permissions; Settings shows the actual accepted bindings. Install the supplied io.github.krvh.speakeasy.desktop file in ~/.local/share/applications (or the corresponding XDG data directory), and make the executable available as speakeasy on your PATH. Portals use this installed launcher identity. For source builds:

cargo build --release --locked -p speakeasy
mkdir -p "$HOME/.local/bin"
ln -s "$PWD/target/release/speakeasy" "$HOME/.local/bin/speakeasy"
install -Dm644 packaging/linux/io.github.krvh.speakeasy.desktop \
  "${XDG_DATA_HOME:-$HOME/.local/share}/applications/io.github.krvh.speakeasy.desktop"

For the tar package, link its absolute Speakeasy.AppDir/AppRun path instead, and install the desktop file from usr/share/applications inside that directory. For AppImage, make it executable, link its absolute path as speakeasy, and install the desktop file from this repository or its --appimage-extract output. The executable stays in the chosen location. On Wayland, automatic paste needs compositor modifier feedback and libei, and typing needs EI direct text support; X11 pastes through XTest and cannot type. Settings' Insert text by control chooses Paste (Ctrl+V), Paste (Ctrl+Shift+V) for terminals, Type (keeps clipboard), or Copy for manual paste if automatic insertion is unavailable. X11 automatic paste needs the first keyboard layout active and an unshifted V key in it; otherwise Speakeasy copies the text and explains how to paste it.

For a desktop without suitable shortcut permissions, set General → Desktop → Shortcuts to Desktop bindings and assign the two commands Settings shows in your desktop's shortcut settings: speakeasy --toggle and speakeasy --cancel, with --config when you use another settings file. This mode starts/finishes hands-free. Set Insert text by to Copy for manual paste as well to avoid requesting keyboard-control access. The optional linux settings object holds the shortcut and cancel chords in portal syntax, such as CTRL+LOGO+space: X11 grabs them, and Wayland requests them as preferred triggers. It also holds external_shortcut, which Shortcuts sets. The top-level text_delivery setting holds the Insert text by choice: paste, terminal_paste, type, or copy. Pause and resume dictation after changing bindings or keyboard maps.

A tray host is optional: without one, closing Settings quits and the launcher reopens the app. Configuration lives under $XDG_CONFIG_HOME/speakeasy, downloads under $XDG_DATA_HOME/speakeasy, and private portal restore credentials under $XDG_STATE_HOME/speakeasy, with standard home directory defaults. Some CPUs without AVX-512 cannot run the pinned Linux CPU engine; Speakeasy checks before readiness and explains how to choose another engine in Settings (details).

Speech engines

Parakeet is the default: NVIDIA's Parakeet TDT 0.6B v3, run by NeMo-Speech.cpp. It detects the language automatically and needs microphone audio at 8–96 kHz. Setup chooses its build, and Prefer GPU switches between the GPU and the CPU. After a five-minute recording the GPU worker holds about 3.8 GB of memory until Pause releases it. The model is by NVIDIA, under CC BY 4.0.

Long Parakeet dictation starts recognition at pauses while you keep speaking, reducing the work left after release. Text still arrives once, when you finish, with phrase corrections applied across the whole dictation.

Nemotron is an optional 742 MB download under Dictation → Speech model. NVIDIA's Nemotron 3.5 ASR Streaming 0.6B supports 32 locales, including Hindi, Japanese, Korean, and Mandarin. Choose a language or automatic detection. It performs continuous inference during ordinary dictation and practice; final text arrives once, after release. If continuous recognition fails, Speakeasy retries the complete recording with the same model. Parakeet remains the default; choosing Nemotron downloads what is missing and switches when the download finishes. Whisper and Show narration use whole-recording recognition.

Recognition hints under Words helps Nemotron recognize names and jargon without forcing replacement text. Add a name or phrase; it applies right away. Up to 100 hints are stored locally; each allows six words and 64 characters. They remain saved when another model is selected, but only Nemotron uses them. Use Corrections when you want a deterministic replacement.

Your own engine, under Dictation → Speech model, runs a whisper.cpp or NeMo-Speech.cpp build you installed. Choose whisper.cpp or NeMo-Speech, then the program and model file for that engine; Speakeasy switches once both are chosen. Switching engines clears the other engine's files, and switching is always explicit. Whisper runs a local whisper.cpp server with a GGML model. The known-good Windows build is whisper.cpp b5130: extract the complete runtime and choose Release/whisper-server.exe. Turn off Prefer GPU for a CPU-only build. The threads setting applies to Whisper and defaults to four. On shared Linux machines, prefer Parakeet: other accounts can read Whisper's request route.

The worker stays warm on loopback. With a GPU, one silent request initializes its kernels before the first dictation; Linux CPU workers also validate inference before readiness. Cancelling before final recognition discards early Parakeet results while their worker finishes. Cancelling a Nemotron stream closes it and reuses the worker after a bounded recovery check. Cancelling final GPU inference keeps a healthy worker and replaces it if a two-second recovery check fails; cancelling final CPU inference replaces the worker. On Mac and Linux, force-quitting Speakeasy can leave the worker running; quit from its menu instead. Relative engine and model paths resolve beside the settings file.

Everyday use

Settings

Settings shows your shortcuts and the speech model in use, and lets you choose the microphone, language, recognition hints, GPU use, filler removal, how text is delivered, reduced motion, sounds, theme, phrase corrections, and on Windows whether Speakeasy starts at login. Changes apply as you make them. Pause or Resume, Shows, Quit, and the status line stay at the bottom while the rest scrolls. The status says whether dictation is ready, confirms Saved, or shows the latest error or notice; problems show in the attention color.

On Windows, assistive tools can read and operate the main Settings buttons, page tabs, switches, and phrase-correction and recognition-hint fields. Native acceptance checks their values, focus, actions, grapheme text selection, visible text ranges, scrolling text into view, and hide/reopen behavior. Scrolling text into view preserves selection and focus and holds across a resize; text replacements and reopening Settings retire prior ranges. Native selection is unavailable during active IME composition. Scrolling the Settings page and complete screen-reader navigation remain unfinished. On macOS and Linux, Settings publishes the same accessibility tree, but it stays published while Settings is hidden and no native acceptance checks it.

Corrections under Words replaces recurring recognition mistakes in dictation and Show narration. Enter what the engine hears and the spelling you want, then choose Add; Edit changes one in place. Matching is case-insensitive, uses whole words, and prefers the longest phrase; replacements do not trigger other rules. Timed narration retains the original word span. This changes recognized text, not the speech model, and does not provide live transcription. Up to 200 rules are stored locally in vocabulary, for example [{"heard": "speak easy", "written": "Speakeasy"}]. Each side allows up to six words and 64 characters.

Presets on the Dictation page keep named combinations of engine, model, language, recognition hints, phrase corrections, filler cleanup, thread count, and GPU preference. Save current settings as a preset names the current choices. Use applies a preset and keeps it; the matching preset shows In use. Its ⋯ menu offers Update with current settings and Delete. Up to 16 presets are stored locally in presets, with distinct names of up to 48 characters. An unavailable model can remain in a preset; using it reports what to fix and leaves dictation as it was.

The Windows/Mac tray's Preset menu and speakeasy preset "NAME" apply a preset for the current session while idle, without changing your settings; Settings marks it In use. That selection survives Pause but resets on restart or a dictation-settings change. Model choices reload the engine only when needed; text-only choices reuse it. An unavailable preset leaves the current configuration intact.

Preset-library, theme, reduced-motion, and Start at login changes keep a recording running; microphone, language, filler removal, recognition hints, phrase correction, delivery, and sound changes end it but keep the model loaded. Changing the Mac shortcut, Linux Shortcuts, or most Linux Insert text by choices restarts dictation, which reloads the model. Saving stays responsive and preserves edits made while the save is running. Changes made while dictation is paused are saved without resuming it, and pausing during a save keeps it paused; Quit finishes requested saves.

The theme colors Settings, the pill, and the Windows and Linux tray icon: Jet & Champagne, Emerald Lounge, Iris, or Midnight Chrome.

On Windows, Start at login opens Speakeasy in the tray when you sign in; it is off by default. While it is on, each launch registers the copy you run, so a moved or updated Speakeasy keeps starting; turn it off before you delete Speakeasy. If Windows' Startup apps page, in Settings or Task Manager, has turned Speakeasy off, Settings says so under the switch: turn it on there. Start at login belongs to the default settings file, which sign-in opens, so a launch with --config neither shows nor changes it.

Settings live in %APPDATA%\speakeasy\settings.json on Windows and ~/Library/Application Support/speakeasy/settings.json on Mac. The Windows and Mac packages include settings.example.json, the settings a first launch starts from; pass --config <path> to use another file. Saving writes only the settings you changed, so edits you make to the file by hand stay. When a settings file from another Speakeasy version cannot be read, Settings and the setup guide offer Start fresh…; General → Start over… does the same at any time. After you confirm, it deletes the downloaded engines, models, and updates and then the settings file, with its phrase corrections, hints, and presets, and downloads Parakeet again. Every Show stays. If something cannot be removed, the settings stay and Speakeasy says what to close or fix. On Windows and Mac, configured launches go straight to the tray or menu bar; Linux opens Settings at startup. Closing Settings hides it; Windows minimize also hides it. Reopening Speakeasy or choosing Settings… in the tray brings it back.

Tray

The tray icon shows whether Speakeasy is ready, recording, working (for example loading the model or transcribing), paused, or needs attention. The Mac menu bar icon is monochrome, so it marks recording with a badge instead of red. The menu pauses or resumes dictation, starts or finishes a recording, cancels, opens Settings, and quits; on Windows and Mac it also starts a Show of the screen or of an area and opens the Shows library. Pause dictation, or Pause in Settings, releases the shortcut and the model until you resume.

Text delivery

By default the text is pasted through the clipboard and stays there. Keep clipboard types the text as direct input instead, which some editors reject. Protected fields and elevated Windows apps may refuse either method, and no OS submission can confirm that an editor accepted the text.

Build and verify

mise install
mise run standards:check

The pinned toolchain and lockfiles make local checks reproducible. mise run standards applies safe formatters and autofixes, and mise tasks lists the focused checks.

Default tests drive the real session owner with mocked microphone, inference, and insertion, and a paused clock exercises gesture deadlines and the five-minute cap. AGENTS.md sets what they may touch. See the architecture change and test map, and verification for opt-in tests and their fixtures.

Packaging and native checks

• scripts/package-windows.ps1, bash scripts/package-macos.sh, and bash scripts/package-linux.sh package the app into artifacts/; --native-tar makes an unbundled Linux archive for the current machine. Each script generates the package's third-party notices with the cargo about that mise install provides. Packages carry no engine or model; setup downloads them on first launch. Windows packaging also requires Inno Setup 6 and emits a per-user installer beside the portable ZIP. Mac packaging emits a drag-to-Applications DMG and ZIP. For Windows publisher signing, provision a certificate and its private-key access in the build user's CurrentUser\My certificate store, set SPEAKEASY_WINDOWS_SIGN_CERT_SHA1 to its thumbprint and SPEAKEASY_WINDOWS_SIGN_TIMESTAMP to an HTTPS RFC 3161 timestamp endpoint. Packaging signs both executables before archiving and then signs the installer; it rejects a failed signature, wrong signer, or missing timestamp. With neither setting it builds unsigned local packages. Authenticode identifies the publisher; SmartScreen reputation is separate. The Mac bundle carries its microphone usage declaration and a local signature by default; grant its permissions as Get started describes. For distribution, set both SPEAKEASY_MAC_SIGN_IDENTITY to a Developer ID Application identity already in the keychain and SPEAKEASY_MAC_NOTARY_PROFILE to a stored notarytool keychain profile. Packaging then signs with hardened runtime and the microphone entitlement, submits to Apple, staples the accepted ticket, and checks Gatekeeper before emitting the ZIP and DMG. Incomplete settings or rejected notarization fail the build. CI remains locally signed until those credentials are configured; no credentials belong in the repository. Moving from a local signature to Developer ID can require granting microphone, Accessibility, and screen recording permissions again; check them after replacing the app.
• Verified Windows updates use an Ed25519 key independently of publisher signing. Commit only the 32-byte public key as hexadecimal in packaging/update-key.pub; store its PKCS#8 PEM private key as the repository's SPEAKEASY_UPDATE_PRIVATE_KEY Actions secret, with a maintainer-held backup. python3 scripts/sign_update.py artifacts/speakeasy-windows-x64-setup.exe <version> --private-key <local-key-file> binds the version, target, filename, size, and SHA-256 in update.json and signs its exact bytes in update.json.sig. Release publication checks that the secret matches the embedded key and fails before tagging if it is absent or wrong. Old builds cannot trust a replacement key: retain the current key or distribute a new trusted build manually. Never commit a private key.
• bash scripts/check-package.sh <package> unpacks a package and checks, with no display or model, that it prints its version and help, answers a mistyped option on stderr with status 2, and that show demo writes a bundle with its summary and contact sheet. It inspects the bundle, prints the embedded agent skill, and checks that a missing frame produces findings and a failure status. The release workflow runs it on the portable packages and Mac DMG before upload. scripts/check-installer.ps1 -Installer <setup.exe> tests both running executables, parent wait and timeout, staged-file retention, upgrade/relaunch, and uninstall on disposable GitHub Actions Windows runners. It uses owned demo windows without devices and preserves settings, model files, edited Shows, and other copies' sign-in entries. The Check workflow's optional installer input runs these checks with the current packaged build.
• On macOS, bash scripts/check-update-macos.sh builds the opt-in native-acceptance feature and opens owned demo windows. It holds an accepted Show write during external, nested, repeated, and app-owned quit requests, then checks rendering callbacks, configuration preservation, and instance release. It uses no microphone, capture, input injection, or clipboard. The Check workflow's mac_updates input runs this on a disposable Mac runner. Default builds and release packages omit the acceptance entry points.
• scripts/check-demo-windows.ps1 -Executable <speakeasy.exe> checks that the demo pill stays non-activating and passes clicks through, and that closing Shows keeps Settings open. It also checks Settings through Windows UI Automation with synthetic Unicode input: roles, selection, switches, invocation, focus, input limits, bounds, hide/minimize, and retired providers. Build the app test executable with cargo test --locked -p speakeasy --no-run, then pass its path to the same script with -StaticAccessibility to check nonactivating and normal reopen without animation or unrelated redraws, stale field edits and text ranges, and the provider after window destruction. It also checks that scrolling text into view keeps selection and focus, that retained ranges survive field resizing, and that a reveal requested before a resize is painted lands in the resized layout. scripts/check-tray-windows.ps1 -Executable <speakeasy.exe> checks minimize, close, relaunch, and configuration preservation with owned --demo-tray windows. mise run ps:syntax parses the Windows scripts on a native PowerShell host.
• On Linux, mise exec -- python scripts/check_demo_linux.py target/release/speakeasy opens a private Xvfb display, checks rendered Settings and Shows, and checks that the preview shows and then hides the pill. It needs Xvfb, x11-utils, and a Vulkan driver. bash scripts/check-rendering-linux.sh runs, in an Ubuntu 26.04 Docker container with stock Mesa, the opt-in native_pill_ tests of the pill's window hints, input shape, visibility, and reopening, the Show review acceptance, the native rendering example, and that demo check on a release binary it builds; --packages checks the AppImage and tar launchers that package-linux.sh builds instead. Linux implementation explains the Mesa requirement.
• cargo run --locked -p speakeasy --example check_native_rendering -- --native-gui opens an owned non-activating window, renders an embedded SVG with alternating path and pathless frames, resizes, and repeats show/hide. It runs on the process main thread for AppKit. Linux needs a private display, such as xvfb-run -a, and on a layer-shell Wayland desktop WAYLAND_DISPLAY unset, as for every Linux owned-window check below; Windows and Mac use their native desktop. It accesses no microphone, global hook, or clipboard.
• cargo test --locked -p speakeasy native_show_review_ -- --ignored --test-threads=1 on Windows, or with xvfb-run -a on Linux, checks synthetic Show navigation, damage, edited summaries, expiry, ZIP export, visual-copy requests through a fake, and image cleanup on close. Linux also checks the owned window's rendered frame pixels. It uses no microphone, global input, screen capture, or clipboard.
• The same command with native_phrase_editor_ checks Settings IME composition and save draining; with native_settings_picker_ it checks language and page navigation, focus restoration, permission refresh using fake observations, private practice cleanup, and the simulated onboarding journey, including Skip, Replay, and recognition before completion. Run each filter separately so each process owns one GPUI application.
• On macOS with FFmpeg installed, bash scripts/check-movie-macos.sh generates synthetic silent movies and checks native frame timestamps, pixels, cancellation, file ownership, and a seek near the five-minute limit. It accesses no microphone, screen, input, or clipboard. The Check workflow's optional movie input also encodes a synthetic color-and-motion clip on Windows and normalizes its fragment headers into the published format and checks the retained prefix through the Mac reader, including HD neutral midtones, without accessing live devices. movie_fixture_run reuses the synthetic Windows artifact from a specified run for a focused Mac check; it skips the normal native matrix.
• On macOS, set SPEAKEASY_MAC_MOVIE_DIRECTORY to a new artifact directory and run cargo test --locked -p speakeasy-platform native_mac_movie_encoding -- --ignored --test-threads=1. It checks native H.264 fragments, held and irregular timing, resized content, colors, bounded output, cancellation, and file closure using generated pixels. The optional movie workflow includes this check. On Windows, native_mac_movies_preserve_colors_and_timestamps reads those same fixtures from SPEAKEASY_MAC_MOVIE_DIRECTORY.
• cargo run --locked -p speakeasy-platform --example mac_capture -- --owned-screen explicitly opts into Mac screen capture on a host with one active display. Two owned processes show a changing synthetic window and an overlapping excluded window. It checks their pixels in memory, presentation timestamps, and stop/restart; it writes no pixels and accesses no microphone, clipboard, or input hooks. Set both movie=true and screen=true in the Check workflow to run it on the disposable Mac runner. Screen Recording permission is required.
• On Windows, set SPEAKEASY_MOVIE_PROBE_DIRECTORY to an empty artifact directory and run cargo test --locked -p speakeasy-platform encode_synthetic_movie_fragments --release -- --ignored --test-threads=1. It exercises the native movie adapter with generated pixels, checks motion and quiet-tail timing through the native reader, and forces storage failure. The windows::movie::tests::timing:: filter checks irregular capture timing, coalescing, quiet fragments before finalization, cancellation during catch-up, and the surviving prefix after a stall. The separate a_cancelled_active_movie_releases_its_file_without_a_new_frame filter checks cancellation and file release. These checks use generated pixels and access no microphone, screen, input, or clipboard.
• The Windows platform filter target_geometry_tracks_an_owned_window_without_sampling_input, with --ignored --test-threads=1, moves and hides an owned window, verifies current target bounds against a fixed area, and reports geometry lookup timings. It accesses no microphone, screen pixels, input, or clipboard.
• The Windows platform filter a_movie_survives_still_backpressure_and_closes_at_the_session_deadline, with the same opt-in arguments, captures only an owned, blacked-out scene into a temporary movie. It changes that scene after filling the still queue and checks later video submissions, the original deadline, and file release. It accesses no microphone, input, or clipboard.
• On any host, set SPEAKEASY_MOVIE_FIXTURES to the synthetic codec probe directory and SPEAKEASY_MOVIE_PREFIX_OUT to a new output directory, then run cargo test --locked -p speakeasy-show --test movie_native -- --ignored --nocapture. It validates native fragment timing and writes recovered prefixes for independent decoder checks. These fixtures contain generated pixels only.
• On Windows, set SPEAKEASY_MOVIE_READ_DIRECTORY to those recovered synthetic prefixes. Run cargo test --locked -p speakeasy-platform recovered_movie_seeks_ --release -- --ignored --test-threads=1 and cargo test --locked -p speakeasy native_video_export_ -- --ignored --test-threads=1. They check native seeks, pixel orientation, cancellation, file replacement, and command exports beyond the annotation journal without microphone, screen, input, or clipboard access.
• With the same Windows fixtures, run cargo test --locked -p speakeasy native_show_video_review_ -- --ignored --test-threads=1. It checks the owned review window's rapid seeks, scrubber, keyboard and narration navigation, exact copied evidence retrieval, and cleanup on close. It injects events into that window without installing hooks, recording the screen, or touching the clipboard.

Live microphone, editor, and screen acceptance is tracked under verification.

Versions

Speakeasy is a preview, versioned 0.MINOR.PATCH under SemVer as Cargo reads major version zero: MINOR marks breaking changes. The version reaches 1.0.0 only when the maintainer declares the public surface stable.

Until the official 1.0.0 release, only the latest Speakeasy version and its current formats, files, settings, and protocols are supported. Optimize for agentic development with one clear, idiomatic implementation of current behavior. Replace obsolete code, schemas, tests, and documentation; remove compatibility readers, migrations, aliases, transition shims, and old-version upgrade scaffolding. Unsupported formats produce an error. Breaking preview changes use a MINOR release under the rules below.

The public surface is what people, scripts, and coding agents rely on from one release to the next:

• the gestures: hold-to-talk, double-tap hands-free, cancelling, and a Show's S, W, A, and Shift;
• the command line: speakeasy options and speakeasy show commands;
• saved settings and what each one means;
• Show bundles: their files, the show.json format with its version, and their retention;
• the supported platforms, their requirements, and the release packages.

The look and sound of the app, its timings, messages, performance, and Rust crates are not part of it. Each release raises one number of the latest release, by its largest change since that tag:

• MINOR, as in 0.5.2 to 0.6.0, when the surface loses something or changes meaning: a gesture, option, or command is removed or does something else; a saved setting is no longer honored as written; a show.json reader must change, which also raises the format's version; or a platform or package is dropped or a requirement raised.
• PATCH, as in 0.5.2 to 0.5.3, for every other release: added gestures, options, settings, and bundle fields that existing readers can ignore, fixes, and performance.

Versions carry no pre-release or build suffix, and a released version and its tag never change.

Documentation

• Architecture: the change and test map, cross-module invariants, recognition, privacy, and verification.
• Interaction design: the brand, the pill, sounds, the tray and Settings, and interaction contracts.
• Linux implementation: desktop adapters, packaging, and the native acceptance Linux still needs.
• Performance: constraints, profiling methods, and native measurement limits.
• Remote dictation: routing a remote microphone to Speakeasy.

License

Speakeasy is free and open source under the MIT License. Josefin Sans is under the SIL Open Font License, the cue sounds are cut from hollandm's CC0 kalimba recordings on Freesound, speakeasy-show adapts MIT-licensed code credited in its notice, and the patched GPUI crates under vendor/ keep their Apache 2.0 license. Every package includes LICENSE, the font license, that notice, and THIRD-PARTY-NOTICES.txt, which packaging generates with cargo about from the crates built for that platform and the licenses packaging/about.toml accepts.