v0.0.5

Grain v0.0.5

This update improves Grain Space editing and keeps extension visuals under Grain's control.

• Aligned note title and body layout and refined Markdown editing.
• Added manual note ordering within folders, including drag-and-drop rearrangement.
• Prevented the Agent from duplicating a note's title as a body heading.
• Removed extension-provided visual customization in favor of Grain-owned presentation.
• Hid the Extensions sidebar entry in production builds.
• Changed the onboarding Standard default to Parakeet TDT 0.6B v2.
• Marked reviewed Parakeet V2 and V3 models as supporting Flow in the Standard model list.

v0.0.4

Grain v0.0.4

A focused release improving everyday navigation, extensions, prompting, and the reliability of Parakeet TDT Flow.

Interface and extensions

• Refined sidebar and content positioning, and reorganized the sidebar for clearer navigation.
• Reworked the Extension Store so extension details open as a full page with more room to understand each extension.
• Changed Studio Extend and .next extension experiences to open in focused pop-ups instead of rendering inside the page.
• Refined extension styling and presentation across the app.
• Added host-owned authentication for extensions.
• Standardized extension icons at the API boundary for consistent presentation.
• Restored settings that had become hidden during the UI migration.

Flow and dictation

• Rebuilt Rolling Window Flow around the reviewed Parakeet TDT v2 and v3 models for faster, accurate streaming behavior.
• Added model-aware Flow availability across settings, shortcuts, live preview, and daily dictation paths.
• Re-audited Flow and fixed three memory-lifecycle issues, along with additional stability and cleanup improvements.
• Re-audited dictation prompt priority, fixing ordering bugs and reducing unnecessary work.
• Hardened prompt extensions with stricter security boundaries and reliability fixes.
• Removed cursor-aware and unique-word Prompt Priority forms from production surfaces.

Fixes and maintenance

• Fixed multiple AI history tracking and consistency issues.
• Fixed global Escape-key ownership when Agent and dictation are enabled together.
• Improved and fixed the upstream maintenance workflow.

v0.0.3

Grain v0.0.3

A refinement-focused release across Agent, dictation, streaming UI, updates, and reliability.

What's new

• Added image support to Agent.
• Added Gemini support to the LLM Router and post-processing pipeline.
• Rebuilt the Agent UI and overlay with cleaner layouts, transitions, and animations.
• Added production Parakeet TDT Flow, bringing batch-quality punctuation to sub-second streaming on supported models.
• Added a dedicated processing state to the streaming pill.
• Improved expanded pill interactions, including working cancel controls, Prompt Record, and Prompt Switching.
• Reworked dictation prompt priority with a new algorithmic resolution system.
• Added extension support for extending or overriding dictation prompts.
• Replaced the three default dictation prompts with one refined default prompt.
• Further refined cursor-aware dictation.

Fixes & reliability

• Fixed repeated transcription when dictating inside Agent.
• Fixed updater launch and restart behavior.
• Improved how available updates are surfaced in the UI.
• Fixed waveform rendering with virtual audio devices such as VB-Audio Cable.
• Reduced false Lost Text warnings when text was inserted successfully.

v0.0.2

Grain v0.0.2 — Context, polish & reliability

Grain v0.0.2 focuses on reliability, context awareness, and a more polished dictation experience.

What's new

Redesigned pill

Grain now ships with a new default pill design featuring a cleaner layout, smoother waveform, and improved state feedback.

The previous pill design remains available in Settings.

Context Awareness in the pill

The pill can now display the active application or supported website, including app icons and website favicons.

Context can also update while dictating, allowing Grain to adapt when you switch between applications or supported websites.

Lost Text recovery

If Grain finishes a transcription without an active text field, the result is automatically copied to the clipboard and surfaced through a notification.

Simplified capture modes

The three capture modes have been reorganized and presented more clearly, making it easier to understand and choose the right mode.

Improved onboarding

Onboarding has been rebuilt to properly introduce dictation and guide new users through all three capture modes.

Context Awareness

Context Awareness received a major update.

• Added built-in categories for Work, Email, Technical, Casual, and AI Chat
• Added editable category prompts
• Added custom categories for specific applications and websites
• Added support for assigning one or multiple applications/websites to a custom category
• Custom categories override Grain's built-in mappings
• Added live context switching during dictation

UI & workflow improvements

• Quick Search is now fully functional
• Added model status for selected model, load state, and local/cloud mode
• Redesigned Dictionary UI
• Redesigned Snippets UI
• Redesigned Context Awareness UI
• Improved Prompt Record interaction with a dedicated hover action
• Push-to-talk is now disabled by default
• General UI and interaction refinements throughout the application

Flow improvements

Flow received a reliability pass covering:

• Error handling
• Memory management
• Rolling-window stability
• General performance and edge-case handling

Fixes

• Fixed toggle behavior
• Improved transcription failure handling
• Improved resource cleanup and memory behavior
• General stability fixes

Maintenance

• Continued integration of upstream Handy changes
• Internal cleanup and reliability improvements

---

Thanks for using Grain.

Grain 0.0.1

Grain 0.0.1 — First Release

Release date: 2026-08-04
Status: First public release

This is the first real release of Grain. Any earlier builds were internal
pre-releases and are being removed — there is no supported release before this
one. 0.0.1 is the baseline the in-app updater and every future release build
on.

Grain is a local, low-overhead, cross-platform speech-to-text application and a
friendly fork of Handy. It keeps Handy's
battle-tested transcription core verbatim and adds a decoupled, native-Rust
front end, multiple dictation modes, AI post-processing, a notes/second-brain
layer, and an extension platform — while staying current with upstream.

---

Highlights

• Native Rust UI, decoupled from the backend. The window can be fully torn
  down while capture keeps working. Target all-in footprint is ~70 MB (vs
  ~210 MB for a comparable WebView stack). Every feature that is off consumes
  zero resources — no listeners, no windows, no background runtime.
• Three capture modes — Standard, Flow, and Streaming — each
  with its own shortcut, so you switch instantly instead of changing a model in
  settings.
• OpenAI-compatible STT and LLM endpoints, with smart routing across
  multiple keys/providers.
• AI post-processing that can be decided mid-speech, plus mid-speech prompt
  switching, "prompt record," and a "scrap that" voice cancel.
• Notes (Grain Space) — capture by voice or text, organize into
  collections, and ask questions across everything, on-device.
• Agent, Context Awareness, and Snippets as opt-in built-ins.
• In-app updates from a signed GitHub release feed.

---

Capture & transcription

Three dictation modes, each on its own configurable shortcut:

Mode	Speed	Accuracy	Live preview
Standard (batch)	Slower	Highest	No
Flow (rolling window)	Sub-second	High	Optional
Streaming (real-time ASR)	Instant	Lower	Yes

• Rolling-window transcription (Flow): a 10-minute dictation that would take
  minutes in batch finalizes in under a second, with no loss of model
  accuracy. Optional live preview shows words as you speak. With AI
  post-processing, a tiny invisible prompt repairs rolling-window punctuation
  artifacts — speed and clean output at once.
• Two models selectable at once (one streaming, one shared by Standard and
  Flow); only one is resident in memory, and switching shortcuts swaps it
  immediately.
• Local or cloud: point the STT endpoint at any OpenAI-compatible source
  (self-hosted or a cloud provider) to drop local resource use even further.

AI post-processing & prompts

• Flexible AI trigger: start dictating with any mode and still choose to end
  through AI post-processing — the decision no longer has to be made before you
  speak.
• Mid-speech prompt switching: jump from a general prompt to a coding/email/
  workflow prompt without stopping.
• Prompt record: mid-recording, dictate an instruction ("turn this into an
  email") and Grain runs the transcript through the LLM with your spoken prompt.
• "Scrap that": say it mid-dictation to discard everything before it and
  keep going, no restart.
• Full history: both the raw transcript and the AI-processed text are kept.

Notes — Grain Space

A local, second-brain layer that appears when needed and stays out of the way.

• Capture by voice or text: quick-grab selected text, structured voice notes
  (title, TLDR, extracted reminders/checklists), and appending into an open
  note.
• Organize: Markdown notes, collections (folders) with drag-and-drop
  filing, pinning, reminders, and a calendar/upcoming view. Filing a note into a
  collection moves it out of Recent; dragging it back out returns it; collections
  can be deleted from a right-click menu (notes are preserved, never destroyed).
• Recall: fast exact search plus optional semantic search; ask questions in
  natural language and get answers cited from your own notes.
• Obsidian vaults: use Grain's native store or a Grain/ folder inside an
  Obsidian vault (ordinary Markdown + YAML). No separate sync service and no
  always-on watcher — Grain reconciles only when a surface needs fresh data.

Agent

Select text (or nothing), trigger the agent, and give an instruction by voice or
typing. Results appear in a compact bottom-corner window: paste with Enter,
dismiss with Escape, retry, or expand into a side-panel chat. A Quick Agent
variant pastes straight at the cursor with no window. The reply panel's WebView
is loaded behind your instruction and destroyed on dismiss — nothing persists.

Context Awareness

Adapts output to what you're doing: app/website-aware tone and terminology,
unique-word biasing from the active field, full-field context, and
per-app/per-URL instructions. Ships off by default — it observes nothing
until you enable it.

Snippets & dictionary

• Snippets: speak a keyword to paste boilerplate — links, addresses, text.
  Snippet actions can open apps, files, or sites (a spoken keyword can launch
  a whole workflow).
• Dictionary: add words that keep being mistranscribed so they're always
  correct going forward. Auto-dictionary (learning corrections after paste)
  is implemented but off by default, pending a decision on its short-lived
  post-paste listener.

Extensions platform

Optional workflow features run on a Grain-owned extension contract: Grain owns
the secure lifecycle, permissions, settings, shortcuts, and surfaces; a feature
owns only its behavior. Snippets, Context Awareness, Agent, and Grain Space
follow this model. Built-in extensions ship disabled by default on new
installs — a disabled extension registers no listeners, windows, or runtime.

Architecture & performance

• Decoupled front end / backend: frontend→backend is Tauri commands,
  backend→frontend is events; the UI is fully destroyable.
• Destroy if not in use: components are torn down when idle; models load only
  when used and unload when not.
• No WebView pre-allocation: a small first-launch delay (sub-second on most
  machines) in exchange for a much lower idle footprint.

Updates

In-app update checks against a signed GitHub release feed, pinned to the
0.0.1 line. (Handy's original auto-updater endpoint is intentionally removed;
Grain ships its own.)

Built on Handy

Grain keeps Handy's transcription core byte-for-byte in an isolated tree and
merges upstream continuously. As of this release, Grain is level with upstream
Handy (0 commits behind), including the latest microphone-stream recovery and
reliable-paste fixes. Inherited standard features: batch transcription,
real-time ASR, manual dictionary, instant model load/unload, GPU offloading, and
multi-language support.

---

Defaults & opt-in

Grain is opt-in by design. On a new install, Agent, Context Awareness, Snippets,
Grain Space, and Auto-dictionary are off and cost nothing until enabled.

Platform, install & build

• Primary platform: Windows 10/11 (x64). The stack is Tauri-based and
  cross-platform; Windows is the validated target for this release.
• Requirements: a WebView2 runtime (Windows) for the Agent/Notes surfaces; a
  transcription model is downloaded on first run.

Build from source (Windows):

bun install
bun scripts/run-tauri.ts build

Note : $env:CARGO_TARGET_DIR = "C:\gtc" # short target dir — avoids the whisper.cpp MAX_PATH build failure

run-tauri.ts detects the short target dir and disables the
transcribe-cpp-sys build junction automatically. The installer/bundle is
written under the Tauri release/bundle output. Do not run the build against a
target dir that a running Grain instance is using.

Known limitations

• Occasional punctuation/capitalization slips are inherent to Flow
  (rolling-window) mode; use Standard for short recordings that need perfect
  punctuation without AI, or enable AI post-processing.
• Streaming trades accuracy for zero latency.
• Auto-dictionary is disabled pending evaluation of its post-paste listener.
• Image-based context is not included in this release.