togatoga/karukan: a neural kana-kanji input method for Linux and macOS
Japanese Input Method System for Linux, macOS, Neural Kana-Kanji Conversion Engine
At a glance
- What is it?
- Karukan pairs a Rust IME engine with llama.cpp inference over GPT-2/Qwen3 models, shipping fcitx5 and InputMethodKit frontends. The install path is documented per platform, and the first launch downloads a model in the background.
- Who is it for?
- Adopt karukan if you want neural kana-kanji conversion on Linux through fcitx5 or on macOS through InputMethodKit and you accept that the first launch pulls a model from Hugging Face. Do not adopt it if you need a documented rollback path or a stable conversion API: the README points to per-platform install docs and nothing else.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 3 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 17, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What karukan solves, and who it is aimed at
Karukan is a Japanese input method system whose conversion step is a neural model rather than a statistical or rule-based one. The README describes the engine as running GPT-2/Qwen3-based models through llama.cpp, and lists live conversion, context awareness, and conversion learning among its features. The target user is a Japanese typist on Linux or macOS who is willing to run a local model to get conversion quality that a dictionary lookup alone does not produce. The repository is a Rust workspace: karukan-engine holds the core library (romaji to hiragana plus the neural kana-kanji conversion), karukan-im/core holds the shared IME state machine and the macOS JSON-RPC server, karukan-im/fcitx5 is the Linux frontend, and karukan-cli bundles dictionary building, a Sudachi dictionary generator, a dictionary viewer, AJIMEE-Bench, and an HTTP server. That split matters: the conversion model, the input state machine, and the platform glue are separate crates, so the engine can be exercised without a desktop session.
How the engine, the state machine and the frontends fit together
The data flow visible in the repository layout is: a frontend (fcitx5 addon on Linux, Swift/InputMethodKit on macOS) feeds key events into the shared state machine in karukan-im/core, which handles romaji conversion and chunking, and the resulting hiragana goes to karukan-engine for neural conversion. On macOS the core also exposes karukan-imserver, described in the README as a JSON-RPC server, which is how the Swift side talks to the Rust engine. The system dictionary is built from SudachiDict data, and karukan-cli is where dictionary building and the Sudachi dictionary generation live. Candidate rewriting is ported from Mozc: half-width katakana, letter case and width, symbol variants, and numeric notations including kanji numerals, daiji, Roman numerals, circled numbers, and base-16/8/2 forms, each with a Mozc-derived annotation. Emoji input is supported both by kana reading and by a Slack-style colon query. The design consequence is that conversion quality depends on a model file, while candidate breadth depends on a dictionary build step, and the two are configured separately.
Installing karukan on Linux or macOS and typing your first conversion
The README does not inline install commands. It points to two platform documents: karukan-im/fcitx5/README.md for Linux and karukan-im/macos/README.md for macOS. Read the one that matches your platform before doing anything else, because the build steps differ. The workspace declares edition 2024 and rust-version 1.92, so a source build needs a toolchain at least that new. The workspace members are the four crates, and a plain workspace build compiles all of them.
First launch: the background model download
The README carries a note that on first launch karukan downloads the model from Hugging Face in the background. During that download, kana input and dictionary conversion keep working, and neural conversion turns on automatically once the model has loaded. Network access happens only for that first download; later runs use the downloaded model. This is a sensible degradation path, but it also means the feature you installed the project for is not available at the moment you first start typing, and there is no documented way to prefetch the model ahead of a session. The configuration documentation in docs/configuration.md covers config.toml, live conversion, conversion strategy, and the learning cache; live conversion itself is toggled with Ctrl+Shift+L according to the README.
Where karukan is the wrong tool
Two limits stand out. First, the first-run model download is a hard dependency on network access and on Hugging Face availability; an offline machine gets dictionary conversion and no neural conversion, and the README does not document a way to side-load the model. Second, the README does not document rollback or uninstall steps for either platform, so removing the fcitx5 addon or the macOS input source is something you have to work out from the platform documentation. There is also a release cadence signal: the only listed release is v0.1.0 from 2026-02-23, and the last push to the repository was on 2026-09-15. The project is not archived, but a single 0.1.0 release means you are tracking main rather than a versioned line. If you need a conversion engine with a stable published API and a long release history, this is not it yet.
How karukan differs from Mozc
Mozc is the obvious comparison, and the relationship is closer than a simple alternative: karukan ports Mozc's candidate rewriter and derives data under karukan-engine/data from Mozc, distributed under BSD 3-Clause with attribution in THIRD_PARTY_LICENSES. The difference in approach is the conversion step. Mozc converts with a dictionary and a statistical language model, and it is packaged by most distributions as the default Japanese input method. Karukan replaces that step with a neural model executed locally through llama.cpp, and adds context-aware conversion and conversion learning on top. In practice that means karukan asks more of your machine (a model must be downloaded and loaded) in exchange for conversion that the README presents as more advanced. If you want a Japanese IME that is already in your distribution's repositories and needs no model download, Mozc is the lower-friction choice; karukan is for people who specifically want the neural path.
Licence, attribution and what redistribution costs
The workspace is dual-licensed MIT OR Apache-2.0, declared in the root Cargo.toml and backed by LICENSE-MIT and LICENSE-APACHE. That is permissive and standard for Rust projects. The part that needs attention is karukan-engine/data: the README states it contains data derived from Mozc and is distributed under BSD 3-Clause, with per-file provenance and Mozc copyright notices in THIRD_PARTY_LICENSES. If you redistribute a build, ship the third-party notices alongside it, and check each derived file's origin in that file rather than assuming the dual licence covers everything in the tree. This is a description of what the repository states, not legal advice; the notices file is the authoritative source.
Editorial conclusion
Adopt karukan if you want neural kana-kanji conversion on Linux through fcitx5 or on macOS through InputMethodKit and you accept that the first launch pulls a model from Hugging Face. Do not adopt it if you need a documented rollback path or a stable conversion API: the README points to per-platform install docs and nothing else. Verify the fcitx5 and macOS install READMEs for your distribution or macOS version, confirm that Rust 1.92 or newer is available if you build from source, and check the THIRD_PARTY_LICENSES file before redistributing anything from karukan-engine/data.
Frequently asked questions
What is karukan?
Karukan is a Japanese input method system for Linux and macOS whose kana-kanji conversion uses GPT-2/Qwen3-based models run through llama.cpp. It ships an fcitx5 frontend for Linux and a Swift/InputMethodKit frontend for macOS, with a shared Rust engine underneath.
How do I install karukan on Linux or macOS?
The README does not inline install commands; it points to karukan-im/fcitx5/README.md for Linux and karukan-im/macos/README.md for macOS. Building from source requires Rust 1.92 or newer, since that is the workspace's declared rust-version.
Does karukan work offline?
After the first launch it does. The README notes that the initial start downloads the model from Hugging Face in the background, and that this is the only time the network is used; subsequent runs use the downloaded model. While the download is in progress, kana input and dictionary conversion still work, and neural conversion activates once the model loads.
Is karukan related to Mozc?
Yes, in two specific ways. The candidate rewriter is described as ported from Mozc, and karukan-engine/data contains data derived from Mozc distributed under BSD 3-Clause, with provenance recorded in THIRD_PARTY_LICENSES. The conversion engine itself is separate: karukan runs a neural model through llama.cpp instead of Mozc's dictionary and statistical model.
Community notes