---

Select text in any application, press a global shortcut, and a small floating popup streams an AI-proofread version. Press Enter to replace the original text, ⌘/Ctrl+C to copy, or Esc to cancel. shakespAIre lives in your menu bar (system tray on Windows and Linux), so it is always one shortcut away and never in your way.

Contents

Demo · Why · Features · How it works · Download · Usage · Configuration · Updates · Platform notes · Troubleshooting · Privacy & security · Build from source · Project layout · Releasing · Contributing

Demo

Why shakespAIre?

Features

• Works anywhere — email, docs, browsers, terminals, chat apps. Not bound to any single editor.
• Strict proofreading — fixes only grammar, spelling, and punctuation. Preserves your meaning, voice, tone, style, slang, dialect, emoji, and formatting. Corrects in the language you wrote in.
• Streaming results — output streams in as it is generated and is shown exactly as it will be pasted. The popup grows a little for long results.
• Menu bar app — no window on launch and no Dock icon. One icon gives you your version, update checks, Settings, and Quit.
• Customizable keys — record your own global shortcut and your own Replace key (default Enter) from Settings. Changes apply immediately.
• OpenAI-compatible — bring your own API key, or point it at a local model (Ollama, LM Studio, anything speaking the Chat Completions API).
• Keychain-secured — your API key lives in the OS keychain, never in the settings file.
• Right-to-left ready — Arabic, Persian, and Hebrew text is laid out in the right direction, paragraph by paragraph.
• Self-updating — check for and install new versions from the menu bar icon.
• Launch at login — optional, one switch in Settings.
• One design everywhere — a shared design system, the same bundled font (Inter), and light and dark mode on every platform.
• Small and fast — Tauri 2 + Rust + Svelte. No Electron and no bundled browser, so the app itself is only a few megabytes.
• Retry & cancel — transient failures retry automatically, and you can cancel a stream mid-flight.

How it works

1. Select text in any application.
2. Press the shortcut. shakespAIre reads your selection, then opens a frameless popup near the text (on macOS it uses the Accessibility API to sit next to the selection; elsewhere it appears near the cursor).
   • macOS and Windows: it copies the selection through the clipboard and restores your clipboard afterwards.
   • Linux: it reads the highlighted text straight from the primary selection, without touching your clipboard, and falls back to copying if that is empty.
3. Stream — the AI streams a proofread into the popup in real time.
4. Act — press Enter (or your Replace key) to replace the original, ⌘/Ctrl+C to copy, or Esc to cancel. Clicking anywhere outside the popup closes it.

Download

Prebuilt installers for every release are on the Releases page.

Every release also contains latest.json and .sig files. Those are what the built-in updater uses; you do not need to download them.

Usage

Keyboard shortcuts

The trigger shortcut and the Replace key are both customizable. Esc and ⌘/Ctrl+C are reserved and cannot be used as the Replace key.

The proofread popup

The popup shows a status (Connecting → Writing → Ready), the result exactly as it will be pasted, and three actions: Replace, Copy, and Close. If something goes wrong, it shows the message and a Try again button, and Replace stays disabled so a half-finished result can never overwrite your text.

The menu bar icon

Click the icon in the menu bar (or system tray) to open its menu:

Configuration

Choose Settings… from the menu bar icon. On first launch the window opens once by itself.

Click Save to store the server, key, and model. The keys and the login switch apply as soon as you change them. Preview popup (under the Save button) opens the popup on a sample sentence and streams a real proofread, so you can check your setup end to end. Replace is disabled in the preview.

Local models

Point shakespAIre at a local server to keep your text on your machine — no API key needed.

Customizing the keys

1. Open Settings and click the Shortcut or Replace key field. It prompts: "Press keys…"
2. Hold the modifier(s) and press one key (letter, number, function key, arrow, or symbol). Esc cancels.
3. The global shortcut needs at least one modifier (⌘/Ctrl/Option/Shift); the Replace key can be a single key such as Enter or F2.

Where things are stored

• API key → OS keychain (service com.artamrj.shakesp-ai-re, account ai-api-key). Where no keychain exists (common on minimal Linux desktops), a file ai-api-key.txt in the app's config folder is used instead, readable only by your user.
• Settings file (ai-settings.json) holds the base URL, model, shortcut, and Replace key — never the API key (enforced by a unit test).
• Logs → shakesp-ai-re/logs/shakesp-ai-re.log in your user data folder (~/Library/Application Support on macOS, ~/.local/share on Linux, %LOCALAPPDATA% on Windows).
• Environment overrides (for development): OPENAI_BASE_URL, OPENAI_API_KEY, and OPENAI_MODEL take precedence over the settings file.

Updates

shakespAIre updates itself from the menu bar icon.

• Release builds check quietly about once a day. When a newer version exists, the menu item changes to Install Update vX.Y.Z… and the icon's tooltip says an update is available.
• Nothing installs until you click it. After the download, shakespAIre waits for an open popup or a running replace to finish before it restarts.
• Every update is signed. The app only accepts files signed by the project's key, which is built into it.
• Linux: only the AppImage updates itself. Install a newer .deb or .rpm with your package manager.
• macOS: builds are not yet signed with an Apple Developer ID, so macOS treats each update as a new app and asks for the Accessibility permission again after updating.

Platform notes

macOS

• Accessibility permission required. Selection capture and replacement simulate ⌘C/⌘V and read selection bounds via the Accessibility API. Grant it under System Settings → Privacy & Security → Accessibility. Settings shows whether it is granted.
• The popup positions itself next to the selected text when the focused app exposes selection bounds; otherwise it appears near your mouse. Many Chromium/Electron apps do not expose them.
• The popup uses the native Liquid Glass effect on macOS 26 and newer (vibrancy on older versions), so the app is direct-download only — not available on the Mac App Store.
• Unsigned by Apple. Builds are ad-hoc signed and not notarized. On first launch you may need to right-click the app and choose Open.
• Installing over a previous version may reset the Accessibility permission; toggle it off and on again if the shortcut stops capturing text.

Windows

• Text injection uses the native SendInput API and requires no helper program.
• It cannot inject into an application running with higher privileges (for example an admin app from a non-elevated install). Run both at the same level.
• The installers are not code-signed yet. Windows will warn about an unknown publisher:
  • SmartScreen ("Windows protected your PC"): click More info → Run anyway. If that button is missing, right-click the installer → Properties → tick Unblock.
  • Smart App Control blocks unsigned apps outright. You can turn it off under Windows Security → App & browser control → Smart App Control settings.

Linux

• Reading the selection works out of the box through the primary selection, using xclip or xsel (X11) or wl-clipboard (Wayland). Install one of them.
• Pasting the result needs one input helper, intentionally not bundled:
  • X11: xdotool.
  • Wayland: wtype. It does not work on GNOME's Wayland session; on GNOME, use an X11 session or press Copy and paste yourself.
• On Wayland, xdotool is only a limited XWayland fallback and cannot control every native Wayland application.
• If no keyring service is running, your API key is stored in a private file instead of the keychain.
• Popup positioning is macOS-only; on Linux the popup appears near the cursor.
• The tray icon needs a tray host. Stock GNOME needs an AppIndicator extension.

Troubleshooting

The log file (see Where things are stored) records each capture and popup with timings and is the first place to look.

Privacy & security

• No telemetry, no analytics, no accounts. shakespAIre doesn't phone home. The only other network request is the update check, which fetches a public file from GitHub.
• Your API key is stored in the OS keychain — the settings file is verified to never contain it.
• Your clipboard is saved and restored around every capture and replace (macOS/Windows), so shakespAIre doesn't clobber what you copied. On Linux the selection is read without using the clipboard.
• Your selected text is sent only to the endpoint you configure. Point it at a local model to keep text entirely on your machine.
• Prompt-injection guard: the selected text is treated as data, not as instructions to the model.
• Signed updates: the app refuses any update not signed by the project's key.

Build from source

Prerequisites

• Node.js LTS
• Rust (stable) — via rustup
• Platform Tauri system dependencies — see the Tauri 2 prerequisites.

Commands

npm install                 # install frontend deps
npm run tauri dev           # run a dev build
npm run dev:side-by-side    # dev build with its own settings, next to an installed copy
npm run check               # svelte-check (typecheck the frontend)
cargo fmt --manifest-path src-tauri/Cargo.toml --check   # formatting
cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets -- -D warnings
cargo test --manifest-path src-tauri/Cargo.toml          # Rust tests
npm run bundle:macos        # .app + .dmg
npm run bundle:windows      # NSIS .exe + .msi
npm run bundle:linux        # AppImage + .deb + .rpm

Builds produce update files, so bundling needs the signing key in the environment (TAURI_SIGNING_PRIVATE_KEY_PATH). See docs/RELEASING.md.

Regenerate icons from the master source:

npm run icons        # tauri icon assets/branding/shakesp-ai-re-icon-master.png

Running a dev build next to an installed copy

Both copies would share settings and fight over the same global shortcut. This script gives the dev copy its own identity (com.artamrj.shakesp-ai-re.dev, defined in src-tauri/tauri.dev.conf.json), so it has separate settings:

npm run dev:side-by-side

Then open the dev copy's Settings and choose a different shortcut from the installed app's, and leave Launch at login off. The API key is shared, because both use the same keychain entry. Or simply quit the installed app while you develop.

Project layout

src/                     Svelte 5 frontend (settings window and popup)
  App.svelte             Settings window
  Popup.svelte           Proofread popup
  theme.css              Shared design system
  shortcut.ts            Shortcut parsing and labels
  fonts/                 Bundled Inter (SIL OFL)
src-tauri/               Rust backend (Tauri 2)
  src/lib.rs             App setup, commands, tray menu, shortcuts
  src/ai.rs              Streaming chat client
  src/clipboard.rs       Selection capture and clipboard restore
  src/input.rs           Copy/paste simulation, selection bounds (per OS)
  src/popup.rs           Popup window, positioning, focus
  src/glass.rs           Native glass/vibrancy backdrop
  src/updater.rs         Menu bar self-update
docs/RELEASING.md        Release, signing, and updater guide
.github/                 CI, releases, Dependabot (see .github/CI.md)

Releasing

Releases are automatic and driven by commit messages. Merge changes with Conventional Commit titles (feat:, fix:, …); a bot keeps a Release pull request up to date with the next version and changelog. Merging it builds and publishes the installers after one approval. Nobody edits a version number or pushes a tag by hand.

The whole pipeline is described in .github/CI.md. Signing, notarization, and the updater key are covered in docs/RELEASING.md.

Contributing

Pull requests are welcome — see CONTRIBUTING.md for the full guide, and SECURITY.md to report a vulnerability privately. In short:

• Title your pull request like a Conventional Commit (fix: …, feat: …, docs: …). CI checks it, and the title becomes the commit message that decides the next version.
• Do not bump versions by hand. The release bot does it in every file at once.
• Make CI pass: npm run check, cargo fmt --check, cargo clippy -- -D warnings, and cargo test. CI also compiles the app on macOS and Windows.
• Keep Tauri versions matched. The Rust tauri crate and the @tauri-apps/* npm packages must share a minor version.
• Don't commit secrets. The API key belongs in the keychain, and signing keys belong in GitHub secrets.
• Naming: write shakespAIre when displayed to people and shakesp-ai-re in identifiers, file names, and URLs.

License

MIT © 2026 Arta