Jot: hold fn, speak, and Gemini types into whatever app has your cursor

What Jot actually solves, and for whom

Most dictation tools put a transcript somewhere: a window, a file, a notes app. You then copy it into the place you were actually working. Jot removes that step. You hold fn, speak, release, and the cleaned-up text lands at the cursor in the app you already had open. The README describes it as "smart dictation for macOS that puts polished text wherever your cursor is."

The cleanup is the part that separates it from macOS built-in dictation. Say "let's meet at 1pm, actually, no, make it 2pm" and Jot writes "Let's meet at 2pm." The README calls this following a change of mind and makes it the first thing onboarding asks you to try. Filler words go away. Punctuation is added. Names you put in the Dictionary ride along with the audio so the model hears "Kubernetes" instead of guessing at syllables.

The audience is narrow on purpose. You need macOS 14 or later, a Gemini API key, and a willingness to grant Accessibility permission to an app that types into other apps. If any of those three is a problem, Jot is not your tool. It is a demo, and the README says so twice: it is built on Gemini 3.5 Transcribe and is "not an officially supported Google product."

The capture-to-cursor pipeline, step by step

The README includes a diagram of the data flow, and it is worth reading literally:

fn down ─▶ capture (CAF on disk from t=0) ─▶ fn up ─▶ FLAC ─▶ Gemini transcribe
                                                                    │
   cursor ◀─ insert (AX → paste → clipboard) ◀─ [validate ◀─ tone pass] ─┘
                                              (optional, off by default)
                                                    │
                                              History (SQLite)

Three decisions in that path matter more than the rest. First, audio hits disk as CAF from the first millisecond, so a crash, a kill -9, or a dead battery does not lose the recording; it is recovered on the next launch. Second, the capture graph is pre-warmed while idle, so a key press only pays engine.start(), which the README puts at 20-40ms instead of 75-150ms. Preparing is not recording: no audio flows and the mic indicator stays dark until you hold the key. Third, the mic drains one buffer past the stop, because the audio tap delivers roughly 100ms chunks and tearing down immediately threw away the tail of your last word.

Insertion is a ladder rather than a single method: Accessibility API first, then a guarded paste that restores your clipboard, then a chip that says copied, press Command-V. The README states it never blind-pastes into an app that stole focus mid-flight. The optional tone pass sits behind a validation gate that catches the failure where the model answers your audio instead of transcribing it, and falls back to the raw transcript when that happens.

Installing Jot and getting your first dictation

There is no package manager installation. The README points to Releases: download the latest Jot-x.y.z.dmg, drag Jot into Applications, and launch it from there. The warning attached to that step is specific. Apps run from a mounted disk image are sandboxed by macOS and the permissions you grant will not stick, so dragging first is not optional.

Setup walks you through four steps: paste a Gemini API key from Google AI Studio, allow the microphone, allow Accessibility, and hold fn. The key is stored in the macOS Keychain. The README states that setup tells you up front if your key lacks access to gemini-3.5-transcribe, rather than failing on your first dictation.

The README gives the three gestures in a table: hold fn records while held and the text lands at your cursor on release; fn plus a tap of Space goes hands-free and keeps recording after you let go, with a tap of fn to finish; Esc cancels, and anything over 10 seconds is still kept in History. If fn is already spoken for on your keyboard, the README says the key is rebindable in Settings, General.

For development work the project is xcodegen-based and the .xcodeproj is generated rather than checked in. The README gives these commands:

brew install xcodegen
./scripts/build.sh          # xcodegen generate + xcodebuild
./scripts/test.sh           # swift test on JotCore
open Jot.xcodeproj          # or work in Xcode

Debug builds sign ad-hoc, so a clean clone needs no Apple account, certificate, or team membership. Only release builds via scripts/release.sh need a real Developer ID. The internal surfaces are reachable headlessly through the jot:// URL scheme, which the README lists as jot://settings/about, jot://history, jot://dictionary, and others.

What Jot does not do, and where the design bites

Jot is a client for one model. The README names gemini-3.5-transcribe as the specialist transcription model it runs on, and there is no fallback to a local engine or a second provider. No key access means no dictation. Offline, dictations queue and land when you reconnect, so the app is not useless without a network, but it is also not doing anything until the connection returns.

Cost sits with Google, not with Jot. The README says you pay for what you dictate at Gemini API pricing, that a free tier exists, and that a typical dictation is a few seconds of audio. That is a recurring variable cost per use, which is a different budget shape from a one-time purchase. It also means an API outage or a rate limit is a Jot outage.

Accessibility permission is the hard requirement people underestimate. macOS requires it for any app that types into another app, and the README notes that granting it from a mounted disk image will not stick. If your organization blocks Accessibility grants, Jot cannot insert text, and the clipboard fallback chip is the only remaining path.

The project is also a demo with a single author. The README credits Ammaar Reshi and repeats that it is not an officially supported Google product. That is not a stability claim in either direction, but it does mean support expectations should be set accordingly.

Jot against macOS built-in dictation and Whisper-based tools

The obvious alternative is macOS dictation, which ships with the system and needs no API key. The difference is where the text goes and what shape it arrives in. System dictation typically streams into the focused text field as you speak, with limited cleanup. Jot records first, sends the audio to Gemini, and inserts the result after the fact, which is what allows the change-of-mind rewrite and the filler removal. Jot also keeps a History window backed by SQLite, so a failed insertion is retryable rather than gone.

Whisper-based dictation apps are the other comparison. Most run the model locally, which means no per-use cost and no network dependency, at the price of a large model download and local compute. Jot takes the opposite trade: a small app, a hosted model, your key, and a per-dictation bill. The README leans into this with the phrase "private by architecture," meaning audio goes from your Mac straight to the Gemini API with your key and no middleman server, no account, and no analytics. That is a real architectural difference from a service that proxies your audio, but it is not the same privacy property as local transcription, where the audio never leaves the machine. Pick according to which of those two you actually need.

The Dictionary is the feature that is hardest to replicate elsewhere. Sending names and product terms along with the audio so the model hears them is a different approach from post-hoc find-and-replace, and the README is explicit that it corrects at the source rather than patching afterwards.

Maintenance, upgrades, and the Apache-2.0 licence

The last push to the default branch was on 2026-08-27, and the most recent tagged release is v0.4.0, Jot 0.4.0, dated the same day. v0.2.0 landed two days earlier, on 2026-08-25. The repository is not archived. That is the whole of what the available facts say about its cadence, and it is worth noting that the release numbering jumped from 0.2.0 to 0.4.0 in a two-day window, so the version scheme is not a reliable signal of maturity.

Upgrade cost is low by construction. Distribution is a DMG you replace in Applications, and the .xcodeproj is generated rather than checked in, so a source build is a fresh xcodegen run plus xcodebuild. There is no database migration story in the README beyond the GRDB index in HistoryStore; the History window is described as proving nothing was ever lost, and recovery happens on next launch.

Jot is Apache-2.0 licensed, and the repository carries a THIRD_PARTY_NOTICES.md alongside LICENSE. Apache-2.0 permits commercial use and modification with attribution and notice requirements. The part worth checking yourself is the interaction with Google's API terms: the licence covers Jot's code, not your use of the Gemini API, which is governed separately by the pricing and terms you accept when you create a key. This is not legal advice; read both documents if you plan to use Jot in a commercial setting.

Editorial conclusion

Jot is for macOS 14 users with a Gemini API key who want speech turned into polished text at the cursor without an account or a middleman server. Skip it if you need a notarized, officially supported Google product, if you are on a macOS version below 14, or if you cannot grant Accessibility. Before adopting it, verify three things: that your Gemini key has access to gemini-3.5-transcribe, that the Accessibility and microphone permissions stuck after you launched from /Applications, and that History recovers a recording after you kill the app mid-dictation.

Frequently asked questions

Official sources

1. google-gemini/jot-gemini-transcribe-macOS on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases