Top Related Projects
Quick Overview
Mozc is an open-source Japanese input method editor (IME) developed by Google. It provides a way to input Japanese text on computers and mobile devices, supporting various input methods and offering advanced conversion features.
Pros
- High-quality Japanese text input with advanced conversion algorithms
- Cross-platform support (Windows, macOS, Linux, Android)
- Customizable dictionary and user preferences
- Regular updates and maintenance by Google and the open-source community
Cons
- Primarily focused on Japanese, limiting its use for other languages
- May have a steeper learning curve for users accustomed to other IMEs
- Documentation and resources are primarily in Japanese, which can be challenging for non-Japanese speakers
Getting Started
To use Mozc on your system:
- Visit the Mozc GitHub repository
- Follow the installation instructions for your operating system
- After installation, enable Mozc in your system's input settings
- Start typing in Japanese using your preferred input method (e.g., romaji, kana)
Note: Specific installation steps may vary depending on your operating system and configuration.
Competitor Comparisons
Rime Input Method Engine, the core library
Pros of librime
- More flexible and customizable input method framework
- Supports a wider range of input methods and languages
- Active community-driven development with frequent updates
Cons of librime
- Steeper learning curve for configuration and customization
- Less out-of-the-box support for Japanese input compared to Mozc
- Smaller user base, potentially leading to fewer resources and tutorials
Code Comparison
Mozc (C++):
// Example of key event handling in Mozc
void Session::SendKey(const commands::KeyEvent &key) {
context_->mutable_keyevent()->CopyFrom(key);
Execute(commands::SessionCommand::SEND_KEY);
}
librime (C++):
// Example of key event handling in librime
ProcessKey(Context* ctx, int keycode, int mask) {
KeyEvent ke{keycode, mask};
return ctx->ProcessKeyEvent(ke);
}
Both projects use C++ and handle key events, but librime's approach appears more streamlined. Mozc's implementation involves more abstraction layers and command structures, while librime's is more direct. This reflects librime's focus on flexibility and customization, allowing for easier integration of various input methods.
maybe a new fcitx.
Pros of fcitx5
- More lightweight and modular architecture
- Supports a wider range of input methods and languages
- Active development with frequent updates and improvements
Cons of fcitx5
- Less extensive documentation compared to Mozc
- Smaller user base, potentially leading to fewer community resources
- May have a steeper learning curve for new users
Code Comparison
Mozc (C++):
class Session {
public:
virtual bool SendKey(const commands::KeyEvent &key, commands::Output *output) = 0;
virtual bool TestSendKey(const commands::KeyEvent &key, commands::Output *output) = 0;
virtual bool SendCommand(const commands::SessionCommand &command, commands::Output *output) = 0;
};
fcitx5 (C++):
class InputContext {
public:
virtual bool keyEvent(KeyEvent &keyEvent) = 0;
virtual void reset() = 0;
virtual void updateUI() = 0;
virtual bool hasFocus() const = 0;
};
Both projects use C++ and have similar class structures for handling input events. Mozc's Session class focuses on key events and commands, while fcitx5's InputContext class provides a more general interface for input handling and UI updates.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Mozc - a Japanese Input Method Editor designed for multi-platform
Copyright 2010-2025 Google LLC
Mozc is a Japanese Input Method Editor (IME) designed for multi-platform such as Android OS, Apple macOS, Chromium OS, GNU/Linux and Microsoft Windows. This OpenSource project originates from Google Japanese Input.
Mozc is not an officially supported Google product.
Build Status
| Linux | Windows | macOS | Android lib |
|---|---|---|---|
 |  |  |  |
What's Mozc?
For historical reasons, the project name Mozc has two different meanings:
- Internal code name of Google Japanese Input that is still commonly used inside Google.
- Project name to release a subset of Google Japanese Input in the form of source code under OSS license without any warranty nor user support.
In this repository, Mozc means the second definition unless otherwise noted.
Detailed differences between Google Japanese Input and Mozc are described in About Branding.
Build Instructions
- How to build Mozc for Android: for Android library (
libmozc.so) - How to build Mozc for Linux: for Linux desktop
- How to build Mozc for macOS: for macOS build
- How to build Mozc for Windows: for Windows
Release Plan
tl;dr. There is no stable version.
As described in About Branding page, Google does not promise any official QA for OSS Mozc project. Because of this, Mozc does not have a concept of Stable Release. Instead we change version number every time when we introduce non-trivial change. If you are interested in packaging Mozc source code, or developing your own products based on Mozc, feel free to pick up any version. They should be equally stable (or equally unstable) in terms of no official QA process.
Release History page may have additional information and useful links about recent changes.
License
All Mozc code written by Google is released under The BSD 3-Clause License. For third party code under src/third_party directory, see each sub directory to find the copyright notice. Note also that outside src/third_party following directories contain third party code.
src/data/dictionary_oss/
Mixed. See src/data/dictionary_oss/README.txt
src/data/test/dictionary/
The same to src/data/dictionary_oss/. See src/data/dictionary_oss/README.txt
src/data/test/stress_test/
Public Domain. See the comment in src/data/test/stress_test/sentences.txt
src/data/unicode/
UNICODE, INC. LICENSE AGREEMENT. See each file header for details.
Top Related Projects
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot