[Userscript] WaniKani Kanji Review Vocabulary List

Somehow or other, I’ve cobbled together my first userscript.


These past few months year, the number one thing I’ve spent my WaniKani time on has been book clubs reviewing the same leeches over and over and over again. No technique has been completely successful at combating these leeches.

However, one recent technique has shown great promise for improving my kanji reviews: adding vocabulary words to the review screen. Having this vocabulary list has doubled to tripled my review accuracy for my kanji leeches.

To streamline this, I’ve put the logic into a userscript. It’s a simple script which alters the kanji review screen to display a list of all of WaniKani’s vocabulary for that kanji.


Install TamperMonkey or a similar userscript extension.

Install WaniKani Open Framework.

Download/install WaniKani Kanji Review Vocabulary List userscript.


Simply do your reviews through the WaniKani web site, and vocabulary words appear below the kanji on kanji reviews.




In TamperMonkey, you can click on the TamperMonkey icon and open the Dashboard. From there, select “WaniKani Kanji Review Vocabulary List” to open the code. Configuration options are near the top of the code:

// Show vocabulary words for meaning/reading reviews.  Must be true or false.
// Limit number of vocabulary words to be shown.  Must be an integer.
// Show locked vocabulary words.  Must be true or false.
// Vocabulary words will be blurred until the vocabuary bar is hovered over by mouse.

Note: If I do any future updates, user-specific configuration setting values will be lost, and will need to be manually set again.


My main experience with Javascript was over 20 years ago, and even then I didn’t know what I was doing with it. For this script, I spent time reading @rfindley’s amazing documentation for their amazing Open Framework, as well as poking around at various userscripts to see how various people did various things. Add in many Stack Overflow results from web searches on how to do every little thing in Javascript, and it seems I ended up with something that works for me.

This script shows all vocabulary for the kanji, even if it’s from a higher level.

I am unaware of the long-term impact on using vocabulary as an aide to recall the reading and/or meaning for kanji. Use at your own risk.


That’s very interesting, Christopher. (I can’t comment on your programming other to be impressed, as I know nothing about such things :slight_smile: )
But I do know your idea definitely reminds me that I too find it much easier to recognise some kanji in context and not when they’re on their own. So it’s tempting, very tempting. But I have a sneaking suspicion that the reason I don’t recognise those kanji is because I’m not taking proper notice of what their shape is. Which perhaps I should make more effort to do. I wouldn’t like to say learning things in context isn’t a good thing (after all it’s pretty much what we all do all the time with words in our native languages). But maybe the fact they’re leechy on their own should be a kick up the rear to me to make a special effort with them. Hmm tricky.
I like it a lot though


Very interesting!
Are the vocab always visible, or only after you answer?
Have you noticed any effect on your non-leeches, too?

Yes, probably so! After drawing the vector-graphics version of the Radicals for Tofugu, it caused me to focus explicitly on how the Kanji are visually composed of the Radicals. I know that’s what they intended all along with their use of the radicals, but doing so descriptively (via the mnemonics), rather than visually, doesn’t encourage you to really look at them that way. But after spending a month drawing Radicals meticulously, it really started to impact how I looked at the kanji… even the ones I had already learned long ago. I actually started being able to write without trying hard, and my ability to distinguish similar kanji – without having vocabulary for context – really improved.

So, in some ways, I suspect that this script will cause the vocabulary context to deemphasize kanji recognition in favor of word recognition, which is probably a double-edged sword: Ultimately, reading by shape-of-word is more efficient, and that’s sort of the goal as you reach fluency. But it may also make that journey a little more difficult as you lose some ability to figure out unfamiliar words because it might be harder recall the individual kanji.

It’s all speculation until proven, though. So, I’m glad (and interested) that it helps with leeches, and I’ll look forward to seeing what the long-term effect will be. (Neuroscience is sort of a hobby of mine).

Anyway… congrats on the nice script! And I’m glad the Open Framework documentation was helpful.


Always. It’d be interesting to try both and see what the results are.

It’s too soon to tell. I haven’t done a new kanji lesson in two and a half months because I’m always busy with reviewing the same leeches over and over.

That is something I plan to be watching for.

Lately I’ve been transcribing a manga that doesn’t have furigana, to force myself to see how well I do on kanji recognition. My number one finding had been that I’m often recognize my leech kanji quickly, both reading and meaning, as I’m seeing it in vocabulary words in the manga. But if the same kanji comes up in isolation in a kanji review a few hours later, nothing. Sometimes it’s as if I’ve never see the kanji before in my life. That’s one of the driving forces to add vocabulary to my reviews.

This is definitely one of my concerns. But when I’ve had many of these kanji moving between Apprentice 1 and Guru 1 and back for the past year, I’m willing to try any new approach.


Sounds like you are approaching it from a good investigative perspective.

If you happen to think of it down the road, tag me with any interesting findings.


This is what I had in mind too.

I’m sure this script will benefit a fair few people, but it’s not one I’d want to use myself.

This is something I can really relate to, and I have yet to find a way apart from writing practice to address this. @rfindley any suggestions regarding this?


Writing is a good option if your number of leeches is small enough .

Beyond that, I’m a firm believer in the brain’s strength at remembering consistent sequences, which may be its most powerful associative cue. I would suggest queueing up a stack of card (physical or anki) where you are exposed to a kanji first, then to 2-3 vocab that use that kanji. Treat it like a quiz, where you have to remember the vocab in sequence after seeing the kanji. Don’t shuffle the order of a kanji and its vocab. But do shuffle each group, so you’re not associating a specific sequence of kanji.

In other words:
1st round: {k1+v1a+v1b}, {k2+v2a+v2b}, {k3+v3a+v3b}, …
2nd round: {k3+v3a+v3b}, {k1+v1a+v1b}, {k2+v2a+v2b}, …

If you find that you associate a particular vocab more strongly with a kanji, put that vocab first after the kanji, because the goal is to recognize where that kanji is used, and you’ll likely remember the other words after recalling the first. (And even if you don’t, that’s probably okay since that’s not the goal).


Cool! I will try this. Although I will probably modify it so that I only see the vocab after an incorrect answer


I’ve done similar, but rather than kanji to vocabulary, it was a constant sequence of similar-looking kanji that I kept getting mixed up. Just my luck, I memorized the order of meanings and soon lost any partial recognition I had of the kanji! Hopefully I’m just the exception that proves the rule on sequential association…

Any brief tips on how to go about this? Like, would you add an array to track which kanji have been seen/misanswered? Or does the page have Javascript tracking your results that you can query?

I’m completely new to writing WaniKani userscripts, so any minor hints may give me a hand up if I later decide to extend this script with configurable options.

1 Like

While WK does store the ID of items that have been partially answered in jStorage, what I did was just check whether the words should be visible every time an answer is submitted. You should look into what WK stores in jStorage. Setting up listeners for when the values change is particularly useful for figuring out when to make your script do something.

Might not be the best way to do it, but it was quick and easy. I just added this to your script

    // Fires every time an aswer is submitted because WK updates the questionCount value
    $.jStorage.listenKeyChange('questionCount', handle_answer)
    // Toggles a class on the #reviews element on and off depending on whether the vocab should be visible
    function handle_answer() {
        // The field containing the user's answer. WK adds a class "incorrect" on this when you answer something incorrectly
        let answer_field = document.querySelector('#answer-form fieldset');
        // WK stores information about the current item in jStorage with the key "currentItem"
        let item = $.jStorage.get('currentItem');
        // If the item is a kanji review and the user answered it incorrectly, then remove the "hidden_vocab_list" class from #reviews
        // Otherwise, add it to #reviews
        $('#reviews').toggleClass('hidden_vocab_list', !(item.kan && answer_field.className == 'incorrect'));
    // Insert some CSS hiding the #vocabulary_list when  the class "hidden_vocab_list" is present on #reviews
    $('head').append('<style id="kanjivocabcss">.hidden_vocab_list #vocabulary_list {display: none;}</style>');

Thanks for the info! It sounds like if I expand this, jStorage will be the next thing to learn a little about.

I see now what you mean about showing after getting a wrong answer. I was mistakenly thinking, “If the kanji is answered wrong the first time, then show the vocabulary underneath when reviewing it the next time.”


For this you would have to store that info yourself. Although, it shouldn’t be too difficult if you set up some listeners on the jStorage keys to monitor and record the changes

1 Like

Actually, that’s exactly what I would expect in that circumstance. The key is to maintain sequence on anything you want associated, and randomize for anything you don’t. That’s the reasoning behind why I advocate for doing an item’s reading-then-meaning back to back, but randomize the items overall in a session.

Where that concept originated: When I first started doing supplemental study on Wanikani, I went to the Level page (which shows all rad/kan/voc for a level), hid the meanings, and worked my way through the grid of kanji as a drilling exercise. It only took about 3 or 4 times through the grid to realize that I was starting to remember the sequence of meanings, so it made sense to randomize the grid each time through. The result was [Self-Study Hide Info].


Oh good, I’m normal!

What you say makes sense.

Yay, that’s how I do my reviews =D

Although, for the longest time I was always doing reading-then-meaning, so about two or three weeks ago I decided switch it up to meaning-the-reading. Since then, every single individual reviewed item, when the card comes up for meaning, I immediately think of the reading. (Even if reviewing 70 items, I default to reading first 70 times in a row.) I’m undecided on whether to just switch it back to reading-then-meaning, or keep trying to break the habit of defaulting to reading first.

1 Like

I do reading first since I consider that the most important. If I get the reading wrong, then reading the correct answer usually jogs my memory for the meaning. If I did meaning first I would be worried about whether I would actually recall the reading when seeing the kanji in the wild


My reasoning for doing reading first is: If you think about it, the ‘meaning’ is actually just the English ‘reading’. The real ‘meaning’ is purely conceptual, but we don’t separate the concept from the reading in English, so we think of it as being the ‘meaning’. So, it made sense to me to put the Japanese reading before the English reading, so the Japanese would be the first thing I think of when I see a kanji/vocab. And eventually you look at 猫 and think ‘neko’ instead of ‘cat’, and that’s when you’re thinking in Japanese instead of translating.


Thanks for this. This might actually be very useful for remembering all the common readings of a Kanji. Right now, I remember the reading taught by WK when I see a Kanji, but using this method of yours, I may be able to remember the rest by considering an answer incorrect if I don’t get all the readings right :thinking:. Another way to do that would be to consider that I got the Kanji wrong if I get even one of the following vocabulary readings wrong.


so glad you decided to do this… woo hoo!!! if this works will be super awesome to kill off leeches!!!

1 Like

I’m going to murder some leeches.


realized I posted on your study thread but for this wanted to post it here…a couple of other possible ideas for leeches and self/other move pairs… could see this sort of method being used for displaying the ‘visually similar’ kanji as well as the self/other move verb pairs… getting more complicated but heck could even add your own non WKvocab and sententeces to something like this (would not be great if it that stuff was lost - but import/export like the leaderboard could work)

this is the first time I’ve actually wanted to see the leeches…part of a regular review (maybe it only adds a 30-60 sec per review but it’s a nice quick vocab review built in to the review cycles and that’s super important for me personally…all those external separate reviews through various additional SRS is just exhausting…and haven’t really worked …and on top of that there are potentially lots of other great possibilities with an approach like this…

fingers crossed this approach works for to squach leechy kanji!

1 Like