How Anki Works

A research report on the data model, review loop, and the memory science underneath the world's most popular spaced-repetition app.

9 min

The one idea: memory decays predictably, so Anki shows you each fact again right before you'd forget it — and pushes the next review further out every time you succeed. Everything else (cards, buttons, algorithms) is machinery serving that single bet against the forgetting curve.

1. The memory science it rests on

Anki is an implementation of four findings from cognitive psychology, not an invention of its own:

Forgetting curveEbbinghaus, 1880s. Memory decays fast at first, then levels off. Without reinforcement, most of what you learn is gone within days.

Spacing effectPractice distributed over time beats massed cramming for long-term retention. Each successful review lets the next interval grow longer.

Active recall / testing effectRetrieving an answer from memory is itself a learning event — far stronger than re-reading. The struggle is the mechanism.

Desirable difficultyBjork's idea: let a memory fade just enough that recall takes effort. Too easy teaches nothing; too hard fails. Anki aims at the sweet spot.

Each review catches the memory near the 90% line and flattens the next decay — so intervals stretch from days to weeks to months.

2. The data model: notes, cards, fields, decks

A common beginner confusion: you create notes, and Anki generates cards from them. The distinction is the heart of the model.

Note — a single piece of structured knowledge (e.g. a vocabulary word and its meaning). It is the thing you edit.
Fields — the named slots on a note (Front, Back, Audio, Example…). You define them per note type.
Note type — a schema: which fields exist + which card templates run. Basic makes one card; Basic (and reversed) makes two; Cloze makes one per deletion.
Card template — written in HTML + CSS. It maps fields onto a front/back and decides whether a card is even generated.
Card — one question/answer pair actually scheduled and reviewed. One note can spawn several (front→back, back→front, etc.).
Deck — a study queue. Decks nest with ::, e.g. Chinese::Hanzi sits inside Chinese.

Why it matters: editing one note fixes a typo on every card it generates, and one fact reviewed from two directions stays a single editable unit.

Note type: "Basic (and reversed)"
  Fields:  Front = "山"   Back = "mountain"
  ↓ generates
  Card 1:  山 → mountain
  Card 2:  mountain → 山      (each scheduled independently)

3. The review loop: four card states

Every card moves through a small state machine. The scheduler's whole job is deciding when a card re-enters your queue.

New cards pass through short learning steps, graduate to the long-interval Review state, and drop into Relearning if you later forget them.

New — never studied. Gated by a daily new cards/day limit (default 20).
Learning — being drilled through short learning steps (default 1m 10m) within a session before it counts as "known".
Review — graduated. Now scheduled days-to-months out; intervals grow on each success.
Relearning — a Review card you failed (a lapse). It re-enters short steps before climbing back out.

4. The four buttons

At answer time you grade your own recall. That single tap feeds the scheduler.

Button	Means	Effect on the card
Again	Failed to recall	Back to step one / lapses to Relearning. Interval collapses.
Hard	Recalled, but a struggle	Repeats the step, or grows the interval less than normal.
Good	Recalled correctly	The default. Advances a step / multiplies the interval. Used 80–95% of the time.
Easy	Effortless	Jumps straight to a longer interval, skipping remaining steps.

The honesty of this self-grade is the system's weak point and its leverage: the algorithm is only as good as the rating you give.

5. SM-2: the classic scheduler

For most of Anki's life the engine was SM-2, Piotr Woźniak's 1980s SuperMemo algorithm. It tracks one number per card: the ease factor.

Ease starts at 2.5 (250%) and never drops below 1.3 (130%).
First success → 1 day. Second → 6 days. After that → previous interval × ease.
Press Good repeatedly and intervals snowball: 6d → 15d → 38d → 95d…
Again resets the card and shrinks ease; Hard nudges ease down; Easy bumps it up.

interval(n) = interval(n-1) × ease
ease ← ease + (0.1 − (5−q)×(0.08 + (5−q)×0.02))   // q = grade 0–5

It's simple and transparent — but it has only one knob (ease), so it can't separate how hard a card is from how durable the memory currently is. That conflation is what its successor fixes.

6. FSRS: the modern scheduler

Since Anki 23.10 the default is FSRS (Free Spaced Repetition Scheduler), built on the DSR model of memory. Instead of one ease number, it models three:

DifficultyInherent complexity of this specific card. Hard facts climb slower.

StabilityDays for recall probability to fall from 100% → 90%. S = 365 means a year until you're at 90%. Grows with each success.

RetrievabilityYour probability of recalling it right now, given time elapsed and current stability.

Target retentionYou pick a goal (e.g. 90%). FSRS schedules each card for the day its retrievability hits that number.

FSRS reframes scheduling as a prediction problem: when will this card's recall probability drop to your target? Because it can run an optimizer over your own review history, it personalizes its ~19 parameters to your memory — typically the same retention for noticeably fewer reviews.

7. SM-2 vs FSRS at a glance

	SM-2 (classic)	FSRS (default since 23.10)
Memory state	One number (ease)	Three (difficulty, stability, retrievability)
Personalization	None — same constants for everyone	Optimizer fits parameters to your history
Target	Implicit, fixed intervals	Explicit retention % you choose
Efficiency	Baseline	Similar retention, ~20–30% fewer reviews
Transparency	Easy to compute by hand	Black-box-ish; needs review data to shine

8. Where it breaks down

Anki's failure modes are well-documented and mostly about card quality and load, not the algorithm.

Review overload. 20 new cards/day compounds into a review backlog that buries new learners within ~2 weeks. Advice: budget in minutes, start at ~10 new/day.
Leeches. Cards you fail over and over consume disproportionate time. Anki auto-tags/suspends them after repeated lapses.
Bad card formulation. The usual cause of a leech: a card that's too complex, lacks context, or crams multiple facts. The fix is Woźniak's "Twenty Rules" — especially the Minimum Information Principle: one atomic fact per card.
Ease/interval death spirals (SM-2). Repeated Hard/Again drags ease down, shrinking intervals and piling up reviews — a known SM-2 pathology FSRS largely sidesteps.
Garbage-in self-grading. Dishonest or inconsistent button presses corrupt every downstream interval.

9. Design takeaways for a conversation-native SRS

Connecting the research to the V1 vision (spaced repetition that repeats your own life back to you, not Anki-style decks):

The scheduler is the easy part. FSRS is open-source and battle-tested — borrow it. The hard, differentiated part is everything Anki offloads onto the user.
Authoring is Anki's real tax. Notes, fields, templates, the Twenty Rules — users must hand-build atomic cards. A conversation that extracts atomic facts automatically removes the single biggest source of failure (bad cards → leeches).
Self-grading is fragile. Four buttons demand metacognition users don't have. Inferring recall from a natural answer ("tell me about…") sidesteps the dishonest-rating problem.
Decks are a UI for retrieval direction; conversation is richer. One life-fact can be probed from many angles without pre-authoring reversed cards.
Keep the bet identical. Whatever the interface, you're still catching a memory at the 90% line. The forgetting curve doesn't care that the front-end is a chat.