claudeers.
// Other

AllInOneIME

A macOS input method with AI commands in every text field: @improve polishes, @translate translates, @question answers, @claude hands off to Claude Code. Als…

// Other[ cli ][ api ][ web ][ claude ]#claude#ai#claude-code#input-method#llm#macos#pinyin#rime#other◷ NOASSERTION$open-sourceupdated about 1 month ago
Actively maintained
100/100
last commit 7 days ago
last release 7 days ago
releases 25
open issues 7
// star history

Install with your AI

Paste into Claude Code, Cursor, or any agent — it reads the repo and wires the tool into your project.

Install and set up AllInOneIME (release-binary project) into my current project.
Found on https://claudeers.com/allinoneime
Repo: https://github.com/MicroZ-LLC/AllInOneIME
Homepage/docs: https://allinoneime.com
Detected install method: release-binary → inspect the README
Category: other. Platforms: cli, api, web.
Read the repo's README for exact setup and env vars, then install it and wire it into my project.

Claudeers Health Verdict:
active; community-verified: false. Confirm the source before running anything.
// or install directly (release-binary)

Grab the latest release asset from GitHub.

# download a build from https://github.com/MicroZ-LLC/AllInOneIME/releases
// or clone
git clone https://github.com/MicroZ-LLC/AllInOneIME

// compatibility

Platformscli, api, web
Operating systems—
AI compatibilityclaude
LicenseNOASSERTION
Pricingopen-source
LanguageSwift

Get your FREE $2.50 API credits to access TickAtlas financial data ↗

English · 简体中文 · 繁體中文 · 日本語 · 한국어 · Français · Deutsch · Español · Português (Brasil) · Italiano · Русский · Tiếng Việt · ไทย · Bahasa Indonesia · हिन्दी · العربية · Türkçe


AllInOneIME icon

AllInOneIME

AI commands in every text field on your Mac.

Type @improve, @translate or @question in any app, press ⏎, and pick the result.
No copying into a chat window, no switching apps. Your own AI provider, your own keys.

Download · Website · Docs · Extensions

How to use · Commands · Your own commands · Languages · Voice · Installation · Privacy


@translate and a sentence, then ⏎: a line in Spanish, French and German

[!NOTE] From 0.6.3 on, AllInOneIME is signed with a Developer ID and notarized by Apple: no more allowing it in System Settings → Privacy & Security. After updating from an earlier version, macOS asks once for your login password for each key AllInOneIME saved in the keychain: enter it and click "Always Allow". Download AllInOneIME only from GitHub Releases or allinoneime.com.

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 also types Chinese (pinyin, built on Rime and rime-ice), French, Korean (Hangul) and Hindi (Devanagari from Latin letters), and runs your own scripts as @ commands.

@improve and a rough sentence, then ⏎: polished versions, plus rewrites

For more detail (every command and setting, installation troubleshooting, privacy), see the Wiki. Made by Weijian Zhang at MicroZ LLC.

How to use

Without @, it stays out of the way: in English, letters are typed directly and ⏎ is Return; nothing goes online. A new install writes English; to type Chinese (pinyin), French, Korean or Hindi too, add it in the settings (see Input and translation).

KeyWhat it does
Type pinyin, Space / digitsIn Chinese mode: pick words, as in any pinyin input method
@ (at the start of a sentence)Opens the command list: the most used lately first, 5 at a time, scrolled with ↑↓, the wheel or the trackpad; or type letters to find one (a name typed in full first, then names starting with them, then names containing them). ⏎, Tab, Space or a digit chooses
⏎Runs the command. Works even if the pinyin isn't picked yet: it's picked first, as with Space
Space, ⏎ / digitsOnce the results are up: insert the highlighted / numbered one; 0 is the original
⌘CCopies the highlighted result (for @open, the path); the candidate panel stays open
⌃VIn a command (e.g. after @improve ): appends the clipboard text after what you've typed instead of pasting it into the app. Multiple lines become one, up to 2000 characters at a time (@note keeps the line breaks and takes up to 20000). Works in any app; without a command, the key goes to the app as usual
⌘VLike ⌃V, but some apps handle ⌘V themselves (terminals such as Ghostty, iTerm2 and Terminal, and Notes) and paste into the app as usual; use ⌃V there
Esc, ⌫Back to the sentence to keep editing; typing punctuation or digits after the results continues it. After a refine: back to the results before it
Letters, once AI results are upA follow-up instruction, such as shorter: ⏎ refines the results (see Refining the results)
Click a rowIn the candidate panel: picks it, as its digit would (a word, a command in the list, a result, an @open file, a recipient, an extension's row); the row under the pointer is highlighted. The text field keeps the focus
Tap ShiftWith more than one input language: the next one, in their order (English → Chinese → French → …, then back to the first)
Hold right ⌥Talk, release to stop. In the language you're typing (English, Chinese, French, Korean or Hindi). In a command, the text goes after it; otherwise it's inserted directly

@ commands (beta)

CommandWhat it does
@improvePolish: 1–3 are three versions in the sentence's own language, 4 onward the rewrite styles (added and ordered in the settings), 0 is the original. No translation; with "@improve also translates" on, it works like @translate @improve
@translateTranslate into the languages you added (settings → Translate, drag to reorder), a line each, three versions with only one; the sentence's own language is skipped. @translate @improve together translates and rewrites in one request
@questionAsk a question; the answer appears in the candidates, ⏎ or Space inserts it, ⌘C copies it. With nothing typed after it, it lists your last 5 questions, newest first; typing narrows them down (words anywhere in the question, any case, Chinese too). A digit, ↑↓ then ⏎, or a click shows a question's saved answer at once, offline, to insert or copy as usual; R there asks it again for a fresh answer. With no match, or nothing picked, ⏎ asks what you typed
@claudeHands the task to Claude Code: in the background by default, with a notification when it's done (click it to open the session in Terminal and go on), or see @tasks. It uses your own Claude Code (the claude command) with its own sign-in and settings. Turn off "@claude runs in the background and notifies me" in the settings to open it in Terminal as before. The first time it opens Terminal, macOS asks whether AllInOneIME may control Terminal: click OK
@tasksLists the background Claude tasks (working / done / waiting for you) with their last replies; ⏎ opens one in Terminal, ⌘C copies the reply
@settingsOpens the settings window right away (picking it is enough)
@openLists matching files, folders and apps as you type (Spotlight). Several keywords work, separated by spaces: each must be in the path, at least one in the name (a standard folder's name counts for what's in it: downloads pdf finds the PDFs in Downloads). Apps and the standard folders are also found by their Chinese names, and a Chinese interface shows them that way. What you opened with @open comes first, then apps and those folders, then recently used or changed files; when the names find two files or fewer and no app or folder of those, the files in your home folder are searched by content too, those rows marked "content"; when there's nothing else, ⏎ lists them to pick from instead of opening the first. With a web address (github.com, localhost:3000, https://…), the first row is "open in the browser" and contents aren't searched; a file named exactly that (say MANIFEST.in) comes first. Text starting with ~/ or / is a path: Tab completes it and goes into folders; ⏎ opens, ⌘C copies the path
@noteSaves the text to the Notes app, in a folder named AllInOneIME (made when missing); nothing is inserted. Pasted text keeps its line breaks, up to 20000 characters
@reminderAdds a reminder to the Reminders app, in a list named AllInOneIME. Write the time in the text; it's read on the Mac, and a row shows what was read: ⏎ or Space adds it, Esc goes back to edit. With a time, it has an alarm then; with only a date, it's all day
@calculateCalculates on this Mac; the result appears in the candidates, ⏎ or Space inserts it: @calculate 23*17 → 391. It also works inside a sentence: @reply the total is @calculate 23*17 dollars
@pyRuns a line of Python (the Mac's python3) and inserts the result: the value of the code's last expression, e.g. @py 2**100, @py import math; math.sqrt(2), or else what it printed. Not offered without python3 (Xcode's command line tools have it)
@jsRuns a line of JavaScript and inserts the same: the value of the last expression or what console.log printed, e.g. @js [1, 2, 3].map(x => x * 2). It uses macOS's built-in JavaScriptCore, so there's nothing to install; it can't read files, reach the network or run other programs
@reportissueReports a problem: opens GitHub's page for a new issue in your browser, what you typed after the command as its title, and "What happened / What you expected" to fill in. It adds the app and macOS versions, your Mac's architecture, the interface and input languages, the installed language packs, which kind of AI provider (and the model, if it's a public one; otherwise "custom"), the action key, and how many custom commands, plugins and extensions you have, never their names, your text, paths or keys. ⏎ (or your action key) first shows all of it in the candidate panel; ⏎ again, or a click on the row, opens the page, where you read it and click Submit (with your GitHub account); Esc goes back. Also in the input menu ("Report an Issue…") and Settings → About
@imessageSends an iMessage: type a name, a phone number or an email (a Chinese name also by its pinyin, in full or the initials) and pick the recipient in the candidate panel (the ones you messaged lately come first; a full number or address works too), then write the message (commands inside it such as @stock AAPL run first). ⏎ shows "Send to Alex (…): message" in the panel, ⏎ again sends it, Esc goes back to editing; nothing is typed into the text field. The first time, macOS asks whether AllInOneIME may access Contacts and control Messages: click OK for both

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.

Typing @ opens the command list; @question plus a question, then ⏎ for the answer

@open finds apps as you type; starting with /, it's a path: the folder is listed, Tab completes

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).

On the selected text (new)

Select some text in any app (a sentence in Notes, a paragraph in Mail), type @improve, @translate, @question or another command that takes text, and press ⏎: the command works on the selection, and the result you pick replaces it. The selection stays as it is, selected, while you type: the command is written in the candidate panel, whose first line is what you type and the next "On the selection: “…” (N characters)". Esc, ⇧⏎ or clicking elsewhere leave the text as it was; so does a selection you change meanwhile, which cancels the command. Text typed after the command is an instruction for @improve and @translate (@translate ja, @improve more formal) and the question for @question (@question what does this mean), about the selection. @open, @claude, @tasks, @settings, @reminder, @imessage, @reportissue, terminal commands and script extensions don't use it: they take what you type, and the selection stays as it is. Up to 5000 characters; never read during secure input or in a terminal. Turn it off under Settings → General → "Use the selected text" if it misbehaves in an app.

Refining the results (new)

While the results of @improve, @translate, @question or a prompt command are up, type what to change, such as shorter, warmer, more formal, add a joke, in Japanese or 用更口语的说法 (pinyin works, and a tap of Shift switches languages), and press ⏎: the results go to the AI again with your instruction, and the new ones replace them in the same panel. Refine again as often as you like; the panel's top line lists the steps ("Refined: shorter · more formal"), and you can pick a row at any time as usual. A letter starts the instruction (shown as "refine › …" at the top of the panel); while it's empty, digits, Space and ⏎ pick as before. Refining starts once the results are complete: typing while the first results still stream in continues the sentence, as before. While a refine runs you can already type the next instruction; the refine goes on, and ⏎ runs the next one once its results are in. Esc clears the instruction, then goes back one step to the results before the last refine (during a refine: stops it), then back to the sentence; ⌫ on an empty line steps back the same way. On selected text, the result you pick still replaces exactly the selection, which stays untouched until then. A refine that fails (or is refused during secure input) leaves the results as they were, its instruction ready for ⏎ to try again. The same refine of the same results is answered from the cache.

Recent questions (new)

@question with nothing typed after it lists your last 5 questions, newest first, with when they were asked ("3 hours ago"). Typing narrows them down: every word anywhere in the question, in any case (Chinese without spaces too). A digit, ↑↓ then ⏎, or a click shows a question's saved answer at once, without going online: Space or ⏎ inserts it, ⌘C copies it, 0 shows the question, R asks it again for a fresh answer, Esc goes back to the list. With no match, or nothing picked, ⏎ asks what you typed. A new answer to the same question, asked again or refined, replaces the saved one.

  • They're kept only on this Mac (see Privacy): not while secure input is on, and never for questions on selected text.
  • Settings → General → "Remember recent questions" turns it off and deletes them (rememberQuestions in the config); "Clear (N)" deletes them.

Notes and reminders

@note makes a new note; its first line is the title. After copying some text, ⌃V after @note (or ⌘V, outside terminals) 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}" }
]
typeWhat it does
promptGoes to the AI with prompt as its instruction; the answer appears in the candidates, to insert or copy (⌘C)
runRuns argv in the background; what it prints appears in the candidates (several lines are inserted as printed, in a terminal as one line). On an error, its last line is shown
terminalRuns argv in a new Terminal window; nothing is inserted
linkPuts the text into the web address url and opens it in the default browser; nothing is inserted
  • {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.

Script extensions

Add your own @ commands as programs: a script in any language (bash, Python, Node, Swift, …) with a few lines of metadata in its comments. Put it in ~/.config/allinoneime/extensions, or in a folder you add under Settings → Custom Commands → Script Extensions. Raycast Script Commands work as they are, and folders that already hold them are found with Spotlight.

#!/bin/bash
# @allinoneime.schemaVersion 1
# @allinoneime.title Flights
# @allinoneime.argument1 {"type": "text", "placeholder": "from city"}
# @allinoneime.argument2 {"type": "text", "placeholder": "to city"}

echo "Flights from $1 to $2"

flights.sh is @flights. Write its arguments after it, commas between: @flights beijing, new york runs it with beijing and new york as $1 and $2 (more commas stay in the last one); a required one left empty says what's missing instead of running. What it prints is used as its output says:

outputWhat happens
insert (default)All of it, and each line, to insert
showShown in the panel as it prints (progress); nothing inserted. Leave the field and it goes on in the background (up to four at once)
listA list in Alfred's Script Filter JSON, run again as you type; picking a row inserts, opens (a web address, file or folder; never something that would run), copies or runs a second step
silentIts last line near the cursor; nothing inserted

A command can also take no input (input none: ⏎ on its name runs it), run in the background and notify you when it's done (the menu bar panel lists it meanwhile), show a status beside its name in the command list, or ask first (confirm). It runs in its own folder with your login shell's PATH and ALLINONEIME_* variables: the interface and input language, the app you're typing in, the text. A bundle is a folder with an extension.json naming its commands: they share code and preferences, which Settings shows (passwords go to the keychain). Settings lists every command with a switch, and the scripts left out with why.

Raycast's modes map as fullOutput → show, compact and silent → silent, inline with refreshTime → a status. The whole protocol is in docs/extensions.md; Examples/extensions has one of each kind. Extensions run code on your Mac: use ones you trust. They run only when you run them (a status or a list as you type it), never during secure input, and stop when the input method quits.

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.

Typing results out

Turn on "Type results out" under Settings → General (typeOut in the config) and a command's result is typed into the app character by character, like a person typing, instead of going in at once; pinyin picks still go in at once. The slider sets the pace, from 6 seconds a character to 40 a second (typeOutRate), and "Speed up and slow down (like a person)" types in bursts of changing pace (typeOutVaries). Esc stops it where it is; any other key types the rest at once.

"Make occasional typos and fix them" (typeOutMistakes) makes it look even more like a person: now and then the key next to the right one, noticed up to three letters later, deleted and typed again; a letter or a space typed twice and deleted; or a short word typed, deleted and typed again. A few in 100 characters, never two close together, and never at the start of a line. In code, web and email addresses and numbers, a typo is only a wrong letter or digit, fixed at once (never a wrong bracket, quote or space, which editors pair or indent on). The wrong letters are neighbors on your keyboard layout (QWERTY, AZERTY, QWERTZ…). Chinese, Japanese and Korean only hesitate (two characters typed, deleted and typed again), never with a wrong character.

In a field that takes typos back (Apple's text views such as TextEdit and Notes, browsers, most editors): typed to the end, or with another key pressed to type the rest at once, the text is exactly the result; Esc (or leaving the field) in the middle of a typo takes the typo out first, so the field holds an exact start of the result. If the cursor moves while a typo shows (a click), the typo is taken out where it was and the rest is typed without typos.

Typos are never made in terminals, nor in apps that don't tell the input method where the cursor is. Each time, the first typo is a plain one (a wrong letter, corrected in one go), until the field has shown it takes a typo back; while a typo shows, the input method checks before every key that the field holds what it typed. A field that ignores where to replace text can't take a typo back: there that first typo stays, so the text ends up one character off (also after Esc or another key), and the app gets no typos again. Settings → General lists those apps under the typos switch; "Forget apps where typos couldn't be fixed" lets them try again.

Per-app settings (new)

Settings → Apps gives an app settings of its own, each optional; what an app doesn't set follows the settings for every app:

SettingFor exampleIn the config
The input language its text fields start inSlack in English, WeChat in pinyininputLanguage
The rewrite styles @improve offers thereMail formal and tactful, Slack casualrewriteStyles
Type results out, or noton in a chat app, off in MailtypeOut
No AI in this app@improve, @translate, @question, @claude and your prompt commands send nothing there and say so; typing and the other commands worknoAI

"Add App…" lists the apps you typed in lately, or picks one in /Applications. The input menu's "This App: " has quick switches for the app you're typing in (No AI, Type Results Out, the language it starts in). In the config they're under appProfiles, by bundle ID: "appProfiles": {"com.tinyspeck.slackmacgap": {"inputLanguage": "en", "rewriteStyles": ["casual"], "noAI": false}}. Bundle IDs match ignoring case (com.apple.Mail is Mail's com.apple.mail). @reportissue counts the apps that set something, never naming them.

  • The starting language works like the default input language: a text field takes it when it becomes active, and a Shift switch then sticks for that app's fields until the setting changes.
  • With No AI, the AI commands stay in the @ list; running one shows the notice and keeps what you wrote. Your own terminal commands ("type": "terminal") run programs, not the AI, so they still work there.
The menu bar panel: frosted glass, with notes, reminders and Claude tasks on cards; a row swiped left shows its Remove button

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: one to five of English, Chinese (pinyin), French, Korean and Hindi, added with + (always there; greyed out at five). A new install starts with English only. New text fields start in the first; tap Shift for the next, in their order; with one, Shift doesn't switch.
    • French types with its own keyboard layout: AZERTY unless you pick another on its card. Its dead keys (^, ¨, `, ´, ~) compose from it too.
    • Korean types Hangul in the 2-set (Dubeolsik) layout, each syllable put together as you type (g k s → 한); Shift gives ㄲ ㄸ ㅃ ㅆ ㅉ and ㅒ ㅖ.
    • Hindi: type the words as they sound in Latin letters and get Devanagari (namaste → नमस्ते). Common words are spelled as Hindi writes them; otherwise Space inserts the first spelling, a digit another, ⏎ the letters as typed, and "." the danda (।).
    • A command's name, @open's text and code (@py, @js) are typed in letters whatever the language; it comes back after the command.
    • @improve keeps a Korean, Hindi or French sentence in its own language, and @translate translates it into your languages (French is told apart from English when it's one of your input languages).
  • Language packs: the app comes with English (and French, which needs only macOS's layout). Chinese, Korean and Hindi are packs you download when you add them: adding Chinese (pinyin) downloads its dictionaries (about 34 MB, 125 MB unpacked) with a progress bar, and pinyin works as soon as it's done, without a restart; Korean's pack (its key table and how jamo make syllables) and Hindi's (its letters and common words) are a few kilobytes. A pack is data only (dictionaries, tables and schemas, never code), listed in a signed index and checked against its SHA-256 before it's used, like plugins. Each language's card shows its pack (version, size, where it came from) with Delete…, and removing the language offers to delete its pack. Updating from 0.6.1 or earlier keeps Chinese without a download: the installer keeps the dictionaries the old version came with.
  • Candidate layout: for picking words, pinyin and Hindi candidates are side by side by default (Horizontal), like the system's own input methods: ← → choose and ↑↓ (or - =) turn the page. Choose Vertical on the Input page, under the input languages, for one under the other (↑↓ choose). The @ command list and the results are always vertical.
  • 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, Hindi, Bengali, Tamil and the other main Indian languages…) and drag them into order. Hindi typed in Latin letters ("aap kaise ho") comes back in Devanagari. @translate writes a line in each, in this order (three versions with only one); the sentence's own language is skipped. A new install translates into the first language in your Mac's preferred languages that isn't English; with English alone, @translate opens this page to add one.
  • Keyboard layouts: French types with the layout picked on its card (keyboardLayouts in the config). For the other languages, under the input method macOS keeps your last Latin layout (AZERTY, QWERTZ, Spanish, US International…), so you type as usual, @ included wherever your layout has it, and dead keys compose in a command's text too (⌥E then E → é, ^ then e → ê). Layouts without Latin letters (Russian, Hindi InScript) can't be used under an input method: switch to them with ⌃Space, or paste (⌃V) or dictate text into a command.
  • @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.

The candidate panel in dark mode

Voice input

Hold right ⌥ to talk

Hold right ⌥ and talk; when you let go, the text is inserted. It's recognized in the language you're typing (English, Chinese, French, Korean or Hindi). 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 is signed with a Developer ID and notarized by Apple, so the first time macOS only asks whether to open an app downloaded from the internet: click Open. (Versions before 0.6.3 weren't notarized: each had to be allowed once in System Settings → Privacy & Security → Open Anyway.)

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) → English → AllInOneIME (it types pinyin too once you add Chinese under Input in its settings).

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.

Updating: Settings → About → Check for Updates. When there's a new version, About says so (and a line in the menu bar panel), with what's new; "Update to " downloads it, checks it against the update information signed with AllInOneIME's release key, installs it and restarts the input method. Your settings, language packs, learned words and extensions stay, and if anything goes wrong the version you had is put back. AllInOneIME looks once a day by itself, in the background (turn it off with "Check for updates automatically" under About); nothing is installed until you click. This works from 0.6.3 on; to update an older version, or if you prefer, install the new version's disk image over it, without uninstalling first. Before upgrading, read the changelog: it has each version's changes and upgrade notes.

Updating to 0.6.3 from an earlier version: 0.6.3 is the first version signed with a Developer ID, so the keychain doesn't yet know it as the app that saved your keys. The first time it needs each key it saved (an API key, the AllInOneIME Cloud sign-in, an extension's password), macOS asks for your login password: enter it and click "Always Allow". It doesn't ask again, also after later updates. Amazon Bedrock's keys are in ~/.aws/credentials, which isn't affected. Accessibility (System Settings → Privacy & Security → Accessibility), which pasting into terminals and reading the selection use, needs one step too: if AllInOneIME is listed, remove it and turn it on again when asked.

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. The app it installs has no Chinese dictionaries (they're the Chinese language pack): an install that had them keeps them as the pack; otherwise make install-pack installs the pack from the checkout's dictionaries, without a download. 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.
The settings window

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".

ProviderDefault modelAPI key
Claude APIclaude-haiku-5-5 (fastest, cheapest; Sonnet 5.5 and Opus 5.5 are more careful but slower and pricier)Claude Console
Gemini APIgemini-3.8-flashGoogle AI Studio
OpenAI-compatibleOpenAI's gpt-6-luna (or gpt-5.4-mini); "Common Services…" has DeepSeek, Qwen, Kimi, Zhipu GLM, SiliconFlow, OpenRouter and Ollama on this Mac: picking one fills in its base URL, then enter its modelThe service's key; set the Base URL to its address, e.g. https://api.deepseek.com/v1, or http://localhost:11434/v1 for Ollama on this Mac
  • 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).

Apple Intelligence on this Mac (macOS 26)

On a Mac with Apple Intelligence (Apple silicon, macOS 26 or later, turned on in System Settings → Apple Intelligence & Siri), choose "Apple Intelligence (on this Mac)" under "AI Provider": no key, no cost, and nothing you type leaves the Mac. It uses the model built into macOS (the Foundation Models framework), with the same instructions and answer format as the other providers, but only the examples written in the sentence's own language (a small model copies an example's language too readily).

…view the full README on GitHub.

// faq

What is AllInOneIME?

A macOS input method with AI commands in every text field: @improve polishes, @translate translates, @question answers, @claude hands off to Claude Code. Also a full pinyin input method.. It is open-source on GitHub.

Is AllInOneIME free to use?

AllInOneIME is open-source under the NOASSERTION license, so it is free to use.

What category does AllInOneIME belong to?

AllInOneIME is listed under other in the Claudeers registry of Claude-compatible tools.

21 views
★ 16 stars
unclaimed
updated about 1 month ago

// embed badge

AllInOneIME on Claudeers
[![Claudeers](https://claudeers.com/api/badge/allinoneime.svg)](https://claudeers.com/allinoneime)

// retro hit counter

AllInOneIME hit counter
[![Hits](https://claudeers.com/api/counter/allinoneime.svg)](https://claudeers.com/allinoneime)

// reviews

// guestbook

0/500

// related in Other

🔓

符合nature论文学术表达和科研绘图的Skill

// otherYuan1z0825/⟨Python⟩★ 54,085◷ Apache-2.0[ claude ]
🔓

Anti-AI-slop design skill for Claude Code, Cursor, and Codex.

// otherNutlope/⟨CSS⟩★ 49,642◷ MIT[ claude ]
🔓

Huashu Design · HTML-native design skill for Claude Code · Claude Code 里 HTML 原生的设计 skill · 高保真原型 / 幻灯片 / 动画 + 20 设计哲学 + 5 维评审 + MP4 导出 · Agent-agnostic

// otheralchaincyf/⟨HTML⟩★ 28,944◷ MIT[ claude ]
🔓

Open source Ghostty-based macOS terminal with vertical tabs and notifications for AI coding agents. Built for multitasking, organization, and programmability.

// othermanaflow-ai/⟨Swift⟩★ 28,842◷ NOASSERTION[ claude ]
→ see how AllInOneIME connects across the ecosystem