FSRS Explained: How the Spaced Repetition Algorithm Actually Works

FSRS (Free Spaced Repetition Scheduler) is an open-source algorithm that predicts when you're about to forget a flashcard and schedules your next review just before that happens. Instead of applying one fixed formula to everyone, it models each card's state in your memory with three numbers — difficulty, stability, and retrievability — and fits its parameters to your own review history with machine learning. The practical result, per the official documentation: the same retention as the older SM-2 algorithm with roughly 20–30% fewer reviews. It ships built into Anki (since v23.10) and a growing list of other apps, including LingoKeep.

That's the short answer. The rest of this guide unpacks it in plain language: why scheduling matters at all, what was wrong with the old algorithm, and what those three numbers actually mean.

Start with the forgetting curve

In 1885, Hermann Ebbinghaus memorized nonsense syllables, tested himself at intervals, and drew the first forgetting curve: memory doesn't fade linearly, it collapses — steep loss at first, flattening over time. His second finding is the one that matters for learners: every successful recall flattens the curve. Review something just as it's slipping away, and it decays more slowly afterward.

That's the whole trick behind spaced repetition: each review buys you a longer interval before the next one — days become weeks become months. The open question was never whether this works; it's when exactly to schedule each review. Too early wastes your time on things you still know; too late and the memory is gone and you're relearning from scratch. A scheduling algorithm is just a machine for making that timing decision, card by card, thousands of times.

The old answer: SM-2 and its problems

For most of flashcard history, "the algorithm" meant SM-2 — published by Piotr Woźniak for SuperMemo in 1987, and the basis of Anki's classic scheduler. SM-2 keeps an ease factor per card and multiplies the interval by it after each successful review: know it → interval grows, miss it → interval resets and ease drops.

It works — SM-2 carried decades of successful learners. But it has structural problems that every heavy user eventually meets:

• It only looks at the last review. SM-2 updates a card from its current ease and your latest grade. Your full history — the actual data about how you remember this card — is thrown away.
• "Ease hell." Every lapse permanently lowers a card's ease factor, and there's little mechanism to recover. Hard cards spiral into being shown constantly at short intervals, which is demoralizing without being efficient.
• Fixed constants for everyone. The multipliers were hand-tuned in 1987 and don't adapt to your material or your memory.
• No retention target. SM-2 gives you no way to say "I want to remember 90% of my cards" and have the scheduler aim for it. Intervals are whatever the formula produces.

The FSRS answer: model the memory, then schedule around it

FSRS — developed by Jarrett Ye with the open-spaced-repetition community, and published in peer-reviewed papers at ACM KDD and IEEE TKDE — takes a different approach. Instead of a formula that maps grades to intervals directly, it maintains a model of the memory itself, using the three-component "DSR" model. Every card, at every moment, is described by three numbers:

• Retrievability (R) — the probability that you can successfully recall this card right now. It's 100% the moment after a review and decays along a forgetting curve as time passes. This is the only one of the three that changes on its own, without you doing anything.
• Stability (S) — how slowly the card decays, defined concretely as the number of days it takes R to fall from 100% to 90%. A card with stability 3 needs a review within days; a card with stability 200 is safe for months. Reviews increase stability — that's the "flattening" Ebbinghaus saw, made into a number.
• Difficulty (D) — the inherent complexity of the card: how hard it is to increase its stability with a review. Easy cards leap ahead after each success; difficult cards make smaller gains and therefore come back sooner.

Scheduling then becomes almost trivial: you pick a desired retention — say 90%, the common default; anything from ~70% to ~97% is considered reasonable — and FSRS schedules each card's next review for the day its predicted R drops to that target. When you review and grade the card (Again / Hard / Good / Easy), the model updates D and S from the outcome, and the cycle repeats.

Notice what this design buys you that SM-2 structurally can't:

1. A tunable dial instead of a fixed destiny. Want fewer daily reviews and can accept forgetting a bit more? Set retention to 85% and intervals stretch out. Cramming for an exam? Raise it. It's one number with a predictable meaning.
2. Lapses aren't a death sentence. Forgetting a card lowers its stability, but the model has no permanent ease-factor scar tissue — no ease hell.
3. Late reviews are handled gracefully. Life happens and you skip a week; FSRS knows exactly what a delay does to R and updates accordingly, rather than pretending you reviewed on schedule.

The machine-learning part (without the math)

Those D/S/R update rules have shape but need numbers — how much should stability grow after a "Good" on an easy card? FSRS answers empirically: the current version (FSRS-6) has 21 parameters, fitted by machine learning against real review logs. The defaults are trained on hundreds of millions of reviews from thousands of learners, and — this is the part that makes it personal — the optimizer can refit those parameters to your own review history, so the scheduler literally learns how your memory behaves on your material. (The official advice: run the optimizer, don't hand-tweak parameters.)

This is also what makes FSRS's efficiency claim testable rather than rhetorical: on the open srs-benchmark, FSRS predicts actual recall outcomes more accurately than SM-2-family algorithms, and in practice that accuracy converts into the 20–30% fewer reviews for the same retention figure from the documentation. Better predictions → less wasted reviewing. That's the whole pitch.

Using FSRS in practice

In Anki: since v23.10, FSRS is built in — enable it per preset in the deck options (one toggle), set your desired retention, and periodically press "Optimize" once you have a body of review history. If you're searching "anki fsrs," that toggle plus the default 0.9 retention is genuinely all you need to start; the fsrs4anki docs cover the fine print.

Everywhere else: because FSRS is free and open source (unlike SuperMemo's later proprietary algorithms, which is the "Free" in the name), any app can adopt it, and implementations exist across languages — including ts-fsrs for JavaScript. That means the scheduling science is no longer the moat it used to be; what differs between apps is where your cards come from and how much setup the loop costs you.

Choosing a spaced repetition app

If you're evaluating spaced repetition apps, the algorithm question is mostly settled — prefer something running FSRS or equivalent — so choose on workflow instead:

• Anki — the default for a reason: free (desktop/AnkiDroid), FSRS built in, infinitely customizable, huge shared-deck ecosystem. The cost is friction: you assemble the workflow (card creation, add-ons, sync) yourself.
• RemNote / Obsidian plugins — spaced repetition fused into note-taking; strong for study-from-your-notes workflows (RemNote also supports FSRS).
• Mochi and similar — simpler, prettier card apps that trade algorithmic transparency and tuning for low friction.
• Purpose-built loops — apps where cards are created where the learning happens, so the capture step disappears. That's LingoKeep's category: for language learners, the card source is the YouTube video you're already watching — click a word in the subtitles, it's saved with its sentence and video moment, and the built-in FSRS review is free (the scheduler is exactly what this article describes, running ts-fsrs). No Anki install, no deck setup, no add-ons — though if you're an Anki person, your cards export cleanly rather than being locked in.

The honest framing: a general-purpose SRS is a power tool you configure; a purpose-built one is a loop that's already closed. Pick by how much assembly you enjoy.

The one thing no algorithm fixes

FSRS optimizes when you review. It cannot fix what you review. Cards without context ("word → translation" pairs scraped from a frequency list) schedule just as efficiently as rich ones and teach far less — for language learning especially, cards built from real sentences you actually encountered beat isolated words, which is why sentence mining workflows and input-based learning pair so naturally with spaced repetition. Algorithm quality decides your review count; card quality decides what the reviews are worth.

FAQ

Q: What is FSRS in simple terms? A: FSRS (Free Spaced Repetition Scheduler) is an open-source algorithm that estimates, for every flashcard, the probability you can still recall it — and schedules the next review for just before you'd forget. It models each card with three numbers (difficulty, stability, retrievability) and tunes itself to your review history with machine learning.

Q: Is FSRS better than Anki's default SM-2 algorithm? A: On the open srs-benchmark, FSRS predicts real recall more accurately than SM-2-family schedulers, which translates to roughly 20–30% fewer reviews for the same retention per the official docs. It also avoids SM-2's "ease hell" and handles late reviews gracefully. Anki has shipped FSRS as a built-in option since v23.10.

Q: What do difficulty, stability, and retrievability mean in FSRS? A: Retrievability is the probability you can recall the card right now; it decays over time. Stability is how slowly it decays — defined as the days it takes retrievability to fall from 100% to 90%. Difficulty is how hard the card is to strengthen — harder cards gain less stability per review, so they come back sooner.

Q: What desired retention should I set in FSRS? A: 90% is the common default and a sensible start; the documentation considers roughly 70–97% reasonable. Lower it (e.g. 85%) to cut daily workload at the cost of forgetting a bit more; raise it before an exam. Avoid extremes — very high retention makes review counts explode.

Q: Do I need Anki to use FSRS? A: No. FSRS is free and open source with implementations in many languages, and a growing number of apps ship it built in. LingoKeep, for example, runs FSRS (via ts-fsrs) for its free review system, so cards you save from YouTube videos are scheduled with the same algorithm — no separate setup.