MSIME is a pure TSF Chinese and Japanese input method for Windows 10 and 11

One clone gives you the DLL, the Server and the installer

The structural change in this repository is described in one line: the Windows-side first-party source is all in this repository, so a single clone gives you the complete product. The DLL and the Server are still two processes, they are just no longer two repositories.

The table of directories in the README is the best description of the architecture available.

| Directory | Responsibility | | windows/ | The core TSF text service DLL: key prediction, focus, edit session, and the pipe protocol with the Server | | server/ | Server side: algorithm dispatch, candidate window and toolbar host, the settings program, dictionary management | | engine/ | The input engine: input session, candidate query, auxiliary codes, the cross-process contract, the voice module | | ui/ | A self-built native GUI framework, msimeui: a Win32 host window rendering with Direct2D and DirectWrite | | ui-html/ | Interface resources in HTML, CSS and JavaScript: candidate window, floating toolbar, tray menu, settings page | | installer/ | Collects the component artefacts, self-signs, packages with Inno Setup |

There are also log/ for a shared logging library used by the modules, experiments/tsf-edit-control/ for a Win32 TSF edit control experiment with a minimal host demo, vendor/ holding submodules for opencc and cpp-pinyin, and scripts/, tests/, docs/ and product-lock.json described as the product-level build scripts, combination tests, documentation and the external input manifest.

The split into two processes is the interesting part. The TSF DLL is the piece Windows loads into the input context, and the Server is the process that holds the dictionaries and does the heavy lifting, with the two talking over a pipe protocol described in the README as a cross-process contract in the engine directory. So the parts of the input method that must be responsive live in the DLL, and the parts that need memory and dictionaries live in the Server, and the pipe protocol between them is the interface to design against.

The interface is HTML rendered through a hand-written Direct2D shell

The ui/ directory is described as a self-built native GUI framework, msimeui, whose job is a Win32 host window rendering with Direct2D and DirectWrite. The ui-html/ directory then holds the actual interface resources in HTML, CSS and JavaScript, covering the candidate window, the floating toolbar, the tray menu and the settings page.

That combination is unusual enough to be worth understanding. It is not a web view. The project built its own native rendering shell rather than embedding a browser engine, and then expressed the layouts and behaviour of the interface in web technologies on top of it. The result is a native application whose user interface is authored the way a web page is, which is a reasonable way to get a consistent look across a candidate window, a toolbar, a tray menu and a settings page without four separate widget toolkits.

The skins make the same point. The feature list names several, Fluent, WeChat green, Graphite, Willow green, Autumn osmanthus and Microsoft, each supporting a dark and a light variant, and the repository carries a skins/ directory and an examples/skin-examples/ directory for the skin artwork.

The third layer is the engine, and its status is unusual enough to be worth stating plainly. It originated in the separate MSIME-Engine repository and is now a first-class component of this one, at the same level as server/ and windows/, specialised for Windows. The README is explicit about the process: to change the engine for Windows you change it directly, and the engine and the code that calls it are reviewed in the same pull request. The upstream commit and the trimming manifest are recorded in engine/UPSTREAM.md, and product-lock.json no longer locks the engine, it only records the dictionaries downloaded at build time.

Auxiliary codes filter candidates, and letter case decides which one

The auxiliary code system is the most distinctive feature in the documentation, and it is the piece with the most detailed rules. An auxiliary code is an optional shape-code filter appended after a complete pinyin or double pinyin input, and it comes in two forms.

Single code appends one shape code. It mainly reorders rather than filters: for a single character the code matches any of its shape codes, and for a word group it matches the first shape code of the first or last character. Matched candidates are shown first, but the other candidates are still kept.

全拼：aE
双拼：aae 或者 aaK

Double code is a strict filter. The two codes match the character's two shape codes, or the first shape code of the first and last characters of a word group, and only the candidates that match are kept.

全拼：aEK
双拼：aaeK、aaKe 或 aaKE

The case rules are the subtle part, and the README lays them out in a table. In full pinyin the appended codes must be uppercase. In double pinyin the appended single code can be either case, but the case decides which shape code is prioritised. For double codes in double pinyin, a lowercase first code followed by an uppercase second code triggers a normal-order match, while an uppercase first code triggers a reversed-order match whichever case the second code has.

There is a catch the README states at the end of the section: auxiliary codes only take effect when the pinyin before them is complete. If the pinyin is still incomplete, the trailing letters are treated as ordinary pinyin.

The supported auxiliary code schemes are listed as Blue Sky Light Rain, Nature Code, Shouyou 2.0, Shouyou Plus, Xiaohe and PinyinJiaJia, and the feature list says you can also import your own auxiliary code scheme.

Dictionaries are pinned by tag and digest, and one pipeline is already archived

The dictionary story is a good example of a project managing the part of itself that cannot live in the repository.

The README says the dictionaries are taken at build time from the dict-* releases by fixed tag and digest, that the dictionary building pipeline is not in this repository, and that the already archived MSIME-Dict is kept read-only, with its published releases still usable. The engine is in the repository but the words are not, because the words change on a different cadence and come from a different pipeline, and pinning them by tag and digest is what makes a build reproducible.

The same pattern applies to voice input. The standalone tool MetasequoiaVoiceInput has been archived, though its published releases are still downloadable, and the recording, WAV encoding and the recognition and polishing protocol now live in engine/voice/. The repository also carries language-model/ and neural-model/ directories at the top level, alongside the rest.

The result is a repository that contains the code and not the content, with product-lock.json acting as the manifest of what gets fetched. For a contributor that is convenient, because a clone is small and the build pulls exactly the dictionary version it is supposed to. For an auditor it is also workable, since the tag and digest are recorded, but it does mean a build depends on those release artefacts still being reachable.

The installer directory does the packaging, collecting the component outputs, self-signing and running Inno Setup, which is the third-party installer tool the project uses.

The install fails in one specific way when the VC++ runtime is missing

The installation section is short and unusually useful, because it names the failure mode.

After installing, use Win + Space to switch to the MSIME input method. If you cannot switch, if the Server exits repeatedly, or if the settings window flashes and closes, it is most likely a missing Visual C++ 2015 to 2022 Redistributable, and the x64 build is the one that matters. The fix is described in the common questions section of the installation document at docs/installation.md.

That is a specific and useful diagnosis. The symptom described, a Server that starts and immediately exits, is exactly what a missing runtime produces in a Windows application, and the project tells you to install one package rather than sending you to a general troubleshooting page. The x64 qualifier matters too, because a 32-bit redistributable will not satisfy a 64-bit process.

The install artefacts come from the GitHub releases page or from the download page on the project site, and the project publishes the same product for other platforms in separate repositories, with links to MSIME-Apple for macOS and iOS and MSIME-Linux for Linux. That split is a reminder of what this repository is: the Windows product only, and the Windows product is the largest of them, since it carries the TSF DLL, the Server, the GUI and the installer.

The project also has an English README, a user documentation site at msime.app/docs, a privacy statement at PRIVACY.md and a code signing policy document under docs/. The fact that the code signing policy has its own document, and that the project publishes a privacy statement, are two small signals about how the maintainers think about a piece of software that sits in the input path of every keystroke you type.

The hotkey map is the fastest way to learn the feature set

The feature list is long, and the shortcut list is the compact version of it. The README gives a set of single-key hotkeys that work in the Chinese input state.

K for quick phrases, which can optionally be mixed into the candidate list. T for date and time. U for Unicode. E for emoji. M for kaomoji. J for super shuangpin, the abbreviated double pinyin. Y for temporary English. R for temporary Japanese. Separately, Ctrl + Shift + E enters and leaves a standalone English candidate input mode, Ctrl + . switches between Chinese and English punctuation, and Ctrl + Shift + Space toggles full-width and half-width. Vim users can enable automatic switching to English on Esc per application, documented at docs/vim-mode.md.

The candidate paging keys are configurable in the settings, with - and =, , and ., Shift + Tab and Tab, and Page Up and Page Down all selectable, and the up and down arrows moving the highlighted candidate. The Chinese and English states can be remembered per application or unified globally.

The input methods themselves are the wider story. Chinese covers full pinyin, double pinyin with a long list of layouts including Xiaohe, Nature Code, Shoudao, Microsoft, Sogou, Ziguang, Smart ABC, the national standard and PinyinJiaJia, and 86 Wubi. Japanese is entered in romaji with hiragana, katakana and dictionary candidates, and the Chinese layout is remembered when you switch to Japanese and restored when you switch back.

Beyond that, the feature list includes cloud and AI candidates, with Google Cloud candidates and AI suggestions from DeepSeek, OpenAI, SiliconFlow and Groq, Chinese and English translation definitions in the vertical candidate window with a Tencent Cloud machine translation fallback when a local lookup misses, handwriting recognition, an on-screen keyboard, a floating toolbar, clipboard history, and a dictionary manager that can query, add and batch import or export across full pinyin, Wubi and English. The input statistics feature is off by default, records only character counts and active time, and stays on the machine, viewable and clearable in the settings.

GPL-3.0, a privacy statement and a recruiting document for contributors

The licence is GPL-3.0, with the LICENSE file at the repository root and a THIRD_PARTY_NOTICES.txt beside it for the vendored and bundled third-party components, opencc and cpp-pinyin among them. This is a licensing fact rather than legal advice, and for a program that is installed system-wide and sits in the keyboard input path, the copyleft grant is the reason a user can audit what is typing on their machine.

The project states that it will remain 100% open source, now and in the future, and that pull requests are welcome, including ones made with the help of AI, with the only request being friendly exchange. The README is explicit that not knowing TSF or C++ is not a barrier, and it points at a recruiting document that lists the kinds of work available, from curating dictionaries and writing documentation through localisation and compatibility testing to implementing new input schemes.

The issue tracker is organised around who can take what, with four labels described in the README. A good first issue is a small change where the root cause and the fix are already written down. A no-code issue needs no programming at all, such as icon resources, dictionary entries, documentation or research. Help wanted is a clear root cause with a medium-sized change. Needs design means the approach is not decided yet, and the discussion happens in the issue before anyone writes code.

That labelling is a good sign for a project that says it wants contributors, and it is the most actionable thing in the README for anyone who wants to help. The same document set also says to check and test AI-assisted work carefully, and not to leak API keys in pull requests, issues, screenshots or logs.

For maintenance, the repository is not archived, the default branch is develop, and the last push was on 2026-10-19. The recent releases are v0.10.1 and v0.10.0, both on 2026-10-11, and v0.9.5 on 2026-10-05, so the version line is moving quickly, and the project describes the build as an internal test with a Telegram channel and a QQ group for that.

Editorial conclusion

MSIME fits a Windows user who wants an open input method with Chinese and Japanese in one package, who wants the auxiliary code filtering that proprietary Chinese IMEs provide, and who is prepared to install a preview build. It does not fit a user who needs the extra cloud features, since the AI and cloud candidates are optional and depend on third-party services, and it does not fit a Linux or macOS user because this repository is the Windows product only. Before installing, read docs/installation.md, install the Visual C++ 2015 to 2022 Redistributable x64 if the Server exits at startup, and check PRIVACY.md, since the input statistics feature is local but the cloud candidate features are not.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. metasequoiaime/msime-windows on GitHub
3. Project website
4. README
5. Releases