Contents
What is Dimmy?
The name is pronounced like "Dimi" — short for dimmi, Italian for "tell me".
Dimmy is a cross-platform desktop app that turns your voice into text — instantly, in any application. It runs as a tiny overlay on your screen. Press a hotkey, speak, and your words are transcribed and pasted into whatever has focus: editors, browsers, chat apps, terminals, anywhere a cursor blinks.
Built with native UIs for every platform — no Electron, no WebView, no browser shell. A shared Rust core handles all the heavy lifting (audio capture, transcription, AI post-processing, history, key storage), while each platform gets its own native frontend: WinUI 3 on Windows, SwiftUI on macOS, GTK4 + libadwaita on Linux.
Learn more at dimmy.app.
Highlights
- Local offline transcription powered by whisper.cpp and Parakeet TDT v3. No API key, no internet, no data leaving your machine.
- Universal dictation into any application via clipboard paste — editors, browsers, chat, terminals.
- Meeting mode — long-form record with streaming WAV + chunked live transcript + LLM-generated structured recap (TLDR + decisions + actions + next steps + risks + …). Pause / resume mid-meeting; the paused window is excluded from the WAV and the timeline.
- File load — drop or pick a WAV / MP3 / MP4 to transcribe offline (whisper or Parakeet) or via cloud, with waveform preview and silence-aware chunking for files above provider limits.
- Native per platform — WinUI 3, SwiftUI, GTK4. Feels right at home, runs fast, uses little memory.
- Always-on-top pill overlay with live waveform visualization and per-state colour feedback.
- Realtime streaming dictation — text appears at the cursor while you speak, over a WebSocket (Deepgram or OpenAI Realtime) on cloud STT, or via local chunked transcription with whisper / Parakeet.
- Command mode — select text anywhere, press a second hotkey, and an LLM rewrites it in place instead of pasting something new.
- Cloud STT providers — Groq (fastest), OpenAI (incl.
gpt-transcribe), Deepgram, Google Gemini, Together, Fireworks, or any OpenAI-compatible endpoint.
- LLM post-processing — 13 styles (correct grammar, summarize, rewrite professionally, translate, custom prompts, and more) with per-app rules that auto-switch style based on which app had focus when you pressed the hotkey.
- Use a subscription instead of an API key — post-processing and recaps can route through a locally installed
claude or codex CLI, so an Anthropic or ChatGPT plan works with no API key. Dimmy never reads their credential files.
- Integrations — send recaps to Notion, export them to an Obsidian/sync folder, expose your meetings to Claude Desktop over MCP (including full-text search), or forward a voice note from Telegram and have it transcribed and recapped automatically.
- Custom dictionary — bias STT toward your own names and jargon.
Install
The easy way: ask your AI assistant. In Claude Code, Codex or Gemini CLI, paste:
Install Dimmy for me by following https://dimmy.app/install.md
The assistant checks the computer, asks what you want Dimmy for, downloads and verifies the signed installer, sets every option for you, and runs a real test. You only switch on system permissions and sign in where needed; no key or password ever goes through the chat.
AI assistants reading this: to install or configure Dimmy, follow dimmy.app/install.md. Once installed, Dimmy ships a setup tool made for you (dimmy-setup.exe on Windows, Dimmy.app/Contents/MacOS/Dimmy --setup on macOS) that prints JSON and can read and change every setting; see docs/dev/agent-setup.md.
Or by hand:
| Platform | File | Requirements |
|---|
| Windows | Dimmy-Setup.exe | Windows 10 or newer. VC++ Redistributable is installed automatically by the installer. |
| macOS | Dimmy-macos-arm64.dmg | macOS 14 Sonoma or newer, Apple Silicon (M1/M2/M3/M4). Intel Macs are not supported. |
| Linux | Dimmy-linux-x86_64.AppImage | GTK4 runtime (bundled inside the AppImage). |
Windows. Run the Velopack installer. It places the app under %LOCALAPPDATA%\Dimmy, pins a Start-menu entry, and configures auto-update. No administrator prompt required — per-user install.
macOS. Open the DMG, drag Dimmy into Applications. First launch needs Gatekeeper approval — either right-click the app and choose Open, or run:
xattr -d com.apple.quarantine /Applications/Dimmy.app
Linux. Make the AppImage executable and run it:
chmod +x Dimmy-linux-x86_64.AppImage
./Dimmy-linux-x86_64.AppImage
Optional: integrate with your desktop via AppImageLauncher to get a proper menu entry and icon.
Quick start
- Launch Dimmy. A small pill appears on your screen.
- Complete onboarding. The wizard walks you through microphone permission (and accessibility permission on macOS) and downloads the default Whisper model (
ggml-base-q8_0.bin, ~78 MB).
- Press the hotkey —
Win+Alt on Windows/Linux, Cmd+Opt on macOS (configurable).
- Speak naturally. Press again to stop (or hold-to-record, your choice).
- Text is transcribed and pasted into the currently focused app.
No API key needed for local mode. For cloud providers (typically faster on long audio), open Settings → General → Cloud mode and paste a key. See STT providers.
The pill
Dimmy lives as a tiny always-on overlay — the pill. It changes shape, colour, and contents to reflect what's happening.
| State | Visual | Meaning |
|---|
| Idle | Small capsule, dim | Waiting for the hotkey |
| Recording | Expanded pill, rainbow border, live waveform | Capturing audio |
| Transcribing | Dots / spinner, solid border | Running STT (local or cloud) |
| LLM processing | Style-coloured border + style icon | Post-processing with the selected LLM style |
| Done | Green checkmark, brief | Success — text was pasted |
| Error | Red border, tooltip | Something failed; hover for detail |
Right-click the pill (or the tray / menu-bar icon) to open Settings, which has tabs for:
- Home — status at a glance, quick toggles
- Voice input — STT mode (local / cloud), model, language, microphone, preprocessing
- Output — LLM style, tone, translation target, custom prompts, filler removal
- Providers & keys — one card per vendor; a key entered once covers STT, LLM and recap
- Pill overlay — position, waveform style, border scheme, idle opacity
- App rules — auto-switch LLM style based on which app had focus
- Shortcut — hotkey combo, toggle vs hold-to-record, command-mode and meeting hotkeys
- Recordings — searchable transcript archive, audio playback, retention
- Integrations — Notion, folder export, Claude Desktop (MCP), Telegram
- Privacy & data — telemetry toggles, AI transparency, privacy policy
- License — trial, activation, plan
- About — version, update check, links
How it works
graph TD
subgraph "Native UIs"
WIN["Windows · WinUI 3 · C#"]
MAC["macOS · SwiftUI"]
LIN["Linux · GTK4 · libadwaita"]
end
subgraph "Rust core (core/src/)"
FFI["ffi.rs<br/>147 C exports"]
AUDIO["audio.rs → preprocess.rs<br/>highpass · VAD · AGC"]
GATE["silero.rs<br/>speech gate for realtime chunks"]
LOCAL["local_stt.rs · parakeet.rs<br/>whisper.cpp / Parakeet TDT"]
CLOUD["transcribe.rs<br/>Cloud STT routing + chunking"]
STREAM["deepgram_stream.rs · openai_stream.rs<br/>chunked_stt.rs — realtime dictation"]
MEET["meeting.rs<br/>long-form record + live transcript"]
FILLER["filler.rs<br/>6-language cleanup"]
LLM["llm.rs<br/>13 styles · command mode · recap"]
LOCALLM["local_llm.rs<br/>llama.cpp (optional)"]
HIST["history.rs<br/>SQLite + FTS5"]
KEY["keystore.rs<br/>AES-256-GCM"]
INTEG["notion.rs · telegram.rs<br/>claude_desktop.rs (MCP)"]
end
subgraph "External"
MIC["OS audio<br/>(cpal)"]
WHISPER["Whisper / Parakeet models<br/>(HuggingFace)"]
PROVIDERS["Cloud STT + LLM<br/>Groq / OpenAI / Deepgram / Gemini / …"]
SUBS["claude · codex CLI<br/>(subscription instead of API key)"]
LLAMA["llama.cpp + Gemma 4 E2B<br/>(optional, local LLM)"]
end
WIN -->|P/Invoke| FFI
MAC -->|C FFI| FFI
LIN -->|Rust crate| FFI
FFI --> AUDIO
FFI --> MEET
AUDIO --> GATE
GATE -->|"speech in this window?"| STREAM
AUDIO -->|"stt_mode = local"| LOCAL
AUDIO -->|"stt_mode = cloud"| CLOUD
MEET --> GATE
STREAM -->|"live text at the cursor"| FFI
LOCAL --> FILLER
CLOUD --> FILLER
FILLER --> LLM
LLM -->|"llm_mode = local"| LOCALLM
LLM --> HIST
MEET -->|recap| LLM
LLM --> INTEG
HIST -->|auto-save| FFI
MIC --> AUDIO
WHISPER --> LOCAL
PROVIDERS --> CLOUD
SUBS --> LLM
LLAMA --> LOCALLM
KEY --> FFI
Shared core, native chrome. All business logic — audio capture, preprocessing (48 kHz highpass → VAD → AGC → NaN-safe clamp), local or cloud STT, realtime streaming, meetings and recaps, filler removal, optional LLM post-processing, SQLite history, AES-256 key storage — lives in the Rust core. Windows and macOS call it through a 147-function C FFI. Linux links the core as a direct Rust crate dependency.
Two different audio paths, and the difference matters. A finished recording goes through the batch pipeline (highpass → VAD → AGC), which trims silence and normalises level before one STT call. A realtime window instead passes a gate: Silero answers "is there speech in these 3 seconds?" and the window then reaches the model whole, pauses included. Trimming inside a realtime window turned out to be actively harmful — starved of context, whisper falls back on the sign-off phrases from its training data ("Grazie", "Thank you everyone"), so the trimming produced the very hallucination it was meant to prevent. Measured over 300 windows of real meetings, gating instead of trimming cut those from 62 to 19 with no words lost.
For depth: docs/ARCHITECTURE.md covers the layer map, directory tree, data flow, FFI surface, and decision log. docs/dev/modules.md is the per-module reference. docs/dev/audio-pipeline.md documents the DSP pipeline, VAD state machine, and the (nasty, previously-shipped) dagc NaN corruption bug we have to keep guarding against.
STT providers
Local mode is the default — whisper.cpp, no API key, no internet, no data leaves your device. Cloud providers are opt-in and can be faster on long audio.
The model list is not hardcoded in the UI: it is compiled in from
assets/model-catalog.json, so Windows, macOS and
Linux always offer exactly the same models and cannot drift apart.
| Provider | Type | Models | Free tier | Get a key |
|---|
| Groq (recommended) | STT + LLM | whisper-large-v3-turbo, gpt-oss-120b, llama-3.3-70b, qwen3-32b | Yes (rate-limited) | console.groq.com/keys |
| OpenAI | STT + LLM | gpt-transcribe, gpt-4o-transcribe, whisper-1, gpt-5.5, gpt-5.4-mini/nano | Pay as you go | platform.openai.com/api-keys |
| Deepgram | STT (+ realtime WS) | Nova-3, Nova-2 | $200 free credits | console.deepgram.com |
| Google Gemini | STT + LLM | gemini-3.5-flash, gemini-3.1-pro, gemini-2.5-flash/pro | Yes | aistudio.google.com/apikey |
| Anthropic | LLM only | Claude Opus 5.5, Fable 5.1, Sonnet 5, Haiku 5.5 | No | console.anthropic.com/keys |
| OpenRouter | LLM only | Llama 3.3 70B, DeepSeek R1 | Yes (free models) | openrouter.ai/keys |
| Together | STT + LLM | Parakeet TDT, whisper-large-v3, Llama 3.3 70B | — | api.together.xyz |
| Fireworks | LLM | Kimi K2 | — | fireworks.ai |
|
One key per provider covers STT, LLM and recap: the core falls back from the
LLM scope to the STT scope of the same vendor rather than asking twice.
Keys are encrypted on device with AES-256-GCM and a machine-specific KDF — no keyring prompt, no admin permission, no OS popups.
Claude Code subscription — no API key needed
If you already pay for a Claude Pro, Team, or Max plan, you can route Dimmy's LLM calls (style rewrite + meeting recap) through your subscription instead of an API key. Dimmy spawns Anthropic's official claude CLI as a subprocess — it never touches your token or login session, only the stdin/stdout of the binary.
Prerequisites
- Node.js 18+ — install from nodejs.org (LTS works).
npm is bundled with it.
- A browser — the
claude login flow opens one for the OAuth handshake.
- Default Windows / macOS / Linux shell — no WSL, no Git Bash needed.
Setup (any OS)
# 1. Install the CLI globally
npm install -g @anthropic-ai/claude-code
# 2. Verify it's on PATH (open a NEW terminal so PATH refreshes)
claude --version
# 3. Log in with your subscription
claude login # opens browser → sign in with your Pro / Team / Max account
# 4. Quick sanity check
echo "say pong" | claude --print
In Dimmy
Open Settings → Output (Mac) / Integrations (Win). Under LLM or Recap, switch the Provider to Claude Code (subscription). The status card goes green once Dimmy detects the logged-in CLI; pick a model (Opus 4.7 / Sonnet 5 etc.) and you're done. No API key needed.
Gotchas
- Restart the terminal after the npm install — Windows PATH only picks up
%APPDATA%\npm in fresh sessions.
- Corporate proxies / Zscaler / Netskope can break the OAuth callback. If
claude login hangs or shows a TLS error, that's the proxy — try from a personal network to confirm.
nvm users: install the CLI with the same Node version you'll actually use day-to-day; switching versions loses global packages.- Full implementation notes (auth flow, error modes, telemetry): docs/dev/claude-code-backend.md.
Benchmarks
Benchmarked on real audio files (LibriVox, public domain). Match% is word overlap versus the reference transcript. All inputs are 16 kHz mono WAV.
Short audio (5 – 90 s)
| Sample | Duration | Groq turbo | Groq v3 | OpenAI whisper-1 | OpenAI 4o-transcribe | OpenAI 4o-mini | Deepgram Nova-3 | Gemini Flash |
|---|
| JFK "Ask not" | 11 s | 815 ms 100% | 832 ms 100% | 1834 ms 100% | 1173 ms 100% | 1188 ms 100% | 2227 ms 100% | 1569 ms 100% |
| Micro Machines (fast) | 29 s | 838 ms 100% | 1088 ms 100% | 3545 ms 73% | 5161 ms 100% | 2211 ms 100% | 3304 ms 93% | 2689 ms 93% |
| Gettysburg Address | 10 s | 823 ms 100% | 716 ms 100% | 1875 ms 100% | 1563 ms 100% | 1245 ms 100% | 4008 ms 100% | 1669 ms 89% |
| Harvard (female, 8 kHz) | 33 s | 902 ms 100% | 943 ms 100% | 1849 ms 100% | 2349 ms 100% | 1781 ms 100% | 4390 ms 100% | 2087 ms 100% |
Medium audio (5 – 11 min)
| Sample | Duration | Groq turbo | Groq v3 | OpenAI whisper-1 | OpenAI 4o-mini | Deepgram Nova-3 | Gemini Flash |
|---|
| Pinocchio Ch.1 (EN) | 4:53 | 1.5 s 100% | 1.5 s 100% | 15.1 s 100% | 10.4 s 100% | 19.1 s 100% | 11.0 s 100% |
| Tale of Two Cities | 6:49 | 1.7 s 100% | 2.1 s 100% | 22.4 s 100% | 14.6 s 100% | 26.4 s 100% | 10.0 s 100% |
| Pride & Prejudice | 10:38 | 4.6 s 100% | 3.3 s 100% | 34.1 s 100% | 25.3 s 100% | 66.0 s 77% | 15.3 s 100% |
| Pinocchio Cap.1 (IT) | 5:35 | 1.7 s 100% | 2.1 s 100% | 16.5 s 100% | 14.1 s 100% | 40.5 s 100% | 8.3 s 100% |
| Divina Commedia (IT) | 42:00 | > 25 MB | > 25 MB | > 25 MB | > 25 MB | 249.2 s | > 20 MB |
Takeaways
- Groq is 10–20× faster than every other provider while matching or beating accuracy.
- Deepgram handles large files natively (2 GB limit) but is slower on short audio.
- Gemini Flash balances speed and quality well on medium-length audio.
- OpenAI whisper-1 is accurate but consistently the slowest.
- Files above 25 MB are auto-chunked for Groq/OpenAI. Dimmy's chunker searches for silence boundaries in the last 25 % of each chunk before force-splitting. See
docs/dev/audio-pipeline.md.
Benchmark date: 2026-03-13. Reproduce with ./tests/test_benchmark.sh quick.
LLM post-processing
Enable in Settings → Output to pipe transcriptions through an LLM. Pick any provider with a chat-completions endpoint (or check Use same key if your STT provider also serves chat).
| Style | Effect |
|---|
| Off | No LLM processing |
| Correct | Fix grammar, punctuation, obvious typos |
| Summarize | Condense to key points |
| Elaborate | Expand with detail |
| Comprehensible | Rewrite for clarity |
| Professional | Business / email tone |
| Prompt | Reshape as an LLM prompt |
| Gen-Z | Gen-Z slang rewrite |
| Boomer | Old-school formal rewrite |
| Emoji | Insert tasteful emoji |
| Acronyms | Replace phrases with abbreviations |
| Imbruttito | Milanese grumpy rewrite |
| Custom | Your own system prompt |
Scroll wheel on the pill cycles styles. Ctrl + scroll cycles the tone (neutral / friendly / formal / casual / enthusiastic).
Optional local LLM. Gemma 4 E2B Q4_K_M runs on a 4 GB VRAM GPU via llama.cpp. See docs/dev/local-llm-feasibility.md for the full study. Gated behind the local-llm Cargo feature and disabled by default (keeps install size small).
Build from source
Full build reference — every command, every platform, every feature flag — lives in docs/BUILD.md. The summary below is enough to get the Rust core compiling.
Common prerequisites: Rust (stable), Git, CMake (for whisper.cpp / llama.cpp). Platform-specific extras are listed in docs/BUILD.md.
git clone https://github.com/KonradDallaOrg/dimmy.git
cd dimmy/core
cargo fmt --check
cargo clippy --features local-stt,local-llm -- -D warnings
cargo test --lib --features local-stt,local-llm
If all three pass, your environment is ready. For native UI builds:
Extras: Visual Studio 2022+ with .NET Desktop + Windows App SDK workloads, .NET 8 SDK, Ninja, LLVM, Vulkan SDK.
cd core
$env:CMAKE_GENERATOR = "Ninja"
cargo build --release --lib --features local-stt-vulkan,local-llm-vulkan
cd ../platforms/windows/Dimmy.Windows
dotnet restore
dotnet build -c Release
cd ../Dimmy.Windows.Tests
dotnet test -c Release
Or use the one-shot script at the repo root: powershell -File build-windows.ps1.
Per-platform notes: platforms/windows/README.md. CI invariants (read before touching any workflow): docs/dev/windows-ci.md.
Extras: Xcode 15+ with Command Line Tools.
cd core
cargo build --release --lib --target aarch64-apple-darwin \
--features local-stt-metal,local-llm-metal
# Force static-link for Xcode
rm -f target/aarch64-apple-darwin/release/libdimmy_lib.dylib
cd ..
open platforms/macos/Dimmy.xcodeproj
# Cmd+B to build, Cmd+R to run, Cmd+U for tests
Per-platform notes: platforms/macos/README.md.
Extras (Ubuntu/Debian 24.04+):
sudo apt install libgtk-4-dev libadwaita-1-dev libasound2-dev libxdo-dev \
libdbus-1-dev pkg-config cmake
Fedora and Arch equivalents: see docs/BUILD.md.
cd platforms/linux
cargo build --release
./target/release/dimmy-linux
# Lint + test (matches CI)
cargo clippy -- -D warnings
cargo test
Per-platform notes: platforms/linux/README.md.
Testing & quality
| Suite | Count | Command |
|---|
| Rust core unit tests | ~411 #[test] | cargo test --lib --features local-stt,local-llm (from core/) |
| Rust integration tests | ~88 across 11 files (ffi_e2e, meeting_pause_resume, parakeet_long_file, preprocess_properties, abi_snapshot, v2_ffi, …) | cargo test --test <name> --features ... (see docs/dev/testing.md) |
| Windows C# tests | ~100 [Fact] / [Theory] | dotnet test (from platforms/windows/Dimmy.Windows.Tests/) |
| macOS XCTest suite | 69 funcs | Cmd+U in Xcode or xcodebuild test |
| Linux crate tests | Run via cargo | cargo test (from platforms/linux/) |
Negative Space Programming. Every function in the Rust core asserts its preconditions and postconditions. Assertions run in release builds — we want crashes on corruption, not silent propagation of NaN or zero-length buffers. Full rationale in docs/dev/development-practices.md.
Known bugs with root causes. Every non-trivial bug that shipped gets a named entry in docs/dev/known-bugs.md with symptom, root cause, failed fix attempts, and the regression test that now prevents it. Read it before touching audio preprocessing, macOS FFI, or Windows window transparency.
CI / CD
| Workflow | Trigger | Runner | What it does |
|---|
ci.yml | Push / PR to main or staging | ubuntu-22.04 + ubuntu-24.04 | cargo fmt --check, cargo clippy --features local-stt,local-llm -D warnings, cargo test --lib, Linux GTK4 crate clippy + test |
staging-auto-update.yml | Push to staging | windows-2025, macos-14, ubuntu-24.04 | Build all 3 native UIs in parallel, package installers (Velopack / DMG / AppImage), run test-install smoke check, publish staging-latest pre-release |
release.yml | Tag push matching v* | Same as staging | Same as staging, but publishes a real GitHub Release |
test-install.yml | workflow_call from staging/release, or manual | windows-latest (clean) | Install shipped Dimmy-Setup.exe, launch for 15 s, fail if crash.log contains CRASH or bundle integrity breaks |
Windows CI correctness is non-trivial and paid for across many iterations (v0.6.11 → v0.6.20 resolved the MSVC 14.44 miscompile, VC Redist bundling, and PowerShell exit-code propagation saga). Before editing any workflow, read the 10 invariants in docs/dev/windows-ci.md. Release process: docs/RELEASING.md.
Contributing
Contributions welcome. Start at:
AI-assisted development. The project's agent playbook is CLAUDE.md. It's committed so that any Claude Code (or similar) session starts with full context. If you're using a tool that doesn't auto-load CLAUDE.md, just point your agent at it — the TOC links to everything else.
Roadmap
Full backlog with MoSCoW prioritization: BACKLOG.md. Highlights:
- Shipped since this list was written — local LLM enhancement, streaming partial transcription (Deepgram and OpenAI Realtime, plus a local chunked path), live-captions overlay, meeting mode with recaps, MCP bridge, Notion and Telegram integrations.
- Should-Have — launch-at-login across OSes, accessibility (VoiceOver / screen reader), macOS polish.
- Could-Have — Plugin system for post-processing, multiple profiles, speaker diarization, WhisperKit fast-path on Apple Silicon, Flatpak distribution for Linux.
- Won't have — Full text editor, screen recording, mobile app, cloud sync, browser extension, Electron/WebView anything.
FAQ
In local mode (the default), no. Audio is captured, preprocessed, and transcribed entirely on your device. Nothing touches the network.
In cloud mode, audio is sent over HTTPS to the provider you chose (Groq, OpenAI, Deepgram, or Gemini). Each provider has its own data-retention policy — check their terms.
Dimmy also sends a small amount of anonymous opt-out telemetry to PostHog EU and Sentry EU (event names like transcription.completed, error categories, app version, OS — never the audio, never the text, never IP, never your API keys). Toggle it off in Settings → Privacy. Full list of what's collected: PRIVACY.md.
Yes — in the default local mode. After the first run downloads a Whisper model (~78 MB for base-q8_0), you can use Dimmy indefinitely with no internet. Update checks are the only optional network call, and they're easy to disable from Settings → About.
- Tiny (42 MB) — fastest, useful for commands and short phrases, not great on accents.
- Base (78 MB, default) — the right balance for dictation. Works on almost any laptop.
- Small (181 MB) — noticeably better accuracy, especially for non-English. Needs a bit more RAM.
- Medium (514 MB) — near-large quality at half the size. Use it if you have a GPU or ≥ 8 GB RAM.
All Whisper models support 99 languages. The Q8 quantized variants trade 2-3 % accuracy for roughly 2× speed — recommended for the default.
Groq has a free tier that covers casual dictation (a few thousand minutes per day, rate-limited). Paid tier is cheap.
OpenAI whisper-1 is about $0.006 per minute. Their GPT-4o-transcribe models are priced similarly.
Deepgram gives $200 of free credits at signup (several thousand hours).
Google Gemini has a generous free tier.
For most users, local mode is free forever and fast enough. Cloud is worth it if you need faster response on long audio (> 10 min) or the accuracy of Whisper Large turbo.
Three reasons. Performance: the pill stays snappy at 60 fps even on older hardware; a WebView-based pill stutters. Footprint: the Windows installer is ~40 MB, the macOS DMG ~25 MB, the Linux AppImage ~30 MB — an order of magnitude smaller than Electron equivalents. Feel: each platform gets the right typography, spacing, dark-mode behaviour, menu conventions. Users notice, even if they can't articulate why the app "feels right".
The shared Rust core makes this affordable — every platform gets the full feature set because there's only one place to implement them.
Dimmy's VAD (voice-activity detector) has a 3-second grace period after you stop speaking before it emits the "silence" signal. If you pause longer than 3 seconds, the recording ends and transcription starts. You can switch to hold-to-record mode in Settings → Shortcut to keep recording until you release the hotkey.
For the curious: the VAD state machine and the (once-shipped, now-fixed) dagc NaN bug that this logic has to dance around are documented in docs/dev/audio-pipeline.md and docs/dev/known-bugs.md AUDIO-001.
We don't yet have a Developer ID (it requires an Apple Developer Program membership — on the roadmap). First launch, right-click the app and choose Open, or remove the quarantine attribute:
xattr -d com.apple.quarantine /Applications/Dimmy.app
Subsequent launches work normally.
Acknowledgements
Dimmy stands on the shoulders of:
License
AGPL-3.0 — free to use, modify, and redistribute. If you offer a modified version as a service, your code must remain open source under the same license.
Support
If Dimmy saves you time and you want to support continued development:
Bug reports and feature requests: GitHub issues. Security disclosures: email [email protected].
