AllInOneIME

English | 中文

A macOS input method with AI commands in every text field. Start a sentence with @ and press ⏎ when done:
@improve polishes what you wrote and offers a few rewrites, @translate translates it into the languages you pick,
@question asks a question, @claude hands it to Claude Code, and @open finds files and apps or opens a web
address. You can also hold right ⌥ and talk. Without @, your keys go to the app as usual. It's also a full
Chinese (pinyin) input method, built on Rime and rime-ice, for those who want one.

Author: Weijian Zhang

For more detail (every command and setting, installation troubleshooting, privacy), see the Wiki.

How to use

Without @, it stays out of the way: in English, letters are typed directly and ⏎ is Return; nothing goes online.
To write in English only, set Input languages to English in the settings (see Input and translation).

@ commands (beta)

Example: @q ⏎, type what is quantum computing, ⏎. @note books to read: The Three-Body Problem ⏎ saves a note.
@reminder call Bob tomorrow at 3pm ⏎, check the time it read, then ⏎ again to add it. Once the command is chosen, you can also hold right ⌥
and talk. In Chinese mode, @open and @calculate switch to English letters for the moment and go back to Chinese when you're done.

The code for @py and @js is typed in English letters, and full-width punctuation (from Chinese mode) becomes ASCII; write it on one line, with ; between statements.
It runs in a separate process, stopped after 10 seconds or with Esc at any time; on an error, the error's first line is shown, e.g. ZeroDivisionError: division by zero.
Output with several lines is inserted as printed; in a terminal it goes in as one line (a terminal runs every line it is given).
A terminal inside an editor (VS Code, Cursor, JetBrains) can't be told apart from the editor itself, so there any command's output with several lines goes in as it is.
Both also work inside another command's sentence: @reply the answer is @py 2**100; put code with spaces in quotes: @question explain @py "sum(x * x for x in range(10))".
Not the other way round: the code of @py and @js always runs exactly as you typed it, and @commands in it don't run first.

When @ isn't followed by a command, as in @john, the @ is inserted as usual, so @-mentioning
people in chat apps still works.
@question, @improve and @translate send to your own Bedrock only when you press the action key; @open searches only on this
Mac; @note and @reminder go only to Notes and Reminders on this Mac; @claude uses the Claude Code installed on your Mac (the claude command) and its own account, and it asks you
first, as usual, before changing files or running commands. Without Claude Code installed, @claude isn't offered.
@imessage reads Contacts on this Mac only (names, phone numbers, emails), never goes through the AI, and Messages sends
the message; without the Messages app it isn't offered.

@calculate works on this Mac, offline: + - * / (also × ÷), ^ or ** for powers, parentheses, percent (50% is 0.5,
200*5% is 10; as on a calculator, a percentage added or subtracted is of what comes before: 100+10% is 110,
100-10% is 90), the functions sqrt abs round floor ceil ln log exp sin cos tan min max pow (log is base 10, angles
are radians, round(x, 2) keeps two decimals) and the constants pi (π) and e. Full-width digits and signs work too. Arithmetic is exact in decimal, so 0.1+0.2 is 0.3; results have at most 15 significant digits, and
whole numbers of up to 38 digits are written out in full (2^100 → 1267650600228229401496703205376).

Notes and reminders

@note makes a new note; its first line is the title. After copying some text, @note ⏎ ⏎ ⏎ (or ⌃V after @note ) saves it with its line breaks, shown as ↵ in the command.
If you leave the text field (click elsewhere, switch apps) or press ⇧⏎ (insert as typed) before a note with line breaks is saved, it isn't typed into the app (in a terminal, each line would run as a command): it goes on the clipboard instead ("The note wasn't saved; its text is on the clipboard"). A note of one line is inserted as typed.

@reminder reads times like tomorrow at 3pm, in 2 hours, in 3 days at 3pm, on the 15th, this weekend, in 1 month, next month (its 1st), end of the year (Chinese times too).
The day and the time can be apart (tomorrow call Bob at 5); weeks start on Monday.
A time without am or pm (at 5) is the next one, never between midnight and 6 a.m.; a time already past today is tomorrow, but a part of the day still going (this afternoon, tonight) is today, all day; a date already past this year is next year's.
Written to repeat (standup every Monday at 9), it is added once, for the next time: the words stay in the title and the row says "once only".
The row to confirm shows the time it read, e.g. "tomorrow 3:00 PM" (following the Mac's 12/24-hour setting); if it's wrong, Esc goes back to the text. With no time or date in it, it has none ("no date").

@stock and the like inside these two aren't run: the text is saved as written (typing @ there doesn't open the command list). The first time, macOS asks whether AllInOneIME may control Notes (@note) or access Reminders (@reminder): allow it.
If you didn't, allow AllInOneIME in System Settings → Privacy & Security → Automation (Notes) or → Reminders.
When a save fails (no permission, say), the notice says why and the text comes back into the command, to fix and send again; when you have to fix something first (a permission, an account), it's also put on the clipboard (going to System Settings takes the focus from the text field). If you've moved to another text field or are typing something else, it goes on the clipboard instead ("Not saved; the text is on the clipboard.").

Your own commands

In the settings, under "Custom @ Commands", click "Add Command…": give it a name and choose what it does (an AI
instruction, a program, a program in Terminal, or a web page), or start from an example. Your commands come after the built-in
ones; names are English letters only and can't be a built-in command's; they work from the next sentence.
They're kept in customCommands in the config file (~/.config/allinoneime/config.json), which you can also edit:

"customCommands": [
  { "name": "python", "type": "run", "argv": ["python3", "-c", "{input}"], "summary": "Run Python" },
  { "name": "bc", "type": "run", "argv": ["bc", "-l"], "stdin": "{input}\n" },
  { "name": "sh", "type": "terminal", "argv": ["zsh", "-c", "{input}"] },
  { "name": "reply", "type": "prompt", "prompt": "Write a short, polite reply to the user's message." },
  { "name": "google", "type": "link", "url": "https://www.google.com/search?q={input}" }
]

• {input} becomes what you wrote after the command, and it always stays within the one argument it's in: no shell is involved. For a shell, say so, like sh above (zsh -c).
• stdin: what goes to the program's standard input, with {input} replaced too.
• A link's url must be https://, with {input} once, after the ? or #; the text is encoded (a space is %20, a newline %0A), 4000 characters at most.
• run and terminal type English letters by default (like @open; in Chinese mode, Chinese comes back after), and full-width punctuation becomes ASCII. Set "ascii": false to keep text as typed.
• Programs run in your home folder with your login shell's PATH (so Homebrew, pyenv and nvm installs are found). run stops a program after 10 seconds (timeoutSeconds) or when it prints too much; Esc stops it at any time.
• summary is the description in the command list (optional).
• When the program in argv isn't found (say, no python3), the command isn't offered and @python … is inserted as text; once it's installed, the command appears in the next text field.

run and terminal run code on your Mac: only add commands you wrote and trust. They, too, run only when you press the action key, and never during secure input.

Plugins

Plugins are ready-made @ commands for things not everyone needs, like @stock AAPL 600519 700 for stock quotes.
Installed, they work like any command; "Plugins" in the settings shows what's installed and where each sends your text,
and removes them. Plugins are JavaScript run in a separate process: they can reach only the websites they declare
(HTTPS), and can't read files or run other programs. "Browse Library…" under Plugins in the settings installs them
from the plugin library: it shows which websites a plugin
contacts before installing; the library's index is signed and every file must match it. A newer version shows an
"Update" button; nothing updates by itself. Your own plugins go in ~/.config/allinoneime/plugins/ ("Open Plugins
Folder"): local plugins, never overwritten by the library.
"Link" plugins run no code: they put the text into a web address and open it in the browser, like @x nice weather today, which opens X's composer with the text filled in; posting is up to you on the page. The library has four
(@x, @threads, @bsky, @weibo). @xe converts currencies: @xe 100 USD CNY, @xe 1000 JPY EUR, one line
with the date of the rate (rates by ExchangeRate-API). Writing one: docs/plugins.md.

Commands that fetch something (plugins and programs) also work inside a sentence: @reply tell her @stock AAPL is up today.
The inner ones run first, their output takes their place, and the outer command works on the result. The argument is
the word after the command, plus the uppercase codes or numbers right after it (@stock AAPL TSLA, @stock 600519 700);
a lowercase word ends it (@stock SNDK is good to buy looks up SNDK). Quotes mark it exactly: @stock "aapl tsla".
@calculate works inside a sentence too; its argument is the whole expression after it, spaces included, up to other text:
@reply the total is @calculate 23 * 17 dollars.
Inside @claude and terminal commands they aren't run: those get the text as written (typing @ there doesn't open the command list).

Action key

⏎ by default; change it under "Action key" in the settings (actionKey in the config): ⏎, Tap ⌥ (either side: press
and let go right away; holding right ⌥ is still for talking), ⌥Space, or Space (press Space once more after the words
are picked; twice in English mode).
Whatever the action key, @ commands also run on ⏎. If ⌥Space is already a shortcut for Alfred, Raycast or the like,
they get it first.

Menu bar panel

Click AllInOneIME's icon in the menu bar (the ∞-and-cursor mark, without a box; the boxed one is the input source) and the panel drops down under it; a click elsewhere closes it:

• Notes: the notes saved with @note, the newest 5; click one to open it in Notes.
• Reminders: the reminders not done yet in the AllInOneIME list of Reminders (@reminder adds to that list), the soonest due first, 8 shown; click the circle to tick one off, or the title to open Reminders.
• Claude Tasks: like @tasks, the background Claude tasks (what @claude hands off), up to 30, 5 shown at a time: scroll for more, or search their titles and replies in the search box; with their progress and the first line of the last reply; click one to open it in Terminal and go on.

Swipe a row (a note, a reminder or a task) to the left with two fingers to show its Remove button, or all the way to remove it at once; with a mouse, right-click it. Removing only takes it off the panel: the note stays in Notes, the reminder in Reminders (not completed), the task in Claude Code.

The header has the counts (like "2 reminders · 1 task running"; tasks waiting for you are counted apart, like "1 waiting for you") and a refresh button.
It never takes the focus from the app you're typing in: ticking off a reminder or refreshing leaves that app in front; only the Claude tasks' search box, once clicked, takes the keyboard.
The icon is shown by default; turn it off under "Menu Bar Panel" in the settings.

What it reads, and when:

• Notes: the list is the panel's own record (kept while it's closed too), and Notes is never launched: only when Notes is running already, and AllInOneIME was allowed to control it before, does the panel check it for edited titles and deleted notes.
• Reminders: the AllInOneIME list is read when the panel drops down, every 60 seconds and when reminders change. The panel never makes macOS ask for access by itself: if macOS hasn't asked you yet, it shows "Allow Access to Reminders", and only that button asks; if you said no, it shows "Open System Settings".
• Claude tasks: the panel runs claude agents only while it's down: once when it drops down, on Refresh, and when @claude hands off a task; and every 15 seconds while a task isn't done yet, no longer once they're all done. The last replies are read from the end of Claude Code's transcripts on this Mac (~/.claude/projects), and only when a transcript has changed.
• While it's closed, none of this runs; it only keeps a record of the notes @note saves.

Input and translation

In the settings:

• Input languages: English, Chinese (pinyin), or both. A new install starts with Chinese only: to write English, add English and remove Chinese (or drag English first). New text fields start in the first; with two, tap Shift to switch; with one, Shift doesn't switch.
• Fuzzy pinyin (with Chinese input): sounds you don't tell apart typed either way, e.g. z ↔ zh, n ↔ l, in ↔ ing. On the Input page, pick Chinese (pinyin) in the bar of input languages, turn on "Fuzzy pinyin" and pick the pairs; the dictionaries are deployed again in a second or two. It writes rime_ice.custom.yaml in the Rime user folder, and never over a file of your own there.
• Translate (@translate): add the languages to translate into (Spanish, French, German, Japanese, Korean, Chinese…) and drag them into order. @translate writes a line in each, in this order (three versions with only one); the sentence's own language is skipped. A new install has English only.
• @improve polishes and rewrites without translating; @translate @improve together translates and rewrites in one request. Turn on "@improve also translates" in the settings to make @improve always do that.

Rewrite styles

After lines 1–3 come the rewrites, in the language you typed: English rewrites for English, Chinese rewrites for Chinese. Pick any of them in the settings:

• Polish: same tone, more natural
• Concise
• Formal: for managers and clients
• Casual
• Tactful
• Jargon: Amazon-speak in English (bandwidth, circle back…), big-tech jargon in Chinese. Bad news is played down, e.g. "this is a blocker bug" → "Oh! Looks like your team has the bandwidth to fix this minor issue!"

Rewrites that only change punctuation or repeat another line aren't shown.

Jargon list (your own terms)

Jargon has no built-in term list. You can prepare your own (for example, the phrases your team uses), and the model
prefers its terms. In the candidates, the Jargon line notes what the terms it used mean.

The list is a text file with one term per line, optionally followed by its meaning, separated by "=", a colon or a
Tab (you can copy two columns from a spreadsheet and paste them). Lines starting with # are comments:

PRFAQ = a new-feature proposal: the press release and FAQ, written first
COE = an incident review
two-way door = a decision you can undo at any time

Under "Rewrite Styles → Jargon list" in the settings, click "New" to create an empty list at ~/.config/allinoneime/jargon.txt and open it;
if you already have a list file, click "Choose File…" to use it where it is (jargonFile in the config). Changes apply right away.
Only the first 150 terms are read. With "Jargon" checked, the list is sent to Bedrock along with each request.

Voice input

Hold right ⌥ and talk; when you let go, the text is inserted. If you type a command first (e.g. @improve , @question ) and then talk, the text goes after the command and ⏎ runs it; you can also press ⏎ without letting go of right ⌥ to run it as soon as you finish. Speech is recognized on the Mac by macOS's built-in speech recognition (SpeechAnalyzer), and no audio is uploaded; it needs macOS 26 or later.

The first time:

• macOS asks whether AllInOneIME may use the microphone. You can also click "Allow Microphone" in the settings beforehand.
• If this Mac doesn't have the speech model for that language yet, it's downloaded once, automatically. You can also download it in the settings.

Recording starts only after you've held the key for about 0.2 s, so a quick tap on right ⌥ doesn't turn on the microphone (with the action key set to "Tap ⌥", a tap runs the action). If you press another key while holding it (an ⌥ shortcut, ⌥←), it counts as a shortcut and nothing is recorded either. Pressing any other key while recording cancels the recording.

Installation

Running it needs macOS 14 or later, voice input macOS 26 or later. The installer is universal: it works on Macs with
Apple silicon and Intel. So far it has only been tested on macOS 27 on Apple silicon (the Intel build only through its self-test under Rosetta).

1. Download AllInOneIME-<version>.dmg from Releases (only from there) and open it.
2. Double-click "Install AllInOneIME" in it and click Install. The input method goes into ~/Library/Input Methods
   and "AllInOneIME Settings" into ~/Applications. For this user only; no administrator password needed.
3. The installer isn't notarized by Apple yet, so macOS can't verify who made it, and the first time it says it can't verify "Install AllInOneIME":
   click Done (Cancel on macOS 14), open System Settings → Privacy & Security, click Open Anyway near the bottom, and confirm.
   Each new version's installer needs this once.

After that, AllInOneIME is enabled and in your input sources; switch to it with Ctrl+Space
(the 🌐 key switches only if "Press 🌐 key to" is set to "Change Input Source" in System Settings → Keyboard).
If the installer tells you to add it by hand, this Mac doesn't let programs enable it, so add it once yourself:
System Settings → Keyboard → Text Input → Input Sources → Edit… → + (bottom left) → Chinese, Simplified → AllInOneIME
(macOS lists it under Chinese because it can type pinyin; it types English just as well).

If Ctrl+Space doesn't get you to AllInOneIME, or it switches back to U.S. after a while, run the installer again: it adds AllInOneIME back to your input sources.

To update, install again from the new version's disk image, without uninstalling first; settings, the jargon list and learned words are kept.
Before upgrading, read the changelog: it has each version's changes and upgrade notes.

If you had AIPinyin installed (AllInOneIME's earlier name), just install: the old AIPinyin.app and its settings launcher are removed,
and the entry in your input sources gets the new name, with no need to add it again. Settings, the jargon list and learned words move to the new folders
(~/.config/allinoneime and others) on first launch, and each old folder is left as a link to the new one.

To uninstall, open "Install AllInOneIME" and click Uninstall…. Settings and learned words are kept.

Building from source

Building needs Xcode 26 or later, since voice input uses the macOS 26 SDK.

git clone https://github.com/MicroZ-LLC/AllInOneIME.git
cd AllInOneIME
make install

make install downloads librime and the rime-ice dictionaries and verifies them, builds, and installs into the same places, adding it to your input sources the same way.
make status shows the installed version (version:) and whether it's in your input sources (listed:). To uninstall: make uninstall.

Setting up the AI

Translations and rewrites use your own AI provider, and the costs go to your account: Amazon Bedrock in your AWS account by default, or the Claude API, Gemini or an OpenAI-compatible service (see "Other AI providers" below).

Amazon Bedrock

1. Enable Bedrock in the AWS console and make sure you can use the chosen model. The default is Claude Haiku 4.5; the first time you use an Anthropic model, you fill in a use-case form once.
2. Create an access key with the bedrock:InvokeModelWithResponseStream permission and put it in a profile in ~/.aws/credentials.
   Only such static keys are supported for now, not SSO or assume-role.
3. Open "AllInOneIME Settings": you can find it in Spotlight or in Applications, or open it from the input method's icon in the menu bar → Settings….
   Pick the profile, region and model, and click "Test Connection". "Language" at the top of the settings window can be English or Chinese; by default ("System") it follows the system
   (Chinese if Chinese comes before English in the system's preferred languages, English otherwise). The settings window, the hints in the candidate panel and the input menu all follow it.

Other AI providers: Claude API, Gemini, OpenAI-compatible services

You don't need AWS: pick one under "AI Provider" in the settings, paste an API key, click "Save", then "Test Connection".

• API keys are kept in the system keychain, never in the config file. Without one there, ANTHROPIC_API_KEY, GEMINI_API_KEY (or GOOGLE_API_KEY) and OPENAI_API_KEY from your shell are used.
• "Thinking" is low by default: the input method waits on every sentence, and less thinking is faster. Choose "Not set" for models that don't take it.
• With Claude Opus 5.5 or Sonnet 5.5 chosen, requests carry the Claude API's refusal fallback (fallbacks: "default"): when a safety classifier declines, the server retries on another model.
• In the config file: provider ("bedrock", "anthropic", "gemini", "openai"), and model, baseURL, effort and temperature under anthropic, gemini and openai (unset ones use the defaults).

All settings are stored in ~/.config/allinoneime/config.json; after a change, the next translation uses the new settings, with no restart. The newer keys:

Privacy

• Typing (English and pinyin) and @calculate calculations are entirely local. Only when you press the action key on @improve, @translate or @question is that sentence sent to the AI provider you chose (your own Bedrock, or the service whose key you added). With "Jargon" checked and a jargon list set, the list is sent along with it.
• With AllInOneIME Cloud, the sentence goes through the developer's server to a model provider (currently through OpenRouter): the server keeps counts only, never the text. Signing in keeps only your email address.
• Voice is recorded only while you hold right ⌥ and is recognized on the Mac; the recognized text is sent only in the commands above, when you press the action key.
• The input method reads the clipboard text, once, only when you press ⌃V or ⌘V in a command or press the action key with nothing written after a command; content that password managers mark as concealed isn't read. The text is shown in the command first and, again, is sent only when you press the action key. Recent macOS versions ask whether AllInOneIME may read the clipboard: allow it. To stop being asked every time, set AllInOneIME's paste permission to always allow in System Settings → Privacy & Security.
• In password fields (secure input) it doesn't compose text and can't record. Whenever the system is in secure input (password fields, Terminal's Secure Keyboard Entry, etc.), nothing is sent to the AI.
• @note and @reminder don't go to the AI: AllInOneIME hands the text only to Notes and Reminders on this Mac, and reads the reminder's time on the Mac too (whether those apps sync it to your other devices depends on their accounts, such as iCloud). So they work during secure input as well.
• @open searches only on this Mac. It remembers what you opened with it (the latest 200), in the input method's own preferences (not in config.json), to list those first.
• To list your notes, the menu bar panel keeps the id and first line (up to 80 characters) of the last 30 notes saved with @note, in the input method's own preferences, also while the panel is off.
• @py and @js run only when you press the action key, and only code you typed or pasted yourself: the AI's answers and other commands' output are never run as code. @py uses your Mac's python3, which can read and write files and go online as it does in Terminal; @js runs in a separate process that can't read files, reach the network or run other programs. Neither runs during secure input.
• Logs don't record what you type. For every third-party input method, macOS warns "The developer can access anything you type with this input source"; it's a generic system warning.

Development

make test         # unit tests, plus tests that run the real Rime engine
make selftest     # drives the input method through a simulated text field: real Bedrock calls, plus on-device recognition tested with synthesized speech
make realtest     # types into a real app's text field (needs the screen unlocked; takes over the foreground for about 1 minute)
make screenshots  # regenerates the screenshots in docs/
make cli && .build/release/allinoneime-cli --styles concise,jargon "this is a blocker bug your team need fix it asap"   # try polishing and rewrites in the terminal
make icon         # regenerates the app icon and the menu bar icon from Resources/AppIcon.png
make dmg          # the release installer, build/AllInOneIME-<version>.dmg (universal; signed if there's a Developer ID certificate, optionally notarized)

Code layout:

• Sources/AllInOneIMECore: Bedrock client, SigV4, prompts, the two-level input state machine (including @ commands and the voice gesture); no AppKit dependency
• Sources/AllInOneIMERime: librime wrapper
• Sources/AllInOneIME: the InputMethodKit input method, candidate panel, settings window, speech recognition
• Sources/AllInOneIMESettings: the "AllInOneIME Settings" launcher
• Sources/AllInOneIMEInstaller: "Install AllInOneIME" on the disk image: installs, updates and uninstalls

The bundle ID is still com.aipinyin.inputmethod.AIPinyin: macOS uses it to remember the added input source and the microphone permission, so changing it would mean adding the input method and granting the permission again.

License

Copyright © 2026 MicroZ LLC. GPL-3.0; see LICENSE. Third-party components (librime and its plugins under BSD-3-Clause, rime-ice under GPL-3.0)
are listed in THIRD_PARTY_NOTICES.md.