Yomikun brings yomichan/migaku-style features to Emacs for learning Japanese.

• Tokenize Japanese text using mecab (supports UniDic and IPAdic dictionaries)
• Color-code words by grammatical type (nouns, verbs, particles, etc.)
• Track learning status of words: known, unknown, learning, ignored
• Look up definitions via tooltip (using myougiden)
• Look up kanji information (using jamdict)
• Detect compound terms
• Generate a frequency-sorted vocabulary report for any buffer or region, with per-status filtering and bidirectional navigation to the source text
• Jump to reference sites (jisho.org, kanjidamage.com)

See a demo here.

1. Install the requirements (see below)
2. Add to your Emacs config:

(use-package emacsql :straight t)
(use-package pos-tip :straight t)
(use-package yomikun
  :straight nil
  :load-path "~/.emacs.d/modules/yomikun"
  :config
  (setq yk-mecab-binary "/opt/homebrew/bin/mecab")   ;; or your mecab path
  (setq yk-mecab-dict-dir nil)                        ;; nil = use default dictionary
  (setq yk-mecab-dict-type 'ipadic)                   ;; or 'unidic
  (setq yk-db-status-file "~/jp-status.db")
  (setq yk-db-dict-file "~/dictionary.db"))

1. Open a Japanese text file
2. M-x yk-minor-mode — parses the buffer and activates keybindings

Yomikun uses mecab for morphological analysis. Two dictionary formats are supported:

brew install mecab mecab-ipadic

Then set:

(setq yk-mecab-binary "mecab")
(setq yk-mecab-dict-type 'ipadic)

Download from MecabUnidic releases. You need the homebrew mecab binary with the UniDic dictionary files:

(setq yk-mecab-binary "/opt/homebrew/bin/mecab")
(setq yk-mecab-dict-dir "/path/to/MecabUnidic/support")
(setq yk-mecab-dict-type 'unidic)

Run M-x yk-doctor to check that mecab, the dictionary, and the databases are all configured correctly.

pip install myougiden

After installation, download the dictionary database as described on the myougiden page.

Verify:

myougiden --human お願い

pip install jamdict jamdict-data

After installation, verify the database location:

python3 -m jamdict info

Look for the Jamdict DB location line. If it says [OK], you’re set.

If JAMDICT_HOME shows [Missing], create the directory and config:

python3 -m jamdict config

The kanji-dict.py script (in ./other/kanji/) needs the database path. If jamdict installed the DB in a non-standard location (common with pip --user installs), edit the path in kanji-dict.py or set:

(setq yk-kanji-dict-command '("/path/to/kanji-dict.py"))

Verify it works:

kanji-dict.py 日本

Expected output: stroke count, grade, frequency, readings for each kanji.

• emacsql and emacsql-sqlite — SQLite database access (emacsql)
• pos-tip — tooltip display near point

Both are available from MELPA.

Copy one of the JLPT word lists from ./db/ as your starting database:

cp db/tangoN5.db ~/jp-status.db

Or create an empty database with M-x yk-db-status-create.

Decompress the quick-lookup dictionary:

bunzip2 -k db/dictionary.db.bz2
cp db/dictionary.db ~/dictionary.db

This database provides fast definitions for the cursor-sensor auto-help feature.

1. Open a Japanese text file
2. M-x yk-minor-mode — automatically parses the buffer, finds compounds, and activates keybindings
3. Navigate the text — unknown words are highlighted with a colored background
4. Mark words as you learn them using the keybindings below
5. Press RET on any word to see its dictionary definition

If the buffer has already been parsed, yk-minor-mode skips parsing and just activates the keybindings.

Marking a word updates its status globally — all occurrences in the buffer change color immediately.

Words are colored by grammatical type:

Unknown words additionally get a pink background. Learning words get a green background. Compound terms are underlined with a red wavy line.

When cursor-sensor-mode is active (enabled automatically by yk-minor-mode), moving the cursor onto an unknown word shows a quick dictionary definition in a tooltip. This uses the quick-lookup dictionary database for speed.

Press R from a parsed buffer to generate a frequency-sorted vocabulary report in *yomikun-buffer*. Each root is listed in descending order of occurrence; under each root, the encountered surface forms (conjugations) are shown indented with their own count, reading (hiragana), part of speech, and dictionary gloss. Every line is coloured by its own per-surface status.

Example layout:

42  食べる
         42  食べる   たべる   動詞   to eat
10  咲く
         10  咲く     さく     動詞   to bloom

If a region is active when R is pressed, only that region is scoped — both roots and compounds are restricted to it, and the report header notes the region bounds.

In the source buffer (with yk-minor-mode active), J jumps the other direction — from the morph at point to its corresponding line in *yomikun-buffer*. Errors if no report exists or the morph isn’t in the report.

All settings are available via M-x customize-group RET yomikun.

Yomikun tracks four learning states for each word:

Words not in the database are treated as unknown.

The status database is a SQLite file with primary key (morph, mtype, surface). Pre-populated JLPT word lists (N3, N4, N5) are available in ./db/.

• Tooltip width may not perfectly match content on macOS Retina displays (pos-tip limitation)
• Processing is synchronous — large files may take a few seconds
• Compound detection requires the dictionary database
• Tested on macOS; should work on Linux

emacs --batch \
  -L . -L tests \
  -L /path/to/straight/build/buttercup \
  -l buttercup -f buttercup-run-discover

Tests require Buttercup. Integration tests require a working mecab installation.