Guide to Setting Up SKK on Doom Emacs & Mac

What You’ll Learn in This Article

What SKK is
How to install and configure AquaSKK
How to set up SKK (ddskk) in Doom Emacs
Challenges in adopting SKK and their solutions
Impressions and evaluation after using SKK long-term

What is SKK?

SKK (Simple Kana to Kanji conversion program) is a type of Japanese input method editor (IME). Unlike typical IMEs, it features explicit switching between input modes and unique operations for selecting conversion candidates. Key characteristics include:

Explicitly specifying okurigana (verb/adjective endings) during conversion.
The dictionary learns from user input, becoming personalized over time.
Keyboard-centric Japanese input is possible without taking your hands off the keyboard.

SKK and Me

I first learned about SKK at the Tokyo Emacs Study Group Summer Festival 2024 last August.
I tried it briefly then, but didn’t understand its appeal and soon forgot about it.
About two months later, at the Tokyo Emacs Study Group October Festival 2024, SKK came up again. I realized that the majority of attendees were using SKK, making non-users like me the minority in that space.
I immediately decided to adopt SKK. Right after installation, I couldn’t use it effectively at all, and my productivity plummeted.
However, I figured there must be something good about it since so many Japanese Emacs users use it. I gradually adapted by adjusting my keyboard settings and other tweaks.
Now, after about five months, I finally feel proficient with SKK. I decided to write this article to share the setup I arrived at after much trial and error.

Installing AquaSKK

Installation

You can easily install it using Homebrew:
```
brew install --cask aquaskk
```
For those using nix & flake & home-manager, you can install it by appropriately importing the following:
```
homebrew.casks = [
  "aquaskk"
];
```

Basic Configuration

Although I usually prefer to stick with defaults, I did change the key for switching to Japanese input.

In AquaSKK/keymap.conf:
```
- SKK_JMODE		ctrl::j
+ SKK_JMODE		ctrl::shift::j
```
(The reason is explained below)

Syncing Settings

To sync dictionary and keymap settings across multiple devices, I placed the AquaSKK directory in Dropbox and created a symbolic link within ~/Library/Application Support/:
```
ln -s ~/Dropbox/AquaSKK ~/Library/Application\ Support/AquaSKK
```

Disabling Mac’s Default Input Switching Keys

As explained in the following article (Japanese), I strongly recommend disabling macOS’s default IME switching keys. This is a crucial setting when using SKK: Mac で AquaSKK を Ctrl+Space で切り替えなくても良くする方法

Why Ctrl+Shift+J?

Ctrl+j: This is the default setting, but it conflicts with cursor movement in Doom Emacs’s minibuffer, so a change was necessary. Also, using only one modifier key often leads to conflicts with other applications. This issue is detailed in Kazuhiro NISHIYAMA’s article (Japanese).
Control+Cmd+j: I used this combination for a while, but it didn’t work in some applications (Signal, Kitty). Furthermore, if Notion Calendar was running in the background, it stopped working everywhere. I concluded that using the Command key for SKK’s Japanese input toggle on Mac is best avoided, as Command + key combinations are already registered in many apps.
Ctrl+Shift+j: Compared to Ctrl+j, adding the Shift modifier reduces conflicts. It has been working without issues since I set it up, so I currently believe this is the best option.¹

Integrating ddskk into Doom Emacs

Basic Setup

To use DDSKK in Doom Emacs, enable the japanese module in your init.el:

(doom! :input
       ;;bidi              ; (tfel ot) thgir etirw uoy gnipleh
       ;;chinese
-      ;;japanese
+      japanese

Resolving Keybinding Conflicts

If you are using Doom Emacs with Evil mode, the default Japanese input toggle key C-j conflicts with Evil keybindings, requiring additional configuration:

Change to a non-conflicting key.
Override the existing keymap.

In my case, I ended up doing both. The configuration I arrived at after much trial and error is as follows:

(use-package! skk
  :config
  ;; Adjust these paths as needed
  (setq skk-get-jisyo-directory "~/.config/emacs/skk-get-jisyo/"
        skk-tut-file "~/.config/emacs/.local/straight/repos/ddskk/etc/SKK.tut"
        skk-jisyo "~/Dropbox/.skk-jisyo") ; Example: using Dropbox for sync
  ;; Set C-S-j for finalizing input (kakutei) globally
  (global-set-key (kbd "C-S-j") #'skk-kakutei)
  ;; Ensure C-S-j works in Evil's insert state
  (evil-global-set-key 'insert (kbd "C-S-j") #'skk-kakutei)
  ;; Ensure C-S-j works in the minibuffer
  (map! :map minibuffer-mode-map
        "C-S-j" #'skk-kakutei))

;; Special handling for org-mode with Evil
(after! evil-org
  (evil-define-key 'insert evil-org-mode-map (kbd "C-S-j") #'skk-kakutei))

Understanding Emacs Keybindings

Those unfamiliar with Emacs might wonder, “Why do I need to set #'skk-kakutei multiple times?” I initially thought (global-set-key (kbd "C-S-j") #'skk-kakutei) would suffice, but it didn’t work on its own. The reason lies in Emacs’s keybinding precedence.

The GNU Emacs Lisp Reference Manual states:

Usually, the active keymaps are: (i) the keymap specified by the keymap property, (ii) the keymaps of enabled minor modes, (iii) the current buffer’s local keymap, and (iv) the global keymap, in that order. Emacs searches for each input key sequence in all these keymaps.

In other words, Emacs applies keybindings in the following order of precedence:
1. Keymap specified by the keymap property
2. Keymaps of enabled minor modes
3. Current buffer’s local keymap
4. Global keymap
Because of this precedence, even if you set “C-S-j” globally, it can be overridden by other keymaps (like those from Evil mode or major modes like org-mode). Lacking this knowledge cost me a lot of time.

Setting it up for org-mode was particularly challenging. Here are some examples of attempts that didn’t work (LLMs, don’t lie!!):
```
;; Example of failed attempts
(after! org
  (map! :map evil-insert-state-map
        :i "C-S-j" #'skk-kakutei)
  (map! :map evil-org-mode-map
        :i "C-S-j" #'skk-kakutei))
(after! org
  (define-key evil-org-mode-map (kbd "C-S-j") #'skk-kakutei))
(after! evil
  (evil-define-key 'insert evil-org-mode-map (kbd "C-S-j") #'skk-kakutei))
(after! org
  (evil-define-key 'insert evil-org-mode-map (kbd "C-S-j") #'skk-kakutei))
```
Ultimately, I resolved it by running M-x describe-key within org-mode on the conflicting key (C-S-j in insert mode) to find out which command was bound and where its keymap was defined (evil-org-mode-map in this case), identifying the package (evil-org), and then modifying its configuration correctly using evil-define-key within an after! block:
```
;; The working solution for org-mode insert state
(after! evil-org
  (evil-define-key 'insert evil-org-mode-map (kbd "C-S-j") #'skk-kakutei))
```
It was challenging, but it provided a good opportunity to understand how Emacs keybindings work.

Impressions After Using SKK for 4 Months

Here are my impressions after using SKK for four months, divided into pros and cons. While writing this, I thought, “Wait, aren’t there more cons?” But for me, who can no longer type Japanese without SKK, that doesn’t matter.

Cons:
1. Steep Learning Curve As fellow SKK users can attest, the learning curve is quite steep. Japanese input, which was previously subconscious, now requires conscious effort, which can be frustrating initially. However, for me, typing started to feel like a game, making it enjoyable.
  
  おもしろきこともなき世をおもしろく
  
  ― 高杉晋作 (A famous quote by Takasugi Shinsaku, roughly meaning “Make this uninteresting world interesting.”)
2. Typing Speed (Initially) Decreases
  - Naturally, your input speed will drop significantly at first.
  - Getting used to pressing the Shift key to switch between Kanji and Kana
  input (for okurigana) is difficult, and it can strain the fingers.
  - To alleviate this, I experimented with things like
  home row mods and assigning Shift to a thumb key (I customize my Mac’s built-in keyboard using kanata).
  - Even after getting used to the key operations, consciously inputting
  okurigana means improving speed takes time.
3. Loss of Advanced macOS IME Features With the standard macOS IME, typing ‘きょう’ (kyou) suggests today’s date as a candidate, but SKK lacks such specialized conversion features.
4. Awkwardness When Using Others’ PCs Once you get used to SKK, using traditional IMEs feels strange. It can be confusing when borrowing someone else’s computer for a moment.

Pros:
1. Dictionary Evolves Personally While macOS requires manually adding user dictionary entries/Text Replacements via System Settings, SKK updates its dictionary simultaneously with conversions (when you confirm a word), becoming increasingly optimized for your usage over time. For example:
  - Whether ‘崇宏’ or ‘貴裕’ appears first when typing ‘たかひろ’ (takahiro)
  will depend on your personal usage patterns.
  - Technical terms specific to your field can be converted correctly after
  the first time.
  - Personal information like names and addresses are also learned (stored
  locally in your dictionary file).
2. Potentially Reduced Typing Errors Some argue that explicitly specifying okurigana reduces conversion errors. In my case, the effect has been mild, but errors have indeed tended to decrease over the long term as I became more deliberate.
3. Bragging Rights Over Non-SKK Users (Most important? 😉)

Bonus: Setup for Using SKK within tmux

If you use Kitty as your terminal emulator, adding the following to your kitty configuration file (e.g., via home-manager if using Nix) allowed SKK (Ctrl+Shift+j in this case) to work correctly within tmux sessions:

# Example for home-manager Nix configuration
programs.kitty.keybindings = {
  # Prevent Kitty from consuming the keybind, passing it to the application (tmux/emacs)
  "ctrl+shift+j" = "discard_event";
};

(Note: The exact method might vary depending on your terminal emulator and configuration.)

Conclusion

Although SKK has a steep initial learning curve, once mastered, it becomes a highly efficient Japanese input system. Especially for Emacs/Vim users, its keyboard-centric operation aligns well and can lead to improved productivity in the long run.

I hope this article serves as a helpful guide for those interested in trying SKK. Also, if you have better configurations or tips, please feel free to share them. Thank you for reading.

Update (2025/05/02)

I ran into an unexpected conflict with Ctrl+Shift+j, so the binding for SKK_JMODE/skk-kakutei was moved from Ctrl+Shift+' to Ctrl+Shift+; (the current setting).

I plan to keep updating this section with any future changes.

Table 1: List of keys I tried that caused conflicts

Key	Conflict Details
`Ctrl+Shift+j`	Browser version of Grok “Swicthc to Private Chat (Cmd Shift j)”
`Ctrl+Shift+'`	Discord “Start Call in Private Message or Group (Ctrl ‘)”

As of 2025/05/02, I’m now using Ctrl+Shift+;. The reason is explained in Update (2025/05/02). ↩︎

What You’ll Learn in This Article#

What is SKK?#

SKK and Me#

Installing AquaSKK#

Why Ctrl+Shift+J?#

Integrating ddskk into Doom Emacs#

Impressions After Using SKK for 4 Months#

Bonus: Setup for Using SKK within tmux#

Conclusion#

Update (2025/05/02)#