Skip to content
Custom stenographic theory designed from scratch for the Japanese language.
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.
plover_japanese System overhaul complete Feb 24, 2019 Fixed kanji layout image link Feb 24, 2019
ZhengMa.txt Moved ZhengMa file Feb 24, 2019
setup.cfg System overhaul complete Feb 24, 2019
tox.ini System overhaul complete Feb 24, 2019

WIP ⚠️

(Japanese translation coming soon)


Due to the nature of Japanese orthography, creating an efficient stenographic input method is quite challenging. There are several existing methods, such as stenoword, sokutaipu, and caver. However, all these systems have issues dealing with kanji efficiently, due to the phonetic ambiguity inherent with kanji. To counteract this, these steno systems often rely on methods such as selecting ambiguous kanji from a list, and/or having a second individual to deal with fixing the kanji as someone else writes phonetically. Requiring a second user makes it infeasible for an individual to use the system in other situations, and selecting candidates from a list slows down the pace of the writing, and makes it harder to keep up with real-time speech while still having reliable accuracy. I see this as inelegant, and felt there must be a better way of handling kanji input. This project is my proposed solution.

This project is intended to be used with the open source steno software known as Plover. You can learn more here:

Here is an image of the layout:


How it works

The layout is broken into two parts: The left and right banks, used for typing, and the thumb keys, which act as modifiers. This is the first major distinction from other systems, which often use the thumbs to represent characters, typically vowels.

The banks are divided such that the inner two fingers on each hand type the consonants (except for the case of typing あ), while the outer two fingers on each hand type the vowels. If no vowels are chosen, it defaults to the "a" vowel sound. Each hand can individually type any kana character, allowing you to type two characters per keystroke. The chart for the syllables is shown below. All the combinations shown are mirrored on the right side as well. Pressing the small "っ" button will append it to the syllable, indicating double consonants.

The top row is for number keys. To get numbers higher than 4, you press the keys that add up to the desired number. For example, "1" and "4" in one chord will give you "5". Hitting all buttons at once (1234), will give you "0", rather than "10". Since this design is on both sides, you can type two digits per chord.

"た"            => "た"
"な"            => "な"
"か"            => "か"
"さ"            => "さ"
"い"            => "い"
"う"            => "う"
"お"            => "お"
"っ"            => "っ"
"いうお"        => "え"
"うお"          => "ゃ"
"いう"          => "ゅ"
"いお"          => "ょ"
"かさ"          => "は"
"たか"          => "ま"
"たな"          => "ら"
"なさ"          => "や"
"なか"          => "わ"
"たさ"          => "ざ"
"たかさ"        => "が"
"たなさ"        => "ば"
"たなか"        => "だ"
"なかさ"        => "ぱ"
"たさい"        => "じ"
"たなかい"      => "ぢ"
"たなかう"      => "づ"
"なかいお"      => "ん"
"たなかさ"      => "あ"
"かい"          => "き"
"さい"          => "し"
"たい"          => "ち"
"ない"          => "に"
"かさい"        => "ひ"
"たかい"        => "み"
"たない"        => "り"
"たかさい"      => "ぎ"
"たなさい"      => "び"
"なかさい"      => "ぴ"
"かう"          => "く"
"さう"          => "す"
"たう"          => "つ"
"なう"          => "ぬ"
"かさう"        => "ふ"
"たかう"        => "む"
"なさう"        => "ゆ"
"たなう"        => "る"
"たかさう"      => "ぐ"
"たさう"        => "ず"
"たなさう"      => "ぶ"
"なかさう"      => "ぷ"
"かいうお"      => "け"
"さいうお"      => "せ"
"たいうお"      => "て"
"ないうお"      => "ね"
"かさいうお"    => "へ"
"たかいうお"    => "め"
"たないうお"    => "れ"
"たかさいうお"  => "げ"
"たさいうお"    => "ぜ"
"たなかいうお"  => "で"
"たなさいうお"  => "べ"
"なかさいうお"  => "ぺ"
"かお"          => "こ"
"さお"          => "そ"
"たお"          => "と"
"なお"          => "の"
"かさお"        => "ほ"
"たかお"        => "も"
"なさお"        => "よ"
"たなお"        => "ろ"
"なかお"        => "を"
"たかさお"      => "ご"
"たさお"        => "ぞ"
"たなかお"      => "ど"
"たなさお"      => "ぼ"
"なかさお"      => "ぽ"
"かうお"        => "きゃ"
"さうお"        => "しゃ"
"たうお"        => "ちゃ"
"なうお"        => "にゃ"
"かさうお"      => "ひゃ"
"なかうお"      => "みゃ"
"たなうお"      => "りゃ"
"たかさうお"    => "ぎゃ"
"たさうお"      => "じゃ"
"たなかうお"    => "ぢゃ"
"たなさうお"    => "びゃ"
"なかさうお"    => "ぴゃ"
"かいう"        => "きゅ"
"さいう"        => "しゅ"
"たいう"        => "ちゅ"
"ないう"        => "にゅ"
"かさいう"      => "ひゅ"
"たかいう"      => "みゅ"
"たないう"      => "りゅ"
"たかさいう"    => "ぎゅ"
"たさいう"      => "じゅ"
"たなかいう"    => "ぢゅ"
"たなさいう"    => "びゅ"
"なかさいう"    => "ぴゅ"
"かいお"        => "きょ"
"さいお"        => "しょ"
"たいお"        => "ちょ"
"ないお"        => "にょ"
"かさいお"      => "ひょ"
"たかいお"      => "みょ"
"たないお"      => "りょ"
"たかさいお"    => "ぎょ"
"たさいお"      => "じょ"
"たなかいお"    => "ぢょ"
"たなさいお"    => "びょ"
"なかさいお"    => "ぴょ"

As I currently understand it, Japanese people tend to speak at a rate of about 300 characters/mora per minute. This translates to 5 per second. Since we can type two characters in a single keystroke, this translates to 2.5 keystrokes per second for phonetic real-time transcription speed, which is quite reasonable, especially since this doesn't even take briefs into account. However, kanji can also slow down or speed up this process depending on how many there are, and depending on the readings of those particular kanji (whether they're single syllables or multiple).

As for the thumb keys, the leftmost button is used to indicate a chord for a kanji character. Any chord containing this key will cause the chord to be interpreted as a kanji character rather than as kana. The two middle keys with brackets are used to indicate the start and ends of briefs. If it's a brief that spans multiple chords, you use the left one in the first chord, and the right one in the last chord. If it's a single chord brief you press both at the same time. The rightmost button is to indicate that your stroke should be interpreted as katakana instead of hiragana.

When using a kanji brief, the keys change what they represent. The method behind how the keys translate to kanji is based on the Chinese Zhengma input method. Each character is encoded with 4 or fewer lowercase alphabetical characters. The chart used for this task is given below. There are 26 characters in the latin alphabet. Each finger has 5 possible inputs given the 3 buttons in each column. One finger selects a group of 5 characters, and the other finger selects which character within that group to select. To select "z", you select the final group, but don't select a number. This lets you type any alphabetical character with 2 fingers. Spread across your 8 fingers, and that allows 4 characters in one chord, enabling you to type any character encoded by the Zhengma input method. The rules for how each character is given its encoding is described on the following page (English):

At the time of this writing, there are 3,183 unique kanji defined in the provided dictionary, and only 123 conflicting encodings. I have resolved them by adding the * to the less commonly used character.


Using just the kana and kanji input described so far, you can theoretically type Japanese in real-time without needing any briefs. However, defining briefs can be very useful and enable you to go faster, or keep up with slower finger speed.

Briefs can be done in a single chord of two syllables, or in a series of chords for more syllables, depending on how you use the brackets described earlier. If you have a brief that conflicts with other words you also want to brief, there are several ways to eliminate the ambiguity. If one word is foreign, you can use the katakana key within the stroke or strokes to indicate it should be interpreted as a foreign word. If the conflict is only between two words, where both are native or both are foreign, you can use the asterisk key in the middle to mark the less commonly used one. If the conflict is more widespread, you can choose to use kanji characters as well. The brief could be a single character, several characters, or a phonetic word followed by a relevant kanji character or radical to disambiguate the meaning. These options should be sufficient for dealing with an arbitrarily large dictionary of custom briefs, as you can always disambiguate in one way or another.

You can also define briefs for other things, such as English text, punctuation marks, special characters, keyboard shortcuts, and much more. Any unicode character or sequence of key inputs from a traditional keyboard can be mapped to a chord in your dictionary.

Using an IME

If learning direct kanji input seems intimidating to you and you're not too concerned with reaching real-time transcription speed, don't worry, you can choose to use the kana input with Google IME instead. I've included several briefs for controlling the IME in the "JP_Briefs.json" file. You could even mix it with your kanji input practice until you feel comfortable enough to abandon it entirely. The choice is yours.

First you'll want to install Google IME. You can download it from here: Once installed, go into the preferences and change the input method from Romaji to Kana.


    "-う": RIGHT
    "-な": LEFT
    "-か": UP
    "-さ": DOWN

    "-た": SPACE (Converts input into blocks, and let's you navigate to each block and select separate candidates for each one)
    "-っ": ALT + ` (Switches between direct input and hiragana)
    "「-」": RETURN (Select candidate)

How to install

Open a terminal and navigate to the folder where plover is installed (For me that would be C:\Program Files (x86)\Open Steno Project\Plover), and use the following command: plover_console.exe -s plover_plugins install

Restart Plover, press the "Configure" button, go to the "Systems" tab, and now "Japanese" should be a selectable option.

How to contribute

Here's how you can submit your own additions to the dictionary:

For kanji, first check to make sure the kanji you want to add is not already defined. If it isn't, try searching in the provided zhengma dictionary file to see if it already has a code attached to it. If it is not defined there, then you may proceed with making your own encoding. Make sure it's only 1 kanji character per definition, and make sure they're all 1 single chord. Also make sure they don't conflict with other characters. If there is a conflict, try to resolve it by adding an * to the less commonly used character. Follow the rules described on this page: to ensure the encoding rules are consistent with everything else. Add your definitions to "JP_Kanji.json".

For briefs, if it's an ambiguous word, try to make them simple and logical, while avoiding conflicts. Add them to "JP_Briefs.json".

"JP_Base.json" is used for the base phonetic dictionary. If you have ideas for improving it, modify the "dictionary.jl" file, and run it to generate a new version, and issue a pull request. You will need Julia installed to modify and run it. Download it here:

If you have general ideas and concerns, feel free to open an issue about it.

You can’t perform that action at this time.