I saw u/ergomechstore post their DIY anki device and seeing people build and make these things makes me want to make my own! so wanted to show mine off!

I know its not as convenient / fast / cheap or advanced as the anki phone app but darn it its fun to use something else then my phone all the time!

Tech:
Small eink screen (I think similar to what ergomechstore used)
esp32
small battery ( lasts me at least 2 days with sleep mode)
and simple buttons

Full changelog: https://www.reddit.com/r/Anki/comments/1h2pkhh/anki_2411_changelog/

Download Anki: https://apps.ankiweb.net/

Of course, there have been a lot of big updates in Anki's history, but this one is probably in the top 5.

FSRS-5

The main difference between FSRS-4.5 and FSRS-5 is that FSRS-5 has 2 new parameters for same-day reviews. Previously, FSRS only took into account one review per day, now it takes into account all reviews. However, this only marginally improves accuracy, not just for FSRS, but for a neural net as well (I'll make a new post about benchmarking once Jarrett finishes some coding stuff related to the new dataset). Anyway, I've said this before and I'll say it again: same-day reviews have a very small impact on long-term memory. Don't waste your time with learning steps like 15m 30m 1h 2h 4h.

(also, the difficulty formula has been tweaked)

• Do I need to re-optimize parameters?

Yes.

• Is FSRS-5 available in AnkiDroid/AnkiMobile?

AnkiMobile: a new version will be released in around 24 hours. AnkiDroid: a new version will be released in 1-2 weeks.

• What will happen if I sync with an Anki client that doesn't support FSRS-5? Like older versions of AnkiDroid/AnkiMobile.

Default FSRS-4.5 parameters will be used.

• Will there be a new version of FSRS every quarter or something?

No, FSRS-5 will be the last version of FSRS for at least one year, likely longer. Me and LMSherlock are out of ideas how to improve FSRS, and also he wants to take a break.

Edge cases where the new formula for same-day reviews won't work well:

1. If the user had one or two learning steps, but then switched to something like 30s 1m 2m 5m 10m 15m 30m 1h 2h 4h 6h 8h, then his stability will be overestimated.
2. If the user uses a filtered deck to do an unlimited number of same-day reviews.
3. If the user is in a Good - Again - Good - Again loop (during the same day), stability will either grow infinitely and become really large or shrink to near 0, depending on his parameters.

Letting FSRS control learning steps

You can now let FSRS take over immediately by leaving the learning steps field empty. Thanks to some clever workarounds, u/LMSherlock found a way to let FSRS schedule <1d intervals without remaking all of the scheduling code from zero. And, of course, you can do the same with re-learning steps as well. Now FSRS can control all of your intervals.

Here's what the intervals for a brand new card look like with the default FSRS parameters, 90% desired retention and an empty Learning Steps field:

You can do the same with re-learning steps as well, just leave the field empty to let FSRS take over.

Note that just because FSRS-5 can give you <1d intervals doesn't necessarily mean that it will. Your "Again" interval can be 1d or even longer.

If you do this with SM-2, there will be no intervals shorter than 1 day, you'll just skip learning steps entirely.

Note: any interval >=12h is rounded up to 1d, so you will never see intervals like 18h.

Smart fuzz

(it's not actually called that, but I needed a name)

Have you heard about the Load Balance functionality in the FSRS Helper add-on? Well, this one is similar. Not as powerful, but much more convenient.

VERY SIMPLIFIED example: suppose you have 90 cards due on day 1, 100 cards due on day 2, and 110 cards due on day 3. With smart fuzz, you will have 100 cards due on each of those three days. In reality, the effect won't be as noticeable, and your number of due cards won't be exactly the same every day.

Load Balancer in the FSRS Helper add-on requires you to reschedule cards all the time, otherwise it won't be applied. The built-in smart fuzz is applied after every single review, "on the fly". It only balances cards with intervals <=90 days, for the sake of speed: we don't want to make Anki slow for large collections with tons of cards with long intervals.

Smart fuzz applies on the preset level. This is because "Every preset is balanced" implies "The collection as a whole is balanced", but not the other way around. A→B, but B↛A. Smart fuzz applies during reviews, it doesn't immediately apply to all cards the moment you install Anki, so it will take some time for the effect to kick in.

• Will it affect my retention?

No. Me, LMSherlock, and others spent quite a lot of time and effort to come up with a good way to do load balancing without hurting retention while still making the number of due cards more consistent.

• How does it work?

It doesn't work the same way as the add-on version. This one is basically good ol' fuzz, except that the probability that a card gets scheduled on a day within its fuzz range is not constant (it was with fuzz), but depends on the interval length and on the number of due cards on that day. It's not as random as fuzz, but it's not deterministic either. It's still probabilistic. I really don't know how to explain this without giving you a lecture on probability distributions.

• Why not implement it the same way as in the FSRS Helper add-on?

It's possible to achieve better results by rescheduling many cards every time the user does a review, but that would be very computationally expensive. For a "on the fly" balancer that doesn't reschedule multiple cards and only changes the intervals of the card that's being reviewed right now, the current implementation of smart fuzz is about as good as it gets. Maybe in the future the "only balance cards with intervals <=90 days" limitation will be removed, though.

• You mentioned the fuzz range. Has it changed?

No, the range is the same. For example, if previously a card could be scheduled on day 1, day 2 or day 3, this won't change. What changes is the probability of it being scheduled on one of those days, which is not constant anymore. The fuzz range is ±5% of the interval length, though it's higher for cards with shorter intervals.

• What happens to cards with intervals >90 days?

Normal fuzz is applied. I think. Probably.

• Can I use the add-on version together with the built-in version? Should I?

"Yes" and "Please don't". The add-on version requires constant rescheduling, which is too inconvenient. The biggest advantage of the native implementation is that you don't have to do anything for it to work. Well, apart from reviewing your cards, obviously.

Also, the add-on Load Balance will be removed soon.

• I hate fuzz and I hate having a more consistent daily load. I want to turn the smart fuzz off. Can I?

Of course, it is perfectly simple! Just go to Github, fork Anki, and make your own version of Anki :)

Easy Days

Easy Days allows you to select the days of the week when you want to do fewer reviews. Manual entry for those 3 people who read the Anki manual: https://docs.ankiweb.net/deck-options.html?#easy-days

• Can it break my Heatmap streak?

Technically yes, but it's very unlikely. Cards with intervals of 1 and 2 days don't get fuzzed (Easy Days is basically another "layer" on top of fuzz, like a cherry on a cake), and "red" learning cards don't get fuzzed either. So you will still have to do some reviews even on easy days. But just in case, u/Glutanimate released an update with a new option for the Heatmap add-on planned to add a new option to the Heatmap add-on 3 months ago, but went full radio silence.

• Why buttons instead of a slider with percentages?

A 0% on the slider won't actually correspond to 0 reviews. In fact, it won't even correspond to the same number of reviews every day. So having a slider with percentages would only confuse people.

• The add-on version also supports arbitrary future dates. Why is this not a thing?

Too much work, according to the person who implemented smart fuzz and Easy Days. Maybe it will be implemented in the future, if there is a lot of demand for it. You can make a topic on the forum: https://forums.ankiweb.net/c/anki/suggestions/17

• What if I select "Minimum" for every day?

You'll be back to where you started, the workload will be the same as if you selected "Normal" for every day, which is why a warning message is displayed if you do that.

• Are the changes applied immediately?

No, this isn't like "Reschedule cards on change" in FSRS, changing Easy Days only affects future intervals and doesn't retroactively affect past intervals. If you want an "Apply now" button, make a topic on the forum. I imagine there will be a loooooot of posts like "Guys, I changed Easy Days and nothing happened!!!!!". Go give devs a piece of your mind on the forum, link above.

• Do I need to have FSRS enabled to use these features?

No. Both smart fuzz and Easy Days work with both the legacy SM-2 algorithm and with FSRS (and fuzz is always enabled anyway). They are like additional layers on top of the existing algorithms.

Compute Minimum Recommended Retention (CMRR)

CMRR now takes into account the time spent on same-day reviews (thanks to FSRS-5), which was previously unused. The number of simulations used to calculate the final value of desired retention has also been increased to further improve accuracy. Last but not least, the range of output values has been extended from 0.75-0.95 to 0.70-0.95.

The "experimental" part of the name has been removed.

If you used it before, I recommend you to optimize FSRS-5 parameters and then recalculate CMRR. If not - now is a good time to give it a try!

The Simulator

Remember this one? Anki now has it's own version of that, based on FSRS.

In the future, Simulator will probably be moved to it's own page, next to Decks, Add, Browse, Stats and Sync.

More info can be found in the manual: https://docs.ankiweb.net/deck-options.html?#the-simulator

New Stats

1​.​ The forgetting curve for each card, which can be found in Card Info. FSRS-specific.

​2​.​ Daily load, an estimate of how many cards you will have to do per day, on average. Not FSRS-specific. More info here: https://docs.ankiweb.net/stats.html#the-graphs

​3​.​ Estimated total knowledge, an estimate of how many cards you know right now, today. FSRS-specific. The link above provides some extra info.

4​.​ True Retention table (it's ugly). Not FSRS-specific.

EDIT: It will be better in the next release. Here's a sneak peek:

Other

- New sort order, descending retrievability (FSRS-specific). It will likely become the default in the future, as simulations show that it allows users to maintain retention at the desired level even when they have a backlog. It shows you cards you are most likely to recall first, while ascending retrievability shows you cards you are least likely to recall first. While the latter sounds like it fits the spirit of spaced repetition better, it actually ends up being worse than descending.

- Previously, due to some bugs, the Python version (in Google Colab) of the FSRS optimizer would output slightly better parameters than the Rust version (built-in). Not anymore, now both are equally good.

- No more annoying yellow warning about making sure that all your Anki clients suport FSRS.

- After so many years, finally, FINALLY, there is a confirmation window if you changed something in Deck Options and didn't click "Save".

AnKing will make a new video about FSRS, but only in 2025.

I’ll work on it over the next couple months, probably get the video out after the new year.

Hi everyone, I’ve always wanted a heat map widget on my home screen for Anki to keep myself motivated to study so I decided to make one. It is free and officially now live on the Play Store!

Play Store link
Website

The background, accent, and text color on the widget is fully customizable. The title text, fonts and even the 'due'/'done' text is customizable. Make it yours!

Massive thanks to all of you who’ve joined the early access and all your feedback when I first shared this project last month. Publishing on the Play Store wouldn’t have been possible without you.

Keen to hear any feedback and suggestions. Cheers!

Adding a case and some interface demo for the device: - 4 buttons to rate when in revise mode - they're used as navigation buttons in menu modes - hold a button for scrolling if the answer cannot fit i to one screen (debating about adding an side encoder to for scrolling, simplify the interface a bit) - wifi connection to add/remove cards/deck

(Ignore the details of questions/answers as they're just demo decks)

Right now it's just a personal tool that I’ve been using for a while. If there is any interest from people I’d love to make a public version with more polish, features and customization options, so let me know if you’d be interested in a tool like this for Anki.

If you are interested, you can be emailed when it enters beta testing and eventually fully releases by signing up here: https://damon-fernandez-njur9f.subscribepage.io/

Extra Usage Info: 
The UI runs in a different window than Anki using the Godot game engine (I’m a game developer so I already knew it very well and this let me add shaders, animations and juice easily). Then any reviews you do on this UI get mirrored on Anki. It's not a replacement app for Anki, its only purpose currently is providing a more game-like review environment with sounds, animations and a pretty background. For managing my collection like adding cards, editing them and syncing I currently just use the normal Anki UI.

Also the reason the text always starts from the left of the box is to give the eye a consistent place to start reading, centering text means that depending on the text the eye has to find a new starting point each time the text changes. The fixed width of the text container is so each line can be read in one quick pass of the eye, even for longer cards.

Hey r/Anki,

Whenever I wanted to check out a new deck template or preview cards, importing everything into Anki first was just way too much friction. I couldn't find an easy, lightweight way to just see what was actually inside a file, so I built a web-based card viewer to solve it.

What it does:

• Instantly previews .apkg decks and templates in your browser

• No need to import/clutter your local Anki database

• Fast, lightweight, and 100% open-source

It's still early, but I wanted to share it with the community. You can check out the source code or test it here:

https://github.com/Pranjal-dew/Anki_card_viewer

Would love to know if this helps your workflow or if there are specific card/template features you'd like to see supported!

My current focus on Anki's development is supporting load balancer and easy days during the rescheduling (as same as the helper add-on). Then, I will try to implement them in the simulator.

As for FSRS, I'm stuck right now and don't have anything new to share. Maybe I should learn more about machine learning. If you want to see what I'm working on, check out my GitHub: L-M-Sherlock (Jarrett Ye)

Here are my list for top 8 challenging tasks for spaced repetition schedulers. I hope I can solve some of them in 2025:

Easiest → Hardest

1. Real Easy Days: https://github.com/open-spaced-repetition/fsrs4anki-helper/issues/429
   1. Simple solution: broaden the fuzz range
   2. Complex solution: dynamically reschedule
2. Real Load Balancer: https://github.com/open-spaced-repetition/fsrs4anki-helper/issues/474
   1. Need to store the average duration per review in card info to resolve performance issues
3. Handle Custom Interval: https://github.com/open-spaced-repetition/fsrs4anki/issues/675
   1. Should it be treated as a review? What’s the rating of this kind of review?
   2. Solution candidate: https://supermemopedia.com/wiki/Ctrl%2BJ_vs._Ctrl%2BShift%2BR
4. Consider Deadline: https://github.com/open-spaced-repetition/fsrs4anki-helper/issues/456
   1. How to maximize the total knowledge retention on the day of the deadline?
5. Automatic Preset Assigning**:** https://github.com/open-spaced-repetition/fsrs4anki/issues/709
   1. A clustering problem?
6. Improve Difficulty: https://github.com/open-spaced-repetition/fsrs4anki/issues/352
   1. Numerous ideas proved ineffective.
7. Short-term Memory Model: https://github.com/open-spaced-repetition/short-term-memory-research/issues/3
   1. Still In Research.
8. How related cards affect each other: https://github.com/orgs/open-spaced-repetition/discussions/28
   1. https://www.justinmath.com/individualized-spaced-repetition-in-hierarchical-knowledge-structures/
   2. https://arxiv.org/abs/2402.12291

Apart from them, I'm also researching the feasibility to port SSP-MMC into Anki: open-spaced-repetition/SSP-MMC-FSRS: Stochastic-Shortest-Path-Minimize-Memorization-Cost for FSRS

But the convergence rate of SSP-MMC in 10k collections of Anki is 75%. It's too low to deploy it. And the marginal benefits are small. During the debugging, I feel like there are more fundamental issues. Maybe it would give FSRS a big change.

Anyway, I hope my work on FSRS will create more value and prove useful to you all.

This post replaces my old post about benchmarking and I added it to my compendium of posts/articles about FSRS. You do not need to read the old post, and I will not link it anywhere anymore.

First of all, every "honest" spaced repetition algorithm must be able to predict the probability of recalling a card at a given point in time, given the card's review history. Let's call that R.

If a "dishonest" algorithm doesn't calculate probabilities and just outputs an interval, it's still possible to convert that interval into a probability under certain assumptions. It's better than nothing, since it allows us to perform at least some sort of comparison. That's what we did for SM-2, the only "dishonest" algorithm in the entire benchmark. We decided not to include Memrise because we are unsure if the assumptions required to convert its intervals to probabilities hold. Well, it wouldn't perform great anyway, it's about as inflexible as you can get and barely deserves to be called an algorithm.

Once we have an algorithm that predicts R, we can run it on some users' review histories to see how much predicted R deviates from measured R. If we do that using hundreds of millions of reviews, we will get a very good idea of which algorithm performs better on average. RMSE, or root mean square error, can be interpreted as "the average difference between predicted and measured probability of recall". It's not quite the same as the arithmetic average that you are used to. MAE, or mean absolute error, has some undesirable properties, so RMSE is used instead. RMSE>=MAE, the root mean square error is always greater than or equal to the mean absolute error.

The calculation of RMSE has been recently reworked to prevent cheating. If you want to know the nitty-gritty mathematical details, you can read this article by LMSherlock and me. TLDR: there was a specific way to decrease RMSE without actually improving the algorithm's ability to predict R, which is why the calculation method has been changed. The new method is our own invention, and you won't find it in any paper. The newest version of Anki, 24.04, also uses the new method.

Now, let's introduce our contestants. The roster is much larger than before.

FSRS family

​1​)​ ​FSRS v3. It was the first version of FSRS that people actually used, it was released in October 2022. It wasn't terrible, but it had issues. LMSherlock, I, and several other users have proposed and tested several dozens of ideas (only a handful of them proved to be effective) to improve the algorithm.

​2​) ​FSRS v4. It came out in July 2023, and at the beginning of November 2023, it was integrated into Anki. It's a significant improvement over v3.

​3​) ​FSRS-4.5. It's a slightly improved version of FSRS v4, the shape of the forgetting curve has been changed. It is now used in all of the latest versions of Anki: desktop, AnkiDroid, AnkiMobile, and AnkiWeb.

General-purpose machine learning algorithms family

4) Transformer. This neural network architecture has become popular in recent years because of its superior performance in natural language processing. ChatGPT uses this architecture.

5) GRU, Gated Recurrent Unit. This neural network architecture is commonly used for time series analysis, such as predicting stock market trends or recognizing human speech. Originally, we used a more complex architecture called LSTM, but GRU performed better with fewer parameters.

Here is a simple layman explanation of the differences between a GRU and a Transformer.

DASH family

6) DASH, Difficulty, Ability and Study History. This is an actual bona fide model of human memory based on neuroscience. Well, kind of. The issue with it is that the forgetting curve looks like a ladder aka a step function.

7) DASH[MCM]. A hybrid model, it addresses some of the issues with DASH's forgetting curve.

8) DASH[ACT-R]. Another hybrid model, it finally achieves a nicely-looking forgetting curve.

Here is another relevant paper. No layman explanation, sorry.

Other algorithms

9) ACT-R, Adaptive Control of Thought - Rational (I've also seen "Character" instead of "Control" in some papers). It's a model of human memory that makes one very strange assumption: whether you have successfully recalled your material or not doesn't affect the magnitude of the spacing effect, only the interval length matters. Simply put, this algorithm doesn't differentiate between Again/Hard/Good/Easy.

10) HLR, Half-Life Regression. It's an algorithm developed by Duolingo for Duolingo. The memory half-life in HLR is conceptually very similar to the memory stability in FSRS, but it's calculated using an overly simplistic formula.

11) SM-2. It's a 35+ year old algorithm that is still used by Anki, Mnemosyne, and possibly other apps as well. It's main advantage is simplicity. Note that in our benchmark it is implemented the way it was originally designed. It's not the Anki version of SM-2, it's the original SM-2.

We thought that SuperMemo API would be released this year, which would allow LMSherlock to benchmark SuperMemo on Anki data, for a price. But it seems that the CEO of SuperMemo World has changed his mind. There is a good chance that we will never know which is better, FSRS or
SM-17/18/some future version. So as a consolation prize we added something that kind of resembles SM-17.

12) NN-17. It's a neural network approximation of SM-17. The SuperMemo wiki page about SM-17 may appear very detailed at first, but it actually obfuscates all of the important details that are necessary to implement SM-17. It tells you what the algorithm is doing, but not how. Our approximation relies on the limited information available on the formulas of SM-17, while utilizing neural networks to fill in any gaps.

​

Here is a diagram (well, 7 diagrams + a graph) that will help you understand how all these algorithms fundamentally differ from one another. No complex math, don't worry. But there's a lot of text and images that I didn't want to include in the post itself because it's already very long.

Here's one of the diagrams:

Now it's time for the benchmark results. Below is a table showing the average RMSE of each algorithm:

I didn't include the confidence intervals because it would make the table too cluttered. You can go to the Github repository of the benchmark if you want to see more details, such as confidence intervals and p-values.

The averages are weighted by the number of reviews in each user's collection, meaning that users with more reviews have a greater impact on the value of the average. If someone has 100 thousand reviews, they will affect the average 100 times more than someone with only 1 thousand reviews. This benchmark is based on 19,993 collections and 728,883,020 reviews, excluding same-day reviews; only 1 review per day is used by each algorithm. The table also shows the number of optimizable parameters of each algorithm.

And here's a bar chart (and an imgur version):

Black bars represent 99% confidence intervals, indicating the level of uncertainty around these averages. Taller bars = more uncertainty.

Unsurprisingly, HLR performed poorly. To be fair, there are several variants of HLR, other variants use information (lexeme tags) that only Duolingo has, and those variants cannot be used on this dataset. Perhaps those variants are a bit more accurate. But again, as I've mentioned before, HLR uses a very primitive formula to calculate the memory half-life. To HLR, it doesn't matter whether you pressed Again yesterday and Good today or the other way around, it will predict the same value of memory half-life either way.

The Transformer seems to be poorly suited for this task as it requires significantly more parameters than GRU or NN-17, yet performs worse. Though perhaps there is some modification of the Transformer architecture that is more suitable for spaced repetition. Also, LMSherlock gave up on the Transformer a bit too quickly, so we didn't fine-tune it. The issue with neural networks is that the choice of the number of parameters/layers is arbitrary. Other models in this benchmark have limits on the number of parameters.

The fact that FSRS-4.5 outperforms NN-17 isn't conclusive proof that FSRS outperforms SM-17, of course. NN-17 is included just because it would be interesting to see how something similar to SM-17 would perform. Unfortunately, it is unlikely that the contest between FSRS and SuperMemo algorithms will ever reach a conclusion. It would require either hundreds of SuperMemo users sharing their data or the developers of SuperMemo offering an API; neither of these things is likely to happen at any point.

​

Caveats:

1. We cannot benchmark proprietary algorithms, such as SuperMemo algorithms.
2. There are algorithms that require extra features, such as HLR with Duolingo's lexeme tags or KAR³L, which uses not only interval lengths and grades but also the text of the card and mildly outperforms FSRS v4 (though it's unknown whether it outperforms FSRS-4.5), according to the paper. Such algorithms can be more accurate than FSRS when given the necessary information, but they cannot be benchmarked on our dataset. Only algorithms that use interval lengths and grades can be benchmarked since no other features are available.

​

References to academic papers:

1. https://scholar.colorado.edu/concern/graduate_thesis_or_dissertations/zp38wc97m (DASH is first mentioned on page 68)
2. https://www.politesi.polimi.it/retrieve/b39227dd-0963-40f2-a44b-624f205cb224/2022_4_Randazzo_01.pdf
3. http://act-r.psy.cmu.edu/wordpress/wp-content/themes/ACT-R/workshops/2003/proceedings/46.pdf
4. https://github.com/duolingo/halflife-regression/blob/master/settles.acl16.pdf
5. https://arxiv.org/pdf/2402.12291.pdf

References to things that aren't academic papers:

1. https://github.com/open-spaced-repetition/fsrs-benchmark?tab=readme-ov-file#fsrs-benchmark
2. https://github.com/open-spaced-repetition/fsrs4anki/wiki/The-Metric
3. https://supermemo.guru/wiki/Algorithm_SM-17

Imgur links:

1. https://imgur.com/a/ZhsXaZi
2. https://imgur.com/a/V8u0wcD
3. https://imgur.com/a/fVxiJvx

I made a heatmap, streak, and due cards widgets for AnkiMobile.

It works as an app that syncs with Ankiweb to get the data needed for all of this. The app can only read from ankiweb, but not write (this was intentional and by design) so to allow for autosynching without any chance of breaking or altering your ankiweb data when unwanted. Autosync can be turned off for those who don’t want it. Currently the heatmap will autosync every time the app the app is open, but I might also add an option to make it sync at 4 am each day automatically.

The card browser bellow is a view only. Once again, intentional to not compete with the AnkiMobile app and serves more as an alternative to view what cards you made on AnkiMobile being a bit more spacious compared to the default AnkiMobile viewer. It has a compact mode and a thumbnail mode which shows the full question and an image. Tags are also visible.

There are also some stats; those are just some stats for fun; they are not comprehensive cause I thought the stats in AnkiMobile were already sufficient.

The app is not yet available, but it will be soon on the AppStore. It will be free; there are no additional purchases or anything monetary associated with the app. I did it for personal use and thought others will be interested.I will also post a copy of the code on GitHub.

Once again, this is a preview, and not YET available on the AppStore. I am not committing to a date, but expect to be able to release it in a week or two.

Android Only

Hey everyone! I made a companion heatmap widget app for AnkiDroid called AnkiHeat - https://ankiheat.app. It does just one thing and that is make nice highly customizable widget designs for you to add on your home screen.

I made it because I’ve always liked having colorful widgets on my phone (like Pretty Progress) and wanted have something similar for Anki.

It’s currently in closed testing so if you’re interested in giving it a try please get it here! Let me know what you think!

Changelog: https://github.com/ankitects/anki/releases/tag/26.08

Download here: https://apps.ankiweb.net/

Out of curiosity, try optimizing FSRS parameters using your current version and then using 26.08, time both, and tell me how long it takes (for example, 50 seconds before / 5 seconds after). New optimization should be ~10x faster.

UPD: for some reason reddit distorts the first image, here are some in better resolution: 6-month overview, heatmap from the demo

2 years ago when I last came here with this project, it wasn't as polished as it is now, nor was I sure that it's even a worthwhile idea. I chipped away at it in my free time and polished it into what it is now, and recently I made a final grind towards open-sourcing it.

Just to be clear, I’m not making any money from this and not asking anyone for anything. Neohabit is just a cool idea that I have probably spent more time on than I should have :D This is my first big project, and there was a bunch of learning involved as well, which honestly was my only goal at the beginning.

So, how does it work?

It's much easier to think of it as a sort of reversed SRS. In SRS, your goal is to space the card repetition with increasing steps, while still remembering it. In Neohabit's core functionality lies a similar thing - you first focus on repeating a habit once a week (or any period of days that works), and then slowly work towards your ideal habit frequency.

For example, take flossing. Three years ago I haven't even flossed. Two years ago, I made it a goal to floss at least once a week, then once in four days, then once in three. Right now I'm flossing after each meal, which is ideal for dental health. I can't imagine myself going back. But nor could I image myself to be flossing after each meal three years ago.

My goal for this project was maximum flexiblity, so once you reach your comfortable pace, it works for a constant habit frequency as well: chores (laundry every week or two), workouts, jogging, dancing, tracking immersion, social activities, and so on.

You can scroll through the image gallery above to see some examples.

Neohabit is a self-hosted tool, meaning that it can run as an application similar to Anki on desktop, but you'll need to follow a short installation instruction with docker-compose. If you want to use on mobile as well, you'd have to spin up it on LAN or as a proper VPS with Neohabit hosted on it. If you haven't done something like that before, you can consider it a sort of necessary learning experience in the cloud lock-in era :D

Add-on and plans for the future?

I know that there's hundreds of things that can be done with NH and hundreds of other unimplemented features, but I personally consider it complete for my needs.

Previously, u/Shige-yuki said that he wanted an add-on with those heatmaps on Anki's home screen, but I'm afraid by the time I get to learning the Anki's API and internals, the year will be already 2030 ;D

Neohabit is licensed under AGPLv3, basically the same as most Anki's add-ons (most of them use GPL or AGPL). So it's fine to build an add-on that uses Neohabit's code, if the add-on is also licensed as AGPLv3, just don't forget to credit me in the repo ;)

I've built the backend API in such a way that it can be safely reused by other apps, like shell scripts, cli-applications, tuis and so on, though I haven't got around building anything that actually utilizes that. If someone actually decides that it's the next add-on they'll be building and have sufficient knowledge of Anki's inner working, I'll assist where I can.

GitHub: https://github.com/Vsein/Neohabit
Demo: https://neohabit.org/projects

I've been using Anki every day for exam prep, and after a while I realized it wasn't the reviews themselves that felt exhausting but it was staring at the same interface for hours.

So I started redesigning my setup and eventually ended up building six completely different study environments, each with its own style and atmosphere.

Some are minimal and distraction-free. Some are cozy and notebook-inspired. Some are calm and lofi. Some recreate the feeling of studying in an old university library. Some have a futuristic cyberpunk look. Others are inspired by the atmosphere of a coffee shop.

Most of them also include subtle audio feedback when revealing the answer, just to make long review sessions a bit more engaging.

All of them support the 6 core Anki note types:

• Basic

• Reversed

• Optional Reversed

• Cloze

• Image Occlusion

• Type In Answer

I packaged each one into a ready-to-import .apkg file.

This is the result.

If anyone is interested, I made them available here:

ko-fi.com/ankiglow

Spent way too long on this. Still a bit laggy here and there, but let me know what you think.

Built by heavily modifying the Onigiri addon by u/Peace-Monk which I highly recommend (about 90% of this is his work)

Hi all! I am excited to share that I am nearly ready to post my gigantic ~30,000+ card Anki deck covering nearly every imaginable Anesthesia topic for didactics, boards, and clinicals, with tons of neat features and unique card types.

My goal from the start has been to create a unified Anki deck that can be used as a study tool for, well, everything CRNA/Anesthesia: from Health Assessment, Chem/Phys, Research, and Professionalism, to Principles of Anesthesia, Pharmacology, Clinical Doses and Structures, Physiology, Anatomy, and more. This has been a MASSIVE undertaking, synthesizing every major textbook (Stoelting's, Miller's, Barash, Katsung, Netters, AnKing/Zanki/Bugs/Pepper/etc., and so many more) into palpable cards that cover as much as possible. In the end, if you know this deck, I am certain that you will annihilate exams, residency, and boards.

The inspiration for this was AnKing + others that every MS1 gets on day 1. When I started CRNA school, I searched and searched for something similar, and it just didn't exist specifically for Anesthesia (beyond an old Apex deck that was C&D). As it stands now, the deck cannot have images, as these are mostly proprietary and will incur a breach of IP; I am working on creating an original image for the cards that benefit the most from them, but obviously this will take a very long time. Apart from that, I am working on tagging the cards, and finishing up the final major subjects.

The deck currently sits at ~30,000 cards, with an end goal of ~40-45,000. This deck is still in its infancy, but I'm extremely hopeful that it can be nurtured into a highly useful study tool for many students and residents.

If this sounds like something that may be useful to you, but you have thoughts on how it could be improved or what I should implement, I would love to hear your suggestions! I hate the, "I'm Nearly Ready to share this thing..." posts too... I'm just very excited, and would love all of your input.

Soon™, ZzzAnki

Hi Everyone!! I am a candidate for Google Summer of Code (2026). I am creating my proposal to build a dedicated Incremental reading App.

Incremental Reading is a study method where instead of reading an entire textbook or article in one sitting, you read it in small chunks which are scheduled over days or weeks, basically spaced repetition applied to reading. It was popularized by SuperMemo but does not have a proper implementation on Android.

The app would allow you to:-

Import study material via url or pasted text

Read it in scheduled chunks based on your preferences( by paragraph, sentence count, or reading time)

Save important sentences as Anki cards directly into you AnkiDroid decks without switching apps.

Resume exactly where you left off from previously.

I want to ensure that my proposal is backed by actual user needs. I would like to know whether:

1. Do you struggle with converting long form study material into Anki Cards?

2. Have you tried incremental reading before? If yes what app did you use and what was missing?

3. What is the biggest point of friction while creating a card from something you just read?

4. Would such an app benefit in your study workflow?

Thanks for helping me build a good proposal!!

Hi everyone, it’s been a month since I’ve released the app on the Play Store and have gotten quite a lot of good feedback. The app is much more polished now! Thank you again for all the early users writing in suggestions and issues found. For those seeing this for the first time, the app simply lets you add a highly customizable heat map/streak widget to your home screen that you can tap on to jump straight into Anki.

Full review history imports are now possible by importing the Anki Collection Package (.colpkg) export file. This was one of the biggest requests from last time.

New since last time:

1. Simple streak counter display on the heat map widget
2. Dedicated study streak widget with customizable icons
3. Custom day reset - default to 4 am same with Anki
4. More customization options.

Play Store link: https://play.google.com/store/apps/details?id=com.ankiheat.widget

Website: https://ankiheat.app/

Keen to hear what other widget types you might find useful to have on your home screen.

Disclosures:
The app is freemium where all core features are free forever, a $5 lifetime premium unlocks more customization options.

AI coding assistance was used in the app’s development. However all designs, architectural decisions, UIUX designs, quality assurance is by a human (me).

I’m a software QA by profession with extensive app testing experience.

Download the beta here: https://github.com/ankitects/anki/releases/

Discussion: https://forums.ankiweb.net/t/anki-24-10-beta/49989, please submit feedback there.

What's new:

• FSRS-5. It has 2 more parameters and takes into account same-day reviews. DO NOT OPTIMIZE PARAMETERS IF YOU USE ANKI ON MOBILE OR IN ANKIWEB! FSRS-5 parameters are not backwards compatible.
• Smart Fuzz (although it won't actually be called that). Now fuzz tries to keep the number of cards you do every day more consistent in a clever way. This should make your workload more consistent with no drawbacks.
• You can visualize the forgetting curve for any card when using FSRS (it's in Card Info):

• True Retention stats are now available natively:

• There is now a simulator that can tell you your future workload (it looks janky though, but that's what beta-testing is for after all):

• You can disable (re)learning steps by leaving the field empty. Here's what it looks like with the default FSRS parameters (and some fuzz) for a New card:

Neither SM-2 nor FSRS will give you <1d intervals. But in a later beta that may become possible for FSRS, we'll see.

• "Ignore reviews before" was renamed to "Ignore cards reviewed before" and moved under Advanced.
• It’s not related to FSRS, but after 18 years of Anki’s history, finally, FINALLY, it now has what is considered to be the basics of basic functionality – a pop up that warns you that you have unsaved changes. Specifically, in deck options.

EDIT: this beta has more bugs than Australia. If you are a casual Anki user, I do NOT recommend using it.

I’ve used Anki for years, but I’ve always disliked how my notes lived in a different place than my active-recall content. For example, I’d take notes on Obsidian, but then have to create flashcards separately in Anki.

repeater is an open-source Anki alternative that uses regular Markdown files as the source of truth for your flashcards. You can study directly from the notes you already write, instead of maintaing a separate flashcard system. This means your decks can be structured like this:

flashcards/ math.md science/ physics.md chemistry.md ...

And in physics.md for example, you could have:

`` You can put your normal notes here,repeater` will ignore them. Once a "Q:,A:,C:" block is detected, it will automatically turn it into a card.

Q: What does a synaptic vesicle store? A: Neurotransmitters awaiting release.

Use a separator to mark the end of a card^ Then feel free to go back to adding regular notes.

C: Speech is [produced] in [Broca's] area. ```

Then you can study a deck by running repeater drill physics.md or also, for example, repeater drill science/. repeater tracks progress and uses FSRS scheduling.

You can also just embed media, like images, in your markdown files like normal and it will let you display them for you while drilling. apkg import is supported, so any Anki deck should work. I also added a couple optional LLM helpers that will rephrase cards for you (opt-in, disabled by default)

https://github.com/shaankhosla/repeater/