Problem
Windows already provides speech input, but the experience is not always predictable enough for focused writing. A dictation session can be hard to see, hard to control, and easy to interrupt accidentally. The user also has to trust what happens to their voice and the text produced from it.
I wanted a smaller, more transparent tool for everyday dictation. It needed to make the listening state obvious, insert text into the application already in focus, support simple spoken punctuation and line-break commands, and stop cleanly when the user was finished. It also needed to keep the privacy boundary clear: microphone access should be limited to active dictation, and recognition should run locally after the required model setup.
Approach
I treated the tool as a small interaction system rather than a single transcription function.
The first step was to define the core contract: the user starts dictation deliberately, the app shows whether it is listening, recognized text appears in the currently focused field, and control returns to the user when dictation stops or the context becomes unsafe.
From there, I separated the workflow into clear responsibilities. The audio and recognition layer handles local speech processing. The input layer inserts Unicode text and replaces provisional phrases with finalized recognition. The command parser handles phrases such as “new line,” “new paragraph,” “comma,” and “stop listening.” The interface communicates state through a compact widget, tray controls, listening cues, and a screen-edge glow.
Privacy and recovery shaped the implementation throughout. The app does not persist audio or transcripts. It checks that the original foreground window is still active before changing text, pauses live changes after unexpected keyboard or mouse input, and skips transcript review when the result could be unsafe. Versioned portable packages and per-user installation folders make it possible to install a new release alongside an existing one and roll back to an earlier version.
What I Built
I built a complete local dictation companion for Windows. Core pieces include:
– A small desktop widget that can be dragged, minimized, or hidden to the system tray.
– A configurable global shortcut, with the default set to Ctrl+Shift+Space.
– Local speech recognition through Foundry Local and WinML after an explicit first-use model download confirmation.
– Immediate insertion of interim speech results, followed by replacement with finalized wording when available.
– Spoken commands for stopping, new lines, new paragraphs, commas, periods, question marks, and exclamation marks.
– Listening and ending cues with selectable sounds, volume control, and an optional screen-edge glow.
– Silence auto-stop with configurable timeout options.
– Enter-to-stop behavior that still allows the physical Enter key to reach the focused application.
– A local transcript review option that can correct clear recognition, spelling, capitalization, and punctuation issues and remove obvious filler words.
– A details view for app, SDK, model, microphone, shortcut, and error status.
– Local settings and operational logs that exclude audio and transcript content.
– Versioned ZIP releases with SHA-256 sidecar files, portable installation, and a bounded rollback path.
– Smoke tests for the voice-command parser and a verification script covering build, tests, and release packaging.
The work goes beyond a speech-to-text demo. It includes interaction design, local AI integration, text-insertion safety, privacy boundaries, diagnostics, packaging, installation, and verification.
Outcome
Local Dictation Companion evolved into a focused writing tool that makes the state of dictation visible and keeps the main processing path on the user’s Windows device. The user can start dictation from the keyboard or widget, see when the microphone is active, speak naturally, use simple editing commands, and stop without leaving a hidden process running.
The strongest result is the combination of capability and control. Local speech recognition provides the core utility, but the surrounding safeguards make it usable: the app limits microphone access to active sessions, avoids changing text after the user’s context has shifted, preserves original text when review is uncertain, and exposes diagnostic state instead of hiding it.
The project also became a practical test of building a reliable local AI feature. The implementation required the same discipline as a larger product: define the boundaries, handle intermediate states, preserve user control, verify the risky paths, and package the result so another person can install and recover it.
Tools Used
Windows, .NET 10, WPF, C#, Foundry Local WinML, NAudio, Windows input APIs, local speech and text models, PowerShell, Visual Studio build tooling, smoke tests, versioned ZIP packaging, and SHA-256 verification.