Low-key Anki with custom scheduling

This is a page from Digital Words,
which is for the most part written in Hebrew.
Back to: אנקי.
Publication date: 12022-05-03 (HE)
Last update: 12022-05-06
View settings:
  • 🦉 💡
  • 🎨 📖
Contents:
tl;dr: How (and why) to make Anki have a constant ease factor and use only two buttons (fail and pass). This is implemented with the custom scheduling option of the v3 scheduler. The method I propose is reversible, so if you want to return to vanilla Anki, you can do it without losing your ease data.

1. Meta

The fundamental idea for what I propose here is based on Refold’s, MIA’s and Tatsumoto’s notion of low-key Anki. Neither vanilla Anki nor low-key Anki are perfect; before adopting low-key Anki you might wish to read Damien Elmes’s objection to it. Unless you flatten your ease factors using RefoldEase, the method proposed here is reversible, so you can see for yourself what works the best for you 🙂

My implementation, using the custom scheduling ability, is released under CC0/PD. To the best of my knowledge, it should not have any negative effect on your Anki database. Nevertheless, it is provided ‘as is’, and if you choose to use it I am not liable in any way. It is always a good idea to make backups.If you don’t have an up-to-date backup of your entire system, now is a great time to stop reading and to make a backup… IMHO, Borg is wonderful and resistance is futile.

2. Background

2.1. The problem

What choosing the right feedback in Anki (let alone SuperMemo and Mnemosyne) feels like… (source) The fundamental premise of SRS is that the learner should be prompted on cards just before they forget them. For the algorithm to estimate when that happens, it needs input from the learner, who should assess how well they answered the card.This might be rendered unnecessary by mind-reading computers, but these are not available at the moment… This is done by grading one’s answer: Anki presents four optionsThese are ‘again’ if failed to answer correctly, ‘hard’ if answered correctly and it was too hard, ‘good’ if answered correctly and felt the timing was just right, and ‘easy’ if answered correctly and it was too easy., while SuperMemo and Mnemosyne present a whopping six-grade scale (0–5). The constant need to self-evaluate poses two problems.

One is that we as human beings are not as good as we like to think in assessing how well we know things: there is an extensive body of research in psychology supporting the fact that people are not particularly accurate in their subjective judgement of their own knowledge. The four- or six-grade scales are not well-defined, and individuals interpret them differently according to personal and cultural differences of what counts as ‘success’ or the meaning of ‘hard’ and ‘easy’. These differences may result in very different workloads in Anki, which do not necessarily correspond with the individual’s mastery of the material. In extreme (but not so uncommon) cases, this can give rise to the dreaded ease hell: pressing again or hard (in Anki’s scale) too many times, not sufficiently balanced by easy, lowers the ease factorAn ease factor is a number Anki’s algorithm stores for every card. When one chooses again or hard it decreases, when one chooses good it stays the same and when one chooses easy it increases. Broadly speaking, the new interval of a card after rating a card good (the default option) is calculated by multiplying the current interval by the ease factor; if the latter decreases too much (down to 1.30 even), the interval grows very slowly. of the card to a degree it is being shown too frequently, in a manner that is harmful for one’s progress. Here you can read more about the details of Anki’s algorithm, which is not very complex.

The other problem also has to do with the psychology of decision making: decision fatigue. The quality of our decisions deteriorates in long sessions of decision making, which are mentally tiring. When reviewing SRS cards, one has not only to actively recall information, but also to constantly decide what grade should they give to the retrieval of said information. When one reviews hundreds of cards, this technical issue of providing a feedback to the system results in fatigue. I have not used SuperMemo or Mnemosyne, but I can vouch choosing between Anki’s four options (again, hard, good and easy) is demanding, especially when I do it hundred of times a day, every day.

2.2. The solution

A literal ‘low-key’ keyboard… (source) The solution proposed here sacrifices the supposed ability of the algorithm to estimate the best interval for individual cards in favour of having a simpler, more friendly system, which consists of two complementary and interconnected parts:

This decreases significantly the decision fatigue — as a binary choice is much easier than choosing between four or six minute options — and makes it much clearer what the correct feedback should be. Basically, think of two buttons, one red (🟥, ❌, 🙅) and one green (🟩, ✅, 🙆): it’s as simple as it gets, clear cut.

Having a constant ease factor means the algorithm cannot adjust the ease factor of a particular card according to one’s performance on that card. Therefore, a global ease factor for a deck should be picked. The default ease factor in Anki is 2.5That means that each time good is chosen the interval grows by 2.5; for example: 1 day, 2.5~ days, 6.3~ days, 15.6~ days, 39.1~ days, 97.7~ days, 244.1~ days, 610.4~ days, 1525.9~ days, etc. You see how fast it grows: exponentially. This factor is resemblant, but not identical, to the notion of basic reproduction number (R₀) we are all familiar with from COVID-19 epidemiology…, and for many it might be a good rule of thumb to use it. Depending on how difficult what you learn is to you, you might want to set a higher or lower factor. For example, here are my average ease factors for four languages I learn, as well as RTK Kanji cards, before I began to use low-key Anki:

Deck Reading
comprehension
Listening
comprehension
Production Global
Welsh 3.20 3.17 2.97 3.09
Norwegian 3.05 2.98 2.80 2.95
Finnish 2.72 2.70 2.31 2.68
Japanese 2.77 2.73 not enough cards 2.76
Kanji (RTK) 2.41 2.41

If you already use AnkiIf you read this, you probably are…, use the statistics tool in order to get an idea about what ease factors fit the best for your needs (which, as you can see, may vary according the the topic or language). If you don’t use Anki, or if you begin to learn a new topic, 2.5 seems like a relatively low factor for language learning, and 2.75 might be a better choice for that (unless it is a particularly difficult language for you).

2.2.1. Other existing solutions

This is low-key Anki. It is only one possible modification of Anki’s SM-2 algorithm to allow binary feedback. It is the simplest modification, but it sacrifices individual ease factors. Two other solutions are:H/T Reddit.

3. Implementation

If one avoids the hard and easy buttons on vanilla Anki, and uses only again (our fail) and good (our pass), one gets a very similar system to the one describe above, but there is a problem: hitting again on review cards decreases their ease factor, and since we don’t use easy, the ease factor is bound to get lower and lower.

Fortunately, the v3 schedulerSupported on Anki Desktop (2.1.45+) and AnkiMobile (2.0.75+), but not on AnkiDroid at the moment (2022/5). You can still use the proposed method on your desktop and the vanilla Anki algorithm (not avoiding easy) on your Android device. allows users to easily change the way the algorithm works. If you haven’t already, turn the v3 scheduler on: Tools > Preferences > Scheduling > Check V3 scheduler. Then, paste the following code in the custom scheduling textbox in the deck options window (any deck; this is affect all decks):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
 * New card:
 * 	Fail: enter the learning sequence.
 * 	Pass: skip the learning sequence and use the ‘easy interval’ setting.
 */
if (states.current.normal?.new ||
        states.current.filtered?.rescheduling.originalState.new) {
        states.hard = states.easy;
        states.good = states.easy;
}

/*
 * (Re)learning card:
 * 	Fail: reset the (re)learning sequence.
 * 	Pass: progress in the (re)learning sequence.
 */
else if (states.current.normal?.learning ||
        states.current.normal?.relearning ||
        states.current.filtered?.rescheduling.originalState.learning ||
        states.current.filtered?.rescheduling.originalState.relearning) {
        states.hard = states.good;
        states.easy = states.good;
}

/*
 * Review card:
 * 	Fail: enter the relearning sequence with no penalty.
 * 	Pass: multiply the interval by the constant ease factor.
*/
// Code for normal review
else if (states.current.normal?.review) {
        states.hard = states.good;
        states.easy = states.good;
        states.again.normal.relearning.review.easeFactor =
                states.current.normal.review.easeFactor;
}
// Code for filtered decks
else if (states.current.filtered?.rescheduling.originalState.review) {
        states.hard = states.good;
        states.easy = states.good;
        states.again.filtered.rescheduling.originalState.relearning.review.easeFactor =
                states.current.filtered.rescheduling.originalState.review.easeFactor;
}

Using this custom scheduling, hard, good and easy all behave the same (our pass), making no difference in scheduling. I suggest using answering only good (avoiding hard and easy, even though their effect is identical), because in general pass behaves in most cases like the vanilla good.

3.1. Explanation

Let’s see have a look on how the scheduler behaves in each of the following situations:Even if you are not familiar with JavaScript, you can try to read the code above. It is quite simple and straightforward.

That’s it. Now you are all set to use low-key Anki with the modern v3 scheduler.

4. Other issues

4.1. Mouse-free Anki-ing

If you want to use the keyboard more easily, I suggest installing this add-on and using (enter/return) for showing the answer and pass, and ' for failThat is, set "reviewer choice 1": "'" in the configuration window of the add-on.: this way you have the two side by side. If you have audio on your cards, you might want to change the default key (R) to ]Set "reviewer replay audio 1": "]"., so all three are easily accessible using one hand.

If you have a game controller you can use it to input keys using special softwareSuch as AntiMicroX for Linux, Enjoy2 for macOS and AntiMicro for Windows., allowing you to lean back and review comfortably. The Key (source) This is also a great use for The Key keyboard…

4.2. User interface

If you have the next review times shown above the answer buttonsTools > Preferences > Scheduling > Show next review time above answer buttons., the correct times will be shown in Anki’s built-in answer bar, but not in NDFS’s answer bar (the cards are nevertheless scheduled correctly). Anyway, in my humble opinion having the next review times shown is distracting and not helpful in any way; in fact, I use NDFS without an answer bar at allView > ND Full Screen > Answer Button Visibility > Hidden (Reveals on Mouseover)..

Another add-on you might want to consider is this oneH/T Tatsumoto., which allows you to grade a card from the front side (in case the answer is so obvious you don’t need to check it) and show only two buttons.

4.3. Migrating from vanilla Anki

With the proposed implementation, the ease of old existing cards is retained. This way, you can test whether you like low-key Anki or not without loosing your old data.

But there is a problem: if you have existing cards with low ease values they will remain this way (an eternal, inescapable ‘ease hell’…), since the easy option has been removed. This can be solved in two ways.

One approach is to make all of the cards in a deck have the same ease. The RefoldEase add-on provides this functionality, but take note this quite an extreme sudden change to your deck, which is not reversible in case you want to return to vanilla scheduling.

Another, milder approach, which can be used if you are unsure if you want to stick with low-key Anki or not is the following, which does not flatten the whole deck at once but gradually and only if necessary:

To achieve this, change the final part of the code with this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/*
 * Review card:
 * 	Fail: enter the relearning sequence with no penalty.
 * 	Pass: multiply the interval by the constant ease factor.
*/
// Code for normal review
else if (states.current.normal?.review) {
        if (states.current.normal.review.easeFactor < 2.5) {
                states.good.normal.review.easeFactor =
                        Math.min(states.current.normal.review.easeFactor + 0.2, 2.5);
        }
        states.hard = states.good;
        states.easy = states.good;
        if (states.current.normal.review.easeFactor <= 2.5) {
                states.again.normal.relearning.review.easeFactor =
                        states.current.normal.review.easeFactor;
        }
}
// Code for filtered decks
else if (states.current.filtered?.rescheduling.originalState.review) {
        if (states.current.filtered.rescheduling.originalState.review.easeFactor < 2.5) {
                states.good.normal.review.easeFactor =
                        Math.min(states.current.filtered.rescheduling.originalState.review.easeFactor + 0.2, 2.5);
        }
        states.hard = states.good;
        states.easy = states.good;
        if (states.current.normal.review.easeFactor <= 2.5) {
                states.again.filtered.rescheduling.originalState.relearning.review.easeFactor =
                        states.current.filtered.rescheduling.originalState.review.easeFactor;
        }
}

This way the change is not sudden and binding, but gradual. You also get to benefit from the supposedly more accurate values calculated by vanilla ease factor mechanism, but you are not stuck with values which might prove too low or too high. Unfortunately, at the moment I don’t know how can one have different target values for different decks.I guess the current deck is stored in some variable, but I have not troubled myself with finding out what exactly is its name or how to access it… Contact me if you can help with this.

4.4. Migrating from a low-key workaround

Before custom scheduling was introduced, one way to achieve the low-key Anki functionality was a workaround suggested by Refold, MIA and Tatsumoto: setting the starting ease to 1.31 and the interval modifier to 1.92 (1.31 ⋅ 1.92 ≈ 2.5). Because Anki has a lower 1.30 limit for the ease factorYou cannot set the starting ease to 1.30 due of a bug., this provided a way to have a constant ease of 2.5 de facto. It was great for the time before the v3 scheduler, but now we have better options.

If you want to migrate from this workaround, change the interval modifier back to 1.00 and the ease factor to whatever you want (as discussed above). The latter can be altered using the RefoldEase add-on.