Amical: local-first AI dictation built on Whisper, Ollama and Electron

The problem is not transcription, it is where the text lands

Speech-to-text has been commoditised. Whisper runs on a laptop, and a dozen services will turn audio into words for a few cents an hour. What remains annoying is the last mile: getting the recognised text into the right field, in the right shape, without switching windows. Amical's answer is app-context detection. The README states the app detects the active application and formats your speech accordingly, and gives four examples: drafting an email, chatting on Discord, writing prompts in an IDE, or messaging friends. That is a formatting-policy problem, and it is the only feature in the list that a generic transcription tool cannot copy by swapping in a better model. The audience follows from that. This is for people who already dictate and are tired of editing the output afterwards, not for people who have never used dictation. The repository is TypeScript, Electron and Next.js, with Whisper for speech-to-text and Ollama for the language-model side, and it is MIT licensed.

Two local models, one native addon, and a single-instance Electron shell

The architecture visible in the README is a desktop Electron app with a native component. Whisper arrives as a git submodule, and the repository applies its own patches inside the whisper.cpp submodule during install; the README notes that the submodule showing as modified in git status afterwards is expected. Speech-to-text therefore runs through a compiled native addon rather than a JavaScript reimplementation. The language-model stage is Ollama, which the tech stack lists alongside Whisper. A separate Node.js binary is downloaded for the local Whisper worker via a dedicated pnpm filter, so the worker does not simply reuse whatever Node is on your PATH. The desktop app supports macOS and Windows. The README is explicit that Linux is not supported because the app does not yet have a Linux native helper, which tells you the native layer is doing platform-specific work rather than being a thin wrapper. On the data-flow side, the README says no .env file is required for local transcription, and that the first-run onboarding downloads a local model and requests microphone and OS permissions. Cloud, authentication and telemetry integrations exist but sit behind apps/desktop/.env, which is optional for local use.

Getting a development build running takes four commands and a toolchain

The README's local development path is short but the prerequisites are not. You need Node.js 24.x, pnpm 10.15.0 as pinned in package.json, and CMake 3.20 or later. On macOS you need Xcode or the Command Line Tools with Swift 5.9 or later, and local Whisper transcription requires macOS 15 or later. On Windows you need Visual Studio 2022 Build Tools with the Desktop development with C++ workload, the .NET 8 SDK, and Git Bash is recommended because some development scripts use POSIX utilities. The clone must include submodules: git clone --recurse-submodules https://github.com/amicalhq/amical.git, or git submodule update --init --recursive afterwards. Then corepack enable, pnpm install --frozen-lockfile, and pnpm --filter @amical/desktop download-node. The install step compiles the native Whisper addon and can take a few minutes. To run it, quit any installed copy of Amical first, because Electron allows only one instance at a time, then pnpm turbo run dev --filter=@amical/desktop. The README warns that quitting the terminal command alone may leave the Electron app running; you should quit from the tray menu and then press Ctrl+C. Checks before a pull request are pnpm type:check and pnpm test. For non-developers, brew install --cask amical on macOS is the whole story.

The feature list is a roadmap, and half of it is not shipped

The README marks each feature with a status symbol, and reading those symbols is the fastest way to avoid disappointment. Done: fast dictation with AI-enhanced accuracy, context-aware speech-to-text based on the active app, extensibility via hotkeys, voice macros and custom workflows, offline operation with one-click local model setup, and the floating widget with custom hotkeys. In progress: smart voice notes turning into summaries, tasks and structured notes. Planned, meaning not available: MCP integration for voice commands that control your apps, and real-time meeting transcription using microphone plus system audio. Two of the four items in the marketing topics list, meeting-notes and mcp, describe features that the project's own README places in the future. If you are evaluating Amical as a meeting-notes tool, the honest reading is that you are evaluating an intention, not a product. The other constraint is the single-instance rule. Electron permits one Amical at a time, so a development build and an installed release cannot coexist, which matters if you want to keep a working copy while testing changes.

Where the local-first design costs you

Running everything on the machine removes the per-minute cost and the privacy question, and it replaces them with a hardware question. The README does not publish model sizes, memory requirements or latency figures, so the only way to know whether local Whisper is fast enough on your machine is to run the onboarding and dictate for a while. That is a real gap in the documentation, and it is the first thing I would want answered before recommending this to a team. There is also an operating-system floor: macOS 15 or later for local Whisper transcription. Anyone on macOS 14 or earlier is excluded from the core feature regardless of how capable their hardware is. The build toolchain is another cost. CMake, Swift 5.9, the Visual Studio C++ workload and the .NET 8 SDK are not unusual for a native desktop project, but they are a long way from npm install, and the native addon compile happens on every fresh install. Finally, the cloud, authentication and telemetry paths exist in the codebase and are configured through apps/desktop/.env, which means the privacy story depends on which build you run and how it is configured, not on the project being incapable of network calls.

How this differs from cloud dictation and from raw Whisper

The obvious alternative is a hosted dictation service, where you press a hotkey, audio goes to a server, and text comes back. Those services typically handle model hosting, updates and latency for you, and they work on any machine with a browser. The difference in approach is where the audio goes and who pays for inference. Amical moves both to your hardware: Whisper runs locally through a compiled addon, and the language-model stage runs through Ollama. You trade a subscription and a network round trip for a build toolchain and a model download. The second alternative is running Whisper yourself, either the whisper.cpp command line or a Python script, and wiring it to a hotkey. That gets you the same transcription quality without the Electron shell, and it is a reasonable choice if you only ever dictate into one application. What it does not give you is the active-app detection that changes formatting per target, or the floating widget. Amical's value sits in that layer, and the README's own framing, context-aware dictation that adapts to what you're doing, is the claim worth testing against your own workflow.

Maintenance, releases and what the MIT licence actually covers

The release cadence visible in the material is brisk and pre-1.0 in spirit: the most recent releases are v1.12.0-beta.5, v1.12.0-beta.3 and v1.12.0-beta.2, all published within about two weeks of each other, and the repository's last push is dated the same day as the newest beta. Betas at that frequency mean you should expect to reinstall or rebuild fairly often if you track the latest tag, and it means the stable channel is the Homebrew cask rather than the release page. Upgrade cost for a developer build is dominated by the native addon: any change to the Whisper submodule or its patches triggers a recompile, and the submodule is expected to look modified after install, so a clean git status is not a signal that something is wrong. The project is MIT licensed, which is permissive and imposes no source-disclosure obligation on your own code. That covers the repository's own code. It does not automatically cover the Whisper submodule, the models you download during onboarding, or Ollama, each of which carries its own licence, and model licences in particular vary. I am not a lawyer and this is not legal advice; if you plan to ship Amical inside a commercial product, check the licence of every model and dependency you actually bundle.

Editorial conclusion

Adopt Amical if you dictate into several different applications on macOS 15 or later, or on Windows with the C++ build tools installed, and you want the transcription to stay on the machine. Do not adopt it if you are on Linux, since the README states the app has no Linux native helper, or if you need meeting transcription today, because the feature list marks real-time meeting capture as planned rather than done. Before committing, verify two things yourself: that the first-run onboarding downloads a model successfully on your hardware, and that the active-app formatting behaves the way you expect in the two or three applications you dictate into most.

Official sources

1. amicalhq/amical on GitHub
2. License: MIT
3. Project website
4. README
5. Releases