OpenVanilla: a Mac input method suite built on a table format you can extend

What the suite is, and what the five built-in methods are

OpenVanilla is an input method suite designed for the Mac, and the built-in input methods are Cangjie, Simplex, Dayi, Array, symbols and Japanese kana, five of them in the sense the documentation counts.

Cangjie is the shape-based method that was designed in Taiwan, Simplex is the phonetic one, Dayi is the other Taiwanese shape-based method, and Array is the array or matrix method. Symbols and Japanese kana are the two lightweight ones that round the set out.

The important part is what the suite is not. The documentation is explicit that OpenVanilla itself is not one input method, but a suite that provides input methods such as Cangjie and Simplex, which is why the whole thing is called OpenVanilla even though it is colloquially known as the vanilla input method. Users can import other input method tables through the preferences and build the set that suits them.

For users of bopomofo, including the traditional form and the automatic candidate selection variant, the documentation points at a separate project, McBopomofo, which is built by the original author's group and provides the automatic selection bopomofo, in the style of the Microsoft new bopomofo or the Han-yin, along with the traditional bopomofo that is colloquially known as the half-bopomofo.

The project keeps a dedication in the README to Li Shih-Chieh, whose name is given as Shih-Chieh Ilya Li with the dates 1973 to 2019, and the readme is marked as commemorating him.

The history is in the FAQ, and it explains the name. The predecessor was input method software called VanillaInput, originally designed in 2004 to replace the traditional bopomofo built into macOS. Because the Cangjie built into macOS at the time did not match many people's habits, VanillaInput later added Cangjie, and then a group of friends extended that architecture into a software project for developing new input methods. Because it is open source and uses an open architecture, it is called OpenVanilla.

The primary language is C++, the default branch is master, and the recent releases are 1.8.7 from 2026-10-19, 1.8.6 from 2026-09-07 and 1.8.5 from 2026-08-29.

Installing it, and the five built-in methods you start with

The installation is a download and a run. You take the latest version from the releases page on GitHub, the browser decompresses the archive, and you see an install OpenVanilla application in it. Running that installer is what puts the input method into the system, and after that it is selected from the input method menu at the top right of the screen, the so-called flag menu.

That menu is where the suite becomes visible. OpenVanilla is not a single entry in it, it is a family of entries, one per input method you have enabled, and the menu is how you switch between them.

On the first install the default input method is Cangjie. From there the user can choose among the built-in methods, or import the ones they need from OpenVanilla preferences, which is the panel that holds the whole configuration of the suite.

The system requirement is macOS 10.15 Catalina or later. That is the only stated requirement, and it is worth checking before downloading, because the input method is installed as a system component and an old release will not install on a current system.

The older releases are also available on the same releases page, and the documentation is careful about them. Versions before 1.0 are old enough that they are not guaranteed to install correctly on a current macOS, and the release notes for each version are the reference. That warning is the reason to install the latest version rather than to hunt for the one you remember.

The licensing is stated in the README as the MIT Licence, with users free to use and distribute the software provided the software is kept intact and the copyright text is not modified, and the full text is in the repository's LICENSE.txt file.

The .cin table format, and where the extra methods come from

The most interesting part of the project is that an input method is a data file, and the documentation treats the acquisition of those files as a first-class question.

The commonly used tables can be downloaded from the project's source repository, in the DataTables directory, and the documentation names four examples: a large set for Cangjie, Cantonese pinyin, the telegraph code, and Wubi. There is also a note that Cantonese has been built in since OpenVanilla 1.3.0, in both the tone-marked and the unmarked versions, and that the Chinese Open Desktop project provides further tables that can be used.

Importing one takes three clicks. You open the OpenVanilla input method menu, choose OpenVanilla preferences, choose to add a new input method, press the import button, and select the .cin file you downloaded.

There is a companion document for making your own table, CinHowTo.markdown, and the documentation is honest about its state, noting that many parts of it are outdated. It also notes what changed in version 1.0: users no longer have to copy files into a specific directory, which has since been renamed, and custom input methods can now be added or removed from the preferences instead.

That change is the design point of the whole project. A table format with an import dialog means the barrier to adding a method is writing the table, not patching a binary and hand-editing a support directory. The format is old, the documentation admits it, and the suite is still built around the idea that a method is data.

The repository holds the tables it uses, with a DataTables/ directory at the top level, alongside Images/, Source/, Packages/, the OpenVanilla.xcodeproj/ project and an OpenVanillaTests/ directory. The presence of a test target for the application is worth noting, and the .swift-format file and the .idea/ directory suggest the project is developed with a current Xcode toolchain.

Uninstalling, and the methods the suite no longer ships

Two FAQ entries are about limits rather than features, and both are the kind of thing a user hits in an afternoon.

The first is the grey icon problem. If an input method works in some applications and shows a grey icon in others, the documentation says this may be a macOS bug, and the fix is to uninstall OpenVanilla completely, log out and back in, and reinstall it. The uninstall procedure is specific: in the Finder you hold the Command key and press Shift and G together, which opens the Go to folder dialog, you enter ~/Library/Input Methods/ and press Enter, and the OpenVanilla folder that appears is dragged to the trash. Logging out of the account and back in then finishes the removal, because the input method is registered with the login session rather than only on disk.

The second is the list of methods the suite used to support and no longer provides, with the alternatives named. The bopomofo methods, both the automatic selection and the traditional one, are replaced by McBopomofo. Tibetan is built into macOS. For POJ, the documentation points to the Sinswai Taigi Hakka and Taiwanese input method or the Taiwanese Ministry of Education Taiwanese Hokkien input method, both of which have Mac versions, and it also mentions the RIME-based MoeTaiji method. For 嘸蝦米, users are sent to that project's own website for the Mac version.

The unifying theme is that OpenVanilla stopped being a place where every Chinese input method lived and became a platform for table-based methods, with the non-table ones handed to their own maintainers. That is a coherent line, and it is the same line the table import and the preferences panel draw: if it is data, the suite can carry it, and if it is not, somebody else should.

Building a new input method on top of it, and the two things you must change

The final FAQ entry is the most technical and the most useful for anyone who wants to extend the project, and it lists two requirements that are easy to miss.

The first is that you change three values in Info.plist: CFBundleIdentifier, CFBundleName and InputMethodConnectionName, to avoid conflicting with OpenVanilla itself. The reason given is that if you do not, installing OpenVanilla and your own modified input method on the same Mac may lead to the system being unable to identify the input method correctly, which causes it to be unusable, and in some cases to fail to install at all.

That is a specific and plausible failure. The input method is identified to the system by a bundle identifier and by a connection name, and macOS uses the input method connection name to route keyboard events to the right input method. Two of them claiming the same name is a conflict the system has no way to resolve, and the symptom, an input method that appears greyed out in some applications, is exactly the symptom the other FAQ entry describes.

The second requirement is to remove the built-in version update mechanism. OpenVanilla has one, so users can upgrade to the latest version, and if you build your own input method on top of it you must remove that mechanism, because otherwise your input method will use OpenVanilla's update checker and will report updates that belong to a different piece of software. The documentation points at the UpdateChecker code as the reference.

Building the project itself needs the source from GitHub and the latest Xcode, and you open the OpenVanilla.xcodeproj project and use the Build command, which produces OpenVanilla.app. There is a caution attached: that target does not install the input method automatically, and therefore will not overwrite your existing version. To install, you build the OpenVanillaInstaller target, which automatically builds the OpenVanilla target it depends on, and then run the installer.

For anyone who wants to contribute, the project points at the source on GitHub and at the issue tracker and the Google Groups forum for questions, and the identifiers that matter in the process are these:

OpenVanilla.xcodeproj
OpenVanillaInstaller
UpdateChecker
CFBundleIdentifier
CFBundleName
InputMethodConnectionName

Editorial conclusion

OpenVanilla is worth installing if macOS does not give you the input method you need, because the suite covers five built-in methods and accepts any other as a .cin table imported through the preferences panel, so a method that is not built in is a file rather than a patch, and because the project publishes the tables it uses and the format documentation, so a custom method is a documented exercise. It is the wrong tool if you are on a platform other than macOS. Before you install it, check three things: that your system is on macOS 10.15 Catalina or later, which is the stated requirement, and that you accept the manual install step, since the archive contains an installer you run yourself and the input method then appears in the flag menu at the top right of the screen; that you know how to remove it, because uninstalling means opening ~/Library/Input Methods/ in the Finder, dragging the OpenVanilla folder to the trash and logging out and back in, and a reinstall without a clean uninstall can leave the system unable to identify the input method; and that you read the section for developers before you fork it, because the bundle identifier, the bundle name and the input method connection name all have to be changed, and the built-in update checker has to be removed, or your method will collide with OpenVanilla on the same machine and will also report updates that are not yours.

Frequently asked questions

Official sources

1. Issues
2. openvanilla/openvanilla on GitHub
3. Project website
4. README
5. Releases