EXPLAINER: What is Spaced Repetition and Why Does It Matter?#

For Readers New to Learning Science#

If you’re reading this research and don’t have a background in cognitive science or educational technology, this section explains the fundamental concepts. If you’re already familiar with spaced repetition systems, skip to “Algorithm Comparison” below.

What Problem Does Spaced Repetition Solve?#

Spaced repetition is a learning technique that schedules review sessions at increasing intervals to maximize long-term retention while minimizing study time.

Real-world analogy: Imagine you’re learning Spanish vocabulary. You could:

• Cramming approach: Study the word “perro” (dog) 20 times today, then never review it
• Spaced approach: Study “perro” today, review tomorrow, then 3 days later, then a week later, then a month later

The science: Hermann Ebbinghaus discovered in 1885 that we forget information rapidly at first, then more slowly over time. This is called the forgetting curve.

Without review:

• After 1 day: You remember ~40% of what you learned
• After 1 week: You remember ~25%
• After 1 month: You remember ~10%

With spaced repetition:

• Each review strengthens the memory before you forget it
• Intervals increase as the memory becomes stronger
• You can maintain 90%+ retention indefinitely
• Result: 50-70% less study time for the same retention

Why Does This Work? The Forgetting Curve#

The Forgetting Curve describes how memory decays over time:

Memory Strength
100% |●
     |  ●●
     |     ●●●
 50% |         ●●●●
     |              ●●●●●●
  0% |____________________●●●●●●●●●●●
     0   1d  3d  7d  14d  30d  60d
         Time Since Learning

Key insight: Memory decay is predictable!

Traditional studying fights the curve with repetition:

• Review repeatedly while memory is still strong (wasteful)
• Miss the optimal review time and forget completely (must relearn)

Spaced repetition schedules reviews at the optimal time:

• Just before you would forget
• Each successful review makes the memory more stable
• Intervals grow: 1 day → 3 days → 1 week → 3 weeks → 2 months → 6 months

Efficiency gain:

• Traditional: 20 reviews in first month, constant effort
• Spaced: 5 reviews in first month, exponentially decreasing effort
• Result: Learn 4x more material in the same time

Real-World Impact: Why This Matters#

Medical Education (Most Dramatic Results)#

Context: Medical students must memorize ~10,000+ facts (anatomy, drugs, diseases)

Study: Kirk Kerkorian School of Medicine, Class of 2026 (n=36 students)

Results:

• Students using Anki (spaced repetition app) scored 12.9% higher on board exams (p = 0.003)
• Course exams: +6-7% improvement
• Bonus: Improved sleep quality (less cramming stress)

Translation: The difference between passing and failing board exams

Source: Exploring Impact of Spaced Repetition Through Anki (2025)

Language Learning (Most Popular Use Case)#

Market: Core driver of $1.23 billion spaced repetition software market (2024)

Effectiveness:

• 50-70% time reduction vs traditional flashcard review
• 90%+ vocabulary retention after 6 months (vs 10-25% with cramming)

Popular apps using SRS:

• Anki: 10+ million users
• Duolingo: Custom SRS algorithm
• Memrise: SRS-based language courses

Example: Learning 2,000 Chinese characters

• Traditional flashcards: ~200 hours, frequent forgetting
• Spaced repetition: ~60-80 hours, 90% retention
• Savings: 120 hours = 3 full work weeks

Professional Certification#

Use cases:

• Bar exam (legal): Memorizing case law, statutes
• CPA exam (accounting): Tax codes, accounting standards
• Professional certifications: Technical knowledge retention

Why it works: Long study timelines (3-12 months) align perfectly with spaced repetition

How Spaced Repetition Works: The Basics#

Step 1: Create a Flashcard#

Front: What is the capital of France? Back: Paris

Step 2: Review and Rate Your Recall#

After reviewing, you rate how well you remembered:

Typical rating scale (4 buttons):

• Again (0): Complete blackout, couldn’t recall
• Hard (1): Struggled, needed significant effort
• Good (2): Recalled correctly after brief hesitation
• Easy (3): Instant, effortless recall

Step 3: Algorithm Calculates Next Review#

Based on your rating, the algorithm schedules the next review:

If you rated “Again” (forgot):

• Next review: 1 minute or 10 minutes (short interval, relearn quickly)

If you rated “Good” (correct recall):

• First review: Tomorrow (1 day)
• Second review: 3 days later
• Third review: 1 week later
• Fourth review: 3 weeks later
• Fifth review: 2 months later
• And so on… intervals keep growing

If you rated “Easy” (instant recall):

• Longer intervals (skip some intermediate reviews)

Step 4: Repeat Daily#

Daily routine:

• App shows cards due for review today
• Typically 20-50 cards/day for steady-state learning
• Takes 10-20 minutes
• New cards added gradually

Long-term equilibrium:

• After 6 months: Reviewing ~100 cards/day
• 90% are “mature” cards (only reviewed every 1-6 months)
• 10% are new or difficult cards (reviewed more frequently)
• Time investment levels off (sustainable indefinitely)

Key Concept: The Three Variables That Matter#

All spaced repetition algorithms track some version of these variables:

1. Interval: When to review next?#

Simple version (SM-2 algorithm, 1988):

• First review: 1 day
• Second review: 6 days
• Subsequent reviews: Multiply by “easiness factor”
• Example: 1 day → 6 days → 15 days → 38 days → 95 days

Modern version (FSRS algorithm, 2023):

• Calculated from stability (how long memory lasts)
• Accounts for difficulty, retrievability, and review history
• More accurate, fewer reviews needed

2. Difficulty: How hard is this card for YOU?#

Why it matters: “The Eiffel Tower is in Paris” is easier than “The Battle of Hastings was in 1066”

SM-2 approach: “Easiness Factor” (static)

• Range: 1.3 to 2.5
• Based on your rating history
• Doesn’t change much over time
• Problem: A card might get easier as you learn related concepts

FSRS approach: “Difficulty” (dynamic)

• Range: 0 to 10
• Updates based on your performance
• Accounts for “anchoring” (when you suddenly “get it”)
• Advantage: Adapts as you learn

3. Memory Strength: How well have you learned this?#

SM-2 approach: Tracks “repetition count”

• First review: n=1
• Second review: n=2
• If you forget: Reset to n=0
• Simple but crude

FSRS approach: Tracks “stability” and “retrievability”

• Stability: How long the memory lasts (in days)
• Retrievability: Probability you’ll recall it right now (0-100%)
• Example: Stability = 90 days means you have 90% chance after 90 days
• More accurate, better predictions

Algorithm Comparison: Which One Should You Use?#

Three main algorithms dominate the spaced repetition landscape:

Algorithm 1: SM-2 (SuperMemo 2, 1988)#

What it is: The original spaced repetition algorithm, published in 1988

How it works:

• Three variables: Interval, Easiness Factor, Repetition Count
• Simple formula: Next interval = Previous interval × Easiness Factor
• Hardcoded first intervals: 1 day, then 6 days

Strengths:

• ✅ Dead simple: 50 lines of code, zero configuration
• ✅ Battle-tested: 38 years of use, proven effective
• ✅ Free forever: Public domain, no licensing
• ✅ 50-70% time savings vs traditional methods

Weaknesses:

• ⚠️ Lower performance: 47-60% success rate (vs 89%+ for modern algorithms)
• ⚠️ Static difficulty: Assumes card difficulty never changes
• ⚠️ Hardcoded intervals: One-size-fits-all approach

When to use SM-2:

• Building an MVP or prototype (fastest implementation: 3-4 weeks)
• Budget constrained (zero licensing cost)
• Simple use case (basic flashcards only)
• Team lacks machine learning expertise

Popularity: 361 downloads/month (PyPI)

Algorithm 2: FSRS (Free Spaced Repetition Scheduler, 2023)#

What it is: Modern, machine-learning-optimized algorithm adopted by Anki in 2023

How it works:

• Three variables: Difficulty, Stability, Retrievability (DSR model)
• 21 parameters optimized using machine learning
• Trained on 1.7 billion reviews from 20,000 Anki users
• Dynamic difficulty (adapts as you learn)

Strengths:

• ✅ High performance: 89.6% success rate
• ✅ 20-30% fewer reviews than SM-2 for same retention
• ✅ Open-source: MIT license, free to use
• ✅ Active development: Regular updates through 2026
• ✅ Industry adoption: Anki’s default algorithm since v23.10
• ✅ Evidence-based: Published research, academic backing

Weaknesses:

• ⚠️ More complex: 100-200 lines of code, 21 parameters
• ⚠️ Requires optimization: Best results need training on user data
• ⚠️ Newer algorithm: Only 3 years old (vs SM-2’s 38 years)

When to use FSRS:

• Production app (not MVP)
• User retention is critical (fewer reviews = better retention)
• You have review history data for training
• Open-source requirement (no licensing fees)

Popularity: 7,324 downloads/month (PyPI) — 20× more popular than SM-2

Algorithm 3: SM-18 (SuperMemo 18, 2019)#

What it is: Most advanced algorithm, proprietary to SuperMemo software

How it works:

• Two-component memory model: Stability + Retrievability
• Dynamic difficulty (accounts for “anchoring” effects)
• Proprietary implementation (source code not public)
• Requires SuperMemo license

Strengths:

• ✅ Best-in-class performance: Estimated 90%+ success rate
• ✅ Most advanced model: 30+ years of algorithm evolution
• ✅ Production-proven: Used in SuperMemo software

Weaknesses:

• ❌ Proprietary: Requires licensing from SuperMemo
• ❌ No open-source: Can’t use in free apps
• ❌ Limited ecosystem: SuperMemo exclusive
• ❌ No public benchmarks: Performance claims unverified
• ❌ High lock-in risk: Can’t migrate away easily

When to use SM-18:

• Enterprise budget allows licensing fees
• Best-in-class performance required
• Not building open-source product
• Compliance/audit met by SuperMemo

Popularity: Not available on PyPI (proprietary)

Algorithm Performance Comparison#

Success Rates (2025 Benchmarks)#

*To maintain 90% retention over 1 year for 100 cards **Estimated (no public benchmarks)

Source: Benchmark of Spaced Repetition Algorithms (2025)

Translation to Real-World Impact#

Scenario: Learning 2,000 vocabulary words over 1 year

SM-2 (baseline):

• Total reviews: 10,000
• Time: 50 hours (@ 5 seconds/card)
• Retention: 60% (1,200 words retained)

FSRS (modern):

• Total reviews: 5,750 (42% fewer)
• Time: 29 hours
• Retention: 90% (1,800 words retained)
• Savings: 21 hours + 600 more words learned

SM-18 (best-in-class):

• Total reviews: 5,500 (45% fewer)
• Time: 28 hours
• Retention: 90% (1,800 words retained)
• Trade-off: Licensing cost + vendor lock-in

Recommendation: FSRS offers best balance of performance, cost, and flexibility

Decision Framework: Which Algorithm Should You Choose?#

Decision Tree#

1. Are you building an MVP or prototype?
   ├─ Yes → SM-2 (fast, simple, proven)
   └─ No → Go to 2

2. Do you expect >10,000 users?
   ├─ Yes → Go to 3
   └─ No → SM-2 (sufficient for small scale)

3. Is user retention critical to your business model?
   ├─ Yes → FSRS (20-30% fewer reviews → better retention)
   └─ No → SM-2 (cost-effective)

4. Do you have review history data for training?
   ├─ Yes → FSRS (optimize from day 1)
   └─ No → SM-2 initially, migrate to FSRS after 3-6 months

5. Is licensing cost acceptable?
   ├─ Yes → Evaluate SM-18 (best performance, but licensing fees)
   └─ No → FSRS (open-source, no licensing)

6. Is open-source a requirement?
   ├─ Yes → SM-2 or FSRS only
   └─ No → FSRS or SM-18

Recommendations by Use Case#

Language Learning Apps:

• Choose: FSRS
• Why: Competitive with Duolingo/Memrise, 20-30% fewer reviews improves retention, open-source
• Example: Anki (10M+ users) switched to FSRS in 2023

Medical Education Apps:

• Choose: FSRS (or SM-2 for MVP)
• Why: Medical students already use Anki (FSRS native), evidence-based, performance critical
• Example: 12.9% board exam score improvement proven (2026 study)

Corporate Training Apps:

• Choose: SM-2 (or FSRS if budget allows)
• Why: Lower engagement than language learning, SM-2 sufficient for compliance/onboarding

K-12 Educational Apps:

• Choose: SM-2
• Why: Simplicity valued, lower budget constraints, proven 50-70% time reduction

What It Costs#

One cost in this category belongs to the algorithm. Everything else belongs to building an application, and does not change with the scheduler you choose.

That last row is the important one, and it is not a budget question. SM-18 has no public specification and nothing outside SuperMemo’s own product implements it — so it is not an option you can decide to afford.

What differs between SM-2 and FSRS is engineering capacity, not money. SM-2 is about fifty lines of arithmetic with nothing to tune. FSRS is a hundred to two hundred, has 21 parameters, and wants a corpus of real review history plus a periodic optimizer run to be worth its advantage. If nobody on the team is going to run that optimizer, much of the advantage stays on the table.

And FSRS’s payoff is not measured in your budget. Twenty to thirty percent fewer reviews for the same retention is time returned to the person studying. If anything in this category has a return, that is it, and it accrues to your users.

Common Misconceptions#

Misconception 1: “More reviews = better learning”#

Reality: Optimal learning happens at the edge of forgetting

Traditional thinking:

• Review frequently while memory is fresh (wasteful)
• Constant repetition strengthens memory

Spaced repetition insight:

• Reviewing too early wastes time (you already know it)
• Reviewing just before forgetting maximizes retention
• Effort during recall strengthens memory (slightly forgetting then remembering is ideal)

Example:

• Review 5 times in one day: Minimal long-term benefit, 25 minutes wasted
• Review once today, once in 3 days, once in a week: Strong long-term retention, 5 minutes total

Misconception 2: “I can’t do this every day”#

Reality: 10-20 minutes/day is sustainable, missing days is okay

Common fear: “If I skip a day, I’ll forget everything”

Truth:

• Missing 1-2 days: Minimal impact (intervals adjust automatically)
• System is forgiving (you can batch reviews later)
• 15 minutes/day is more effective than 2 hours/week

Comparison:

• Daily user: Reviews 100 cards/day, 700 cards/week
• Weekend-only user: Reviews 350 cards Saturday, 350 Sunday (same total)
• Outcome: Daily user retains 90%, weekend user retains 75% (spacing within week matters)

Recommendation: Aim for daily, but don’t stress if you miss 1-2 days

Misconception 3: “All spaced repetition apps are the same”#

Reality: Algorithm choice matters for performance

Why people think this:

• All SRS apps show flashcards and schedule reviews (same UI)
• Differences are invisible (algorithm runs in background)

Actual performance difference (same 1,000 cards):

• SM-2 app: 5,000 reviews in first year, 60% retention
• FSRS app: 3,500 reviews in first year, 90% retention
• Difference: 1,500 fewer reviews (25 hours saved) + 30% better retention

Translation: FSRS users spend less time AND learn more

Misconception 4: “I can just use Anki (it’s free)”#

Reality: Anki is excellent, but has limitations

Anki strengths:

• Free, open-source, 10M+ users
• FSRS algorithm since 2023 (excellent performance)
• Massive ecosystem (shared decks, add-ons)

Anki limitations:

• UI/UX: Desktop-first, learning curve
• Mobile: iOS app costs $25 (Android free)
• Syncing: Official sync limited, self-host required for large collections
• Customization: Powerful but complex (requires learning Anki-specific tools)

When to build your own:

• Better UX for your specific use case (language learning, medical school)
• Mobile-first experience
• Custom features (AI-generated cards, speech recognition, social features)
• Branded experience (white-label)
• Monetization (Anki is donation-funded, can’t do freemium)

When to use Anki:

• Personal use (not building an app)
• Prototyping/validation (test SRS approach before investing)
• Open-source contribution (improve Anki itself)

Advanced Concepts#

The Spacing Effect (Why This Works)#

Discovery: Hermann Ebbinghaus (1885) - information reviewed at intervals is retained longer than massed repetition

Mechanism: Distributed practice strengthens memory consolidation

Example:

• Massed practice: Study 20 times in 1 hour → 40% retention after 1 week
• Spaced practice: Study 5 times over 1 week → 80% retention after 1 week
• Result: 4× fewer reviews, 2× better retention

Why it works (cognitive science):

1. Retrieval practice: Actively recalling strengthens memory more than passive review
2. Desirable difficulty: Slight struggle during recall improves long-term retention
3. Consolidation: Time between reviews allows memory to consolidate (brain rewires)
4. Context variability: Reviewing at different times/places makes memory more robust

The Forgetting Curve Formula#

Ebbinghaus’s Forgetting Curve:

R = e^(-t/S)

Where:
- R = Retention (0-100%)
- t = Time since learning (days)
- S = Strength of memory (days)
- e = Euler's number (2.718...)

Example:

• Strong memory (S=90 days): R = 90% after 90 days
• Weak memory (S=10 days): R = 37% after 10 days

FSRS uses this formula to predict retrievability and schedule optimal review time

Optimal review interval: When R drops to 90% (configurable)

• Reviewing earlier wastes time (you still remember)
• Reviewing later risks forgetting (must relearn)

Parameter Optimization (FSRS)#

What are the 21 parameters?

FSRS has 21 weights (w₀ through w₂₀) that determine:

• How difficulty affects stability
• How retrievability changes over time
• How ratings (Again/Hard/Good/Easy) affect intervals

Default parameters: Trained on 1.7 billion reviews from 20,000 Anki users

Personalized parameters: Optimized from YOUR review history (better predictions)

How to optimize:

1. Collect review history (minimum ~1,000 reviews)
2. Run FSRS optimizer (machine learning algorithm)
3. Generates personalized 21 parameters
4. Improves accuracy by 5-15%

Anki integration: Built-in optimizer (1 click, 1-5 minutes)

Custom app: Use py-fsrs library, call optimize_parameters() function

Migration Paths#

SM-2 → FSRS (moderate complexity):

• Map Easiness Factor → Difficulty
• Map Interval → Stability
• Optimize FSRS parameters from review history
• Duration: 2-4 weeks
• Data loss: Minimal (approximations are good enough)

FSRS → SM-2 (high complexity, not recommended):

• Discard Retrievability, Difficulty nuances
• Map Stability → Interval
• Duration: 1-2 weeks
• Data loss: Significant (lossy conversion)
• Why do this: Downgrade to simpler system (cost reduction) or regulatory requirements

SM-18 → FSRS (very high complexity):

• Proprietary state, no direct mapping
• Treat as new FSRS dataset
• Optimize from scratch using review history
• Duration: 4-8 weeks
• Data loss: Complete (no state transfer)

Summary: What You Need to Know#

For Non-Technical Readers#

1. Spaced repetition is scientifically proven: 50-70% less study time for better retention
2. It’s based on the forgetting curve: Review just before you forget, maximize efficiency
3. Used by millions: Medical students, language learners, professionals
4. Daily habit: 10-20 minutes/day, sustainable long-term
5. Different algorithms exist: SM-2 (simple), FSRS (modern), SM-18 (proprietary)

For Technical Readers New to SRS#

1. Three key variables: Interval (when), Difficulty (how hard), Memory Strength (how well)
2. Stability: Core concept in modern algorithms (how long memory lasts)
3. Retrievability: Probability of successful recall at any moment
4. SM-2 vs FSRS: Simple/proven vs Modern/optimized (20-30% fewer reviews)
5. Implementation: 50 lines (SM-2) vs 100-200 lines (FSRS)

For Decision-Makers#

1. Market size: $1.23 billion (2024), growing to $4 billion by 2035
2. Proven ROI: Medical students score 12.9% higher on board exams with SRS
3. Algorithm choice matters: FSRS reduces reviews by 20-30% vs SM-2 (better retention)
4. Cost of the algorithm: nothing, for both SM-2 and FSRS. What differs is engineering capacity, not spend
5. Recommendation: SM-2 for MVP, FSRS for production (best ROI)

For Developers Building SRS Apps#

Quick start:

# SM-2 (simplest)
pip install supermemo2
from supermemo2 import SMTwo
review = SMTwo.first_review(quality=4)
review = SMTwo(review.easiness, review.interval, review.repetitions).review(4)

# FSRS (recommended for production)
pip install fsrs
from fsrs import FSRS, Card, Rating
f = FSRS()
card = Card()
scheduling_cards = f.repeat(card, now)
card = scheduling_cards[Rating.Good].card

Architecture recommendations:

1. Abstract algorithm behind interface (swappable)
2. Store review history in portable format (CSV/JSON)
3. Design for migration (SM-2 → FSRS is common path)
4. Budget 10-15% annual time for algorithm evaluation

Performance considerations:

• SM-2: Minimal compute (constant-time operations)
• FSRS: Moderate compute (parameter optimization periodically)
• Scale: Both handle millions of cards efficiently

Further Reading#

Scientific foundations:

• Ebbinghaus, H. (1885). “Memory: A Contribution to Experimental Psychology”
• Cepeda et al. (2006). “Distributed Practice in Verbal Recall Tasks: A Review and Quantitative Synthesis”

Modern research:

• FSRS Algorithm Documentation: https://github.com/open-spaced-repetition/fsrs4anki/wiki/The-Algorithm
• “The History of FSRS for Anki” (2024): https://www.lesswrong.com/posts/G7fpGCi8r7nCKXsQk

Medical education:

• “Exploring Impact of Spaced Repetition Through Anki” (2025): Class of 2026 study showing 12.9% board exam improvement

Implementation guides:

• “How to Implement SRS: Beginner’s Guide” (2025): https://techbuzzonline.com/spaced-repetition-implementation-guide/
• SuperMemo 2 Algorithm: https://super-memory.com/english/ol/sm2.htm

Market analysis:

• “Spaced Repetition Software Market Research 2033”: https://dataintelo.com/report/spaced-repetition-software-market

The Meta-Lesson#

Spaced repetition is one of the most scientifically validated learning techniques. Unlike trendy “study hacks,” it’s backed by 140 years of research, billions of review sessions, and measurable outcomes.

The algorithms are solved problems: SM-2 (1988) proved it works. FSRS (2023) optimized it with machine learning. SM-18 (2019) pushed the boundaries further.

For most applications: Use FSRS (modern, proven, free). Only optimize if profiling proves the algorithm is a bottleneck (it rarely is—content quality matters more).

The real value: Not in algorithm complexity, but in helping people learn effectively with minimal time investment. A simple SM-2 implementation that people use daily beats a perfect FSRS implementation that’s too complex to maintain.

Focus on: User experience, content quality, habit formation. The algorithm runs in the background—get it “good enough” and move on to what matters.

This explainer synthesizes research from S1 (Rapid Discovery), S2 (Technical Architecture), S3 (Use Cases), and S4 (Strategic Analysis) passes. For detailed technical specifications, benchmarks, and implementation guides, see the full research document.

Spaced Repetition Algorithms: Technical Concepts for Business Stakeholders#

Purpose: Explain spaced repetition algorithms (SM-2, SM-18, FSRS) and terminology for CTOs, PMs, and technical decision-makers evaluating SRS implementation.

What Are Spaced Repetition Algorithms?#

Spaced repetition algorithms are mathematical models that optimize the timing of review sessions to maximize long-term memory retention while minimizing study time. These algorithms calculate when a learner should review information based on how well they remembered it previously.

Analogy: If traditional studying is like watering plants on a fixed schedule, spaced repetition is like a smart irrigation system that waters each plant precisely when it needs it—less water (study time) for better results (retention).

Why Spaced Repetition Algorithms Matter#

1. Efficiency: 50-70% time reduction compared to traditional study methods
2. Retention: Scientifically proven to improve long-term memory
3. Scalability: Manages thousands of facts without overwhelming learners
4. Personalization: Adapts to individual learning patterns

Key Terminology#

Core Concepts#

Quality Ratings#

Algorithm Comparison for Business Stakeholders#

SM-2: The Classic Standard#

Release: 1988 (38 years proven) Used By: Anki (legacy), Mnemosyne, countless custom apps License: Public domain (free)

How It Works:

• Tracks 3 numbers per card: repetitions (n), easiness factor (EF), interval (I)
• Simple formula adjusts EF based on recall quality (0-5 scale)
• Interval doubles/triples each review (1 day → 6 days → 15 days → 38 days…)

Strengths:

• ✅ Simple to understand and implement (~50 lines of code)
• ✅ Zero licensing cost (public domain)
• ✅ Proven effectiveness (50-70% time savings)
• ✅ No setup required (works immediately)

Weaknesses:

• ❌ Lower performance (47-60% success rate in 2025 benchmarks)
• ❌ Assumes item difficulty never changes
• ❌ Hardcoded first intervals (1 day, 6 days) don’t account for individual differences

Best For:

• MVPs and prototypes
• Simple flashcard apps
• Budget-constrained projects
• Teams unfamiliar with ML/advanced algorithms

Example: Basic language learning app where users rate vocabulary 0-5 after each review

FSRS: The Modern ML-Driven Standard#

Release: 2023 (3 years, rapidly adopted) Used By: Anki (native since 23.10), RemNote, custom apps License: Open-source (MIT)

How It Works:

• Tracks 3 variables per card: Difficulty (D), Stability (S), Retrievability (R)
• Uses 21 parameters optimized by machine learning on user review history
• Predicts forgetting curve: R(t, S) = probability of recall at time t given stability S
• Continuously learns from user’s review patterns

Strengths:

• ✅ High performance (89.6% success rate in 2025 benchmarks)
• ✅ 20-30% fewer reviews than SM-2 for same retention
• ✅ Dynamic difficulty modeling (adapts as items become easier)
• ✅ Configurable retention target (balance workload vs retention)
• ✅ Open-source, no licensing cost

Weaknesses:

• ❌ More complex to implement (~100-200 lines of code)
• ❌ Requires parameter optimization (initial setup: 1-5 minutes per user)
• ❌ Less intuitive than SM-2 (21 parameters vs simple formula)

Best For:

• Production applications
• Language learning apps competing with Duolingo
• Medical education platforms
• Apps where user retention is critical

Example: Medical student board exam prep app that adapts to individual forgetting patterns

Sources:

• What spaced repetition algorithm does Anki use?
• FSRS vs SM-2 Guide

SM-18: The Proprietary Gold Standard#

Release: 2019 (7 years, proprietary) Used By: SuperMemo 18 (exclusive) License: Proprietary (licensing required)

How It Works:

• Two-component memory model: Stability (S) and Retrievability (R)
• Proprietary matrices track stabilization patterns
• Accounts for anchoring: new mnemonic context can convert difficult → easy overnight
• Dynamically adjusts item difficulty based on learning patterns

Strengths:

• ✅ Best-in-class performance (proprietary benchmarks claim superiority)
• ✅ Most sophisticated model (accounts for changing difficulty)
• ✅ Production-proven (SuperMemo has 30+ year track record)

Weaknesses:

• ❌ Proprietary licensing required (cost unknown publicly)
• ❌ SuperMemo exclusive (can’t integrate into custom apps easily)
• ❌ Source code not publicly available
• ❌ Not suitable for open-source projects

Best For:

• Enterprise budgets with licensing capacity
• Absolute best performance requirement
• SuperMemo integration/licensing deal

Example: Enterprise learning platform with SuperMemo licensing agreement

Sources:

• Algorithm SM-18
• SuperMemo Algorithm

Performance Benchmarks (2025)#

Success Rate Comparison#

Interpretation: FSRS is nearly on par with cutting-edge LLM methods while being practical for production

Sources:

• LECTOR: LLM-Enhanced SRS
• Benchmark of Spaced Repetition Algorithms

Review Efficiency#

FSRS vs SM-2:

• 20-30% fewer reviews for same 90% retention rate
• Example: Medical student saves 20-30 minutes/day while maintaining exam scores

SM-2 vs Traditional Methods:

• 50-70% time reduction compared to cramming or fixed-schedule review

Sources:

• What algorithm does Anki use?

Real-World Use Cases#

Medical Education (Proven ROI)#

Evidence: KKSOM Class of 2026 study (n=36 students)

Results:

• Course I: +6.4% exam performance (p < 0.001)
• Course II: +6.2% (p = 0.002)
• Course III: +7.0% (p = 0.002)
• CBSE: +12.9% (p = 0.003)
• Step 1: Daily Anki use → higher scores (p = 0.039)

Bonus: Association with increased sleep quality (p = 0.01)

Business Impact: Medical students using SRS outperform peers by 6-13% while sleeping better

Sources:

• Exploring Impact of Anki on Preclinical Performance
• PMC Article

Language Learning#

Effectiveness: 50-70% time reduction vs traditional vocabulary drills

Market Demand: Primary driver of $1.23B spaced repetition software market (2024)

Applications:

• Vocabulary acquisition
• Grammar pattern memorization
• Pronunciation practice

Sources:

• Effective SRS Language Learning

Professional Certification#

Use Cases:

• Bar exam preparation
• CPA (accounting)
• Technical certifications

Growth Driver: Post-pandemic e-learning surge

Other Applications#

• K-12 education
• Corporate training (onboarding, compliance)
• Healthcare (patient education, nursing)

What It Costs#

Only one cost in this category is a property of the algorithm.

Algorithm Licensing — the cost that decides#

SM-18’s row is not a budget line. There is no public specification and nothing outside SuperMemo’s own product implements it, so it cannot be bought into an application at any price.

What Scheduler Choice Does Not Change#

Hosting, storage, sync and maintenance scale with users and content, not with the scheduling algorithm. FSRS performs more arithmetic per review than SM-2 and at any plausible volume that difference vanishes into the cost of serving the request. You cannot save money by choosing SM-2.

What Does Differ: Engineering Capacity#

• SM-2 — ~50 lines of arithmetic, nothing to tune, no dependency required.
• FSRS — ~100-200 lines, 21 parameters, and it wants a corpus of real review history plus a periodic optimizer run to earn its advantage. That run is a batch job over history, not a per-review cost.

If nobody will run the optimizer, much of FSRS’s advantage stays unclaimed.

Where the Return Actually Lands#

FSRS’s 20-30% review reduction for equal retention is time returned to the person studying, not money saved by the operator. That is the return in this category, and it accrues to your users.

Decision Framework: Which Algorithm to Choose?#

For Fastest Time-to-Market#

→ SM-2 (~50 lines of arithmetic, nothing to tune, zero learning curve)

For Best User Retention#

→ FSRS (20-30% fewer reviews, 21 parameters, wants a corpus and an optimizer run)

For Best-in-Class Performance#

→ SM-18 (proprietary licensing, enterprise budget required)

For Open-Source Projects#

→ FSRS (modern, ML-optimized, free)

For Budget-Constrained Startups#

→ SM-2 (MVP), migrate to FSRS post-PMF (product-market fit)

Migration Paths#

SM-2 → FSRS Migration#

Complexity: Moderate Duration: 2-4 weeks

Process:

1. Export review history (CSV or database)
2. Map SM-2 state to FSRS state (EF → D/S approximation)
3. Optimize FSRS parameters using review history
4. A/B test with subset of users
5. Gradual rollout

Anki Example: Built-in migration takes 1-5 minutes per user, preserves history, can revert

Sources:

• How to use FSRS on Anki

FSRS → SM-2 Migration#

Complexity: High (data loss) Duration: 1-2 weeks

Challenge: FSRS has 3 variables (D, S, R) → SM-2 has 2 (EF, I) Data Loss: Retrievability (R) discarded, 21 parameters lost

When Necessary: Downgrading to simpler system, regulatory compliance (explainability)

SM-18 → FSRS Migration#

Complexity: Very High (proprietary state) Duration: 4-8 weeks

Challenge: SuperMemo state is proprietary, no public mapping Approach: Treat as new FSRS dataset, optimize parameters from scratch

Lock-in Risk Analysis#

Lock-in Scores (0-10 scale, 10 = highest risk)#

Analysis:

• SM-2: Minimal lock-in (public domain, simple state, widely implemented)
• FSRS: Low lock-in (open-source, active community, but 21 parameters create data migration complexity)
• SM-18: Very high lock-in (proprietary, SuperMemo exclusive, licensing required)

Market Landscape (2026)#

Market Size#

• Spaced Repetition Software: $1.23B (2024)
• Flashcard Apps (broader category): Projected $4B by 2035
• CAGR: 6.3% (2025-2035)
• Education Segment: $900M (2024)

Growth Drivers:

• Personalized/adaptive learning demand
• Scientific validation of SRS
• Expansion beyond education (healthcare, corporate training)
• Post-pandemic e-learning surge

Sources:

• SRS Market Research 2033
• Flashcard App Market 2035

Competitive Landscape#

Trend: Open-source (Anki/FSRS) vs Proprietary (SuperMemo/SM-18) competition

Strategic Recommendations#

For Startups (<10 employees, <$500K revenue)#

Phase 1 (MVP): SM-2

• Fast implementation (3-4 weeks)
• Zero licensing cost
• Validate product-market fit

Phase 2 (Post-PMF): Migrate to FSRS

• After achieving product-market fit
• 20-30% fewer reviews = competitive advantage

Why not SM-18?: Licensing cost unjustified for startups

For Mid-Market (10-100 employees, $500K-$10M revenue)#

Default Choice: FSRS

• Production-ready from day 1
• Proven performance gains
• Open-source eliminates licensing risk

Alternative: SM-2 → FSRS migration (if already using SM-2)

For Enterprise (100+ employees, $10M+ revenue)#

Default Choice: FSRS (open-source preferred)

Alternative: SM-18 (if budget allows proprietary licensing)

Avoid: SM-2 (insufficient for enterprise scale)

For Agencies/Consultancies#

Default: FSRS

• Flexibility across clients
• No licensing fees to pass through
• Modern, ML-driven

Avoid: SM-18 (client lock-in concerns)

Common Production Patterns#

Pattern 1: Language Learning App (FSRS)#

Stack: React Native + FSRS + Firebase Use Case: Vocabulary acquisition, grammar drills Why FSRS: 20-30% fewer reviews → better user retention Timeline: 4-6 months MVP → production

Pattern 2: Medical Education Platform (FSRS)#

Stack: Web app + FSRS + PostgreSQL Use Case: Board exam preparation (USMLE, COMLEX) Why FSRS: Evidence-based (Anki adoption in medical schools) Timeline: 6-9 months MVP → production

Pattern 3: Corporate Training (SM-2)#

Stack: Web app + SM-2 + Company LMS integration Use Case: Compliance training, onboarding Why SM-2: Simple, sufficient for basic retention needs Timeline: 3-6 months MVP → production

Pattern 4: K-12 Educational App (SM-2)#

Stack: Mobile app + SM-2 + Local storage Use Case: Vocabulary, math facts, science concepts Why SM-2: Simplicity valued, budget constraints (schools) Timeline: 3-4 months MVP → production

Glossary of Terms#

Resources#

Official Documentation#

• SuperMemo 2 Algorithm
• FSRS Algorithm Wiki
• SM-18 Documentation
• Anki Manual
• Open Spaced Repetition GitHub

Research Papers#

• Academic and Wellness Outcomes with Anki - 2023
• Anki Impact on Preclinical Exam Performance - 2025
• LECTOR: LLM-Enhanced SRS - 2025

Implementation Guides#

• How to Implement SRS: Beginner’s Guide
• FSRS vs SM-2 Guide
• Implementing FSRS in 100 Lines

Last Updated: 2026-01-16 Next Review: When major algorithm versions release or market share shifts significantly

Anki SM-2 (Anki’s SM-2 Variant)#

PyPI Package: anki-sm-2 GitHub: open-spaced-repetition/anki-sm-2 Algorithm: Anki’s SM-2 variant (pre-2023)

Popularity Metrics#

• Downloads: 156/month (PyPI)
• GitHub Stars: (part of open-spaced-repetition org)
• Maintenance: Active (released October 2024)
• Latest Release: v0.2.0 (October 31, 2024)
• Python Requirement: >=3.10
• License: GNU AGPL v3

Quick Assessment#

Pros:

• ✅ Anki-compatible (matches Anki’s original algorithm)
• ✅ Recent release (October 2024)
• ✅ Open Spaced Repetition org (same maintainers as FSRS)
• ✅ Clean implementation (Scheduler + Card + ReviewLog objects)

Cons:

• ⚠️ Lowest popularity (47× fewer downloads than FSRS)
• ⚠️ Legacy algorithm (Anki moved to FSRS as default in v23.10)
• ⚠️ AGPL license (more restrictive than MIT)
• ⚠️ Unclear positioning (why not use FSRS from same org?)

Installation#

pip install anki-sm-2

Basic Usage Pattern#

from anki_sm_2 import Scheduler, Card, Rating

# Initialize scheduler
scheduler = Scheduler()

# Create card
card = Card()

# Review card
scheduling_cards = scheduler.review_card(card, Rating.Good)
card = scheduling_cards[Rating.Good].card

Confidence as a Default Choice#

LOW - Same organization now recommends FSRS (their newer, better algorithm).

Notes#

Maintained by same organization that created FSRS. The fact they built FSRS suggests SM-2 is being phased out. Anki itself moved to FSRS as default in 2023.

Sources#

• anki-sm-2 PyPI
• anki-sm-2 GitHub
• Anki FAQs - What Algorithm

S1: Rapid Discovery - Approach#

Methodology: Rapid Library Search (speed-focused) Time Box: 60-90 minutes maximum Goal: Identify the default choice for a new scheduler implementation (80/20 answer)

Core Philosophy#

Get the fastest useful answer. Prioritize:

• What’s most popular/widely used?
• What has active maintenance?
• What’s easiest to implement?
• Is there obvious consensus?

Discovery Process#

1. Algorithm Landscape Scan (15 min)#

• Identify major algorithms: SM-2, FSRS, SM-18, Leitner
• Understand basic differences
• Historical adoption patterns

2. Python Implementation Search (20 min)#

• PyPI search: “spaced repetition”, “sm2”, “fsrs”
• GitHub search: Popular repositories
• Check: Last commit, stars, downloads, maintainers

3. Rapid Validation (20 min)#

• Does it install cleanly? (pip install)
• Is documentation clear?
• Can I run basic example in <5 minutes?

4. Popularity Signals (10 min)#

• PyPI download counts (pypistats.org)
• GitHub stars/forks
• Anki community consensus (r/Anki)
• Stack Overflow mentions

5. Quick Recommendation (10 min)#

• Default choice for 90% of learners
• When to consider alternatives
• Confidence level + reasoning

Evaluation Criteria#

Primary: Popularity + ease of implementation Secondary: Active maintenance + documentation quality Tertiary: Performance (if obviously problematic)

Output Files#

• approach.md (this file)
• sm2.md - SM-2 algorithm implementations
• fsrs.md - FSRS algorithm implementations
• sm18.md - SM-18 algorithm implementations (if Python impl exists)
• leitner.md - Leitner system implementations (if Python impl exists)
• recommendation.md - Final rapid choice

Success Criteria#

• Found viable Python implementations (3+ options)
• Clear popularity leader identified
• Can answer: “Which algorithm should a new review scheduler implement?”
• Total time: <90 minutes

FSRS (Free Spaced Repetition Scheduler)#

PyPI Package: fsrs GitHub: open-spaced-repetition/py-fsrs Algorithm: FSRS (2022, modern open-source)

Popularity Metrics#

• Downloads: 7,324/month (PyPI)
• GitHub Stars: 355
• Maintenance: Active (118 commits, automated testing)
• Latest Release: v6.3.0 (October 2025)
• Python Requirement: >=3.10

Quick Assessment#

Pros:

• ✅ Most popular by far (20× more downloads than alternatives)
• ✅ Active maintenance (regular releases through 2025)
• ✅ Modern algorithm (based on academic research, 2022)
• ✅ Backed by Open Spaced Repetition community
• ✅ Adopted by Anki (as of Anki 23.10, FSRS is official option)
• ✅ Well-documented with optimizer for parameters
• ✅ Evidence-based (DSR model: difficulty, stability, retrievability)

Cons:

• ⚠️ More complex (21 model weight parameters)
• ⚠️ Requires Python 3.10+ (not 3.9)
• ⚠️ Newer algorithm (less battle-tested than SM-2)

Installation#

pip install fsrs

Basic Usage Pattern#

from fsrs import FSRS, Card, Rating

# Initialize scheduler
f = FSRS()

# Create new card
card = Card()

# Schedule first review
scheduling_cards = f.repeat(card, now)

# User rates card (Again, Hard, Good, Easy)
card = scheduling_cards[Rating.Good].card

Confidence as a Default Choice#

HIGH - Clear popularity leader, active maintenance, modern algorithm with academic backing.

Sources#

• FSRS PyPI
• py-fsrs GitHub
• Open Spaced Repetition

S1 Rapid Discovery - Recommendation#

Time Spent: ~70 minutes Confidence Level: HIGH

Clear Winner: FSRS (Free Spaced Repetition Scheduler)#

Package: fsrs on PyPI Install: pip install fsrs

Why FSRS?#

Overwhelming Popularity Signal#

• 7,324 downloads/month vs 361 (supermemo2) vs 156 (anki-sm-2)
• 20-47× more popular than alternatives
• 355 GitHub stars (largest community)

Active Maintenance#

• Latest release: v6.3.0 (October 2025)
• 118 commits, automated testing
• Regular updates through 2025

Modern, Evidence-Based Algorithm#

• Based on DSR model (Difficulty, Stability, Retrievability)
• Published 2022 with academic backing
• Adopted by Anki as official algorithm (v23.10+)

Strong Ecosystem#

• Maintained by Open Spaced Repetition organization
• Same org that maintains anki-sm-2 (they built FSRS to replace SM-2)
• Well-documented with optimizer for parameters

When to Consider Alternatives#

Use supermemo2 if:#

• ❌ You need Python <3.10 support (FSRS requires 3.10+)
• ❌ You want absolute simplicity (SM-2 is simpler to understand)
• ❌ You’re implementing for historical/research purposes

Verdict: Not recommended. Lower popularity + older algorithm.

Use anki-sm-2 if:#

• ❌ You need exact Anki pre-2023 compatibility
• ❌ You’re maintaining legacy Anki integration

Verdict: Not recommended. Same org now recommends FSRS.

Default Recommendation for 90% of Learners#

Use FSRS.

• Popularity signal is decisive (47× more than next option)
• Anki’s official adoption validates effectiveness
• Active maintenance ensures long-term viability
• Modern algorithm with research backing

Implementation Path#

# Install
pip install fsrs

# Basic usage
from fsrs import FSRS, Card, Rating

f = FSRS()
card = Card()
scheduling_cards = f.repeat(card, now)

# After review
card = scheduling_cards[Rating.Good].card

Confidence Assessment#

HIGH (9/10) - Multiple strong signals converge:

• ✅ Popularity (20-47× leader)
• ✅ Anki adoption (industry validation)
• ✅ Active maintenance (2025 releases)
• ✅ Modern algorithm (research-backed)
• ✅ Community support (Open Spaced Repetition org)

Only risk: FSRS is newer (2022) vs SM-2 (1987), but Anki’s adoption mitigates this.

Sources#

• FSRS PyPI Stats - 7,324 downloads/month
• py-fsrs GitHub - 355 stars
• supermemo2 PyPI - 361 downloads/month
• SuperMemo2 GitHub - 120 stars
• anki-sm-2 PyPI - 156 downloads/month
• Anki Algorithm FAQs - Official Anki docs confirming FSRS adoption
• Open Spaced Repetition - Maintainer organization

SuperMemo2 (SM-2 Algorithm)#

PyPI Package: supermemo2 GitHub: alankan886/SuperMemo2 Algorithm: SM-2 (1987, classic)

Popularity Metrics#

• Downloads: 361/month (PyPI)
• GitHub Stars: 120
• Maintenance: Stable (last commit June 2024, 64 total commits)
• Latest Release: v3.0.1 (June 2024)
• Python Requirement: Not specified (likely 3.x)

Quick Assessment#

Pros:

• ✅ Simple algorithm (E-Factor, interval, repetition count)
• ✅ Battle-tested (used since 1987, proven effective)
• ✅ Easy to understand (5 quality ratings, simple math)
• ✅ Lightweight (minimal dependencies: attrs)
• ✅ Clean API (rewritten v3.0 removed class complexity)

Cons:

• ⚠️ Lower popularity (20× fewer downloads than FSRS)
• ⚠️ Less active maintenance (6 months since last update)
• ⚠️ Older algorithm (37 years old, surpassed by modern research)
• ⚠️ Smaller community (fewer resources, examples)

Installation#

pip install supermemo2

Basic Usage Pattern#

from supermemo2 import SMTwo

# Initialize with quality rating (0-5)
review = SMTwo.first_review(4)  # quality = 4

# Next review
review = SMTwo(review.easiness, review.interval, review.repetitions).review(4)

Confidence as a Default Choice#

MEDIUM - Works but lower popularity suggests FSRS is preferred by community.

Sources#

• supermemo2 PyPI
• SuperMemo2 GitHub

S2: Comprehensive Analysis - Approach#

Research Date: 2026-01-16 Duration: Extended technical deep-dive Focus: Mathematical formulas, memory models, implementation details

What This Pass Asks#

S1 ranked the Python packages by adoption. That answers “what do people use” and not “what is the thing doing”. S2 goes underneath the packages to the three algorithms they implement, because in this category the algorithm — not the package — is what a team is committing to. A scheduler can be reimplemented in a weekend; a review history recorded under one memory model cannot be reinterpreted under another without loss.

Method#

Primary sources only, in this order of preference:

1. The algorithm’s own specification. SM-2 is published in full on super-memory.com; FSRS’s model and parameters are documented in the fsrs4anki wiki and the reference implementation; SM-18 is described on supermemo.guru but not specified.
2. The reference implementation, where one exists and is readable — py-fsrs, anki-sm-2, sm-2.
3. Published benchmarks from the srs-benchmark repository, which is the only dataset comparing these algorithms on the same review histories.

Vendor performance claims were recorded as claims. SuperMemo’s “universal metric” results are the vendor’s own measurements of the vendor’s own closed algorithm on data nobody else can see, and are reported here as such.

What Each Algorithm File Covers#

• the memory model: what state is stored per card, and what it means
• the formulas: interval calculation, difficulty update, forgetting curve
• parameters: how many, where they come from, whether they can be fitted
• implementation size and integration surface
• what the model cannot represent

Scope Boundary#

This pass covers scheduling algorithms. Deck formats, sync protocols and review interfaces are a different category and are surveyed separately (1.142).

Performance Benchmarks (2025)#

Algorithm Success Rates#

Note: SM-18/SM-20 data not included (proprietary benchmarks)

Sources:

• LECTOR: LLM-Enhanced Concept-based Test-Oriented Repetition
• Benchmark of Spaced Repetition Algorithms

Review Efficiency#

FSRS vs SM-2:

• 20-30% fewer reviews for same retention level
• Example: 90% retention with FSRS requires 70-80% of SM-2 review count

SM-2 vs Traditional Methods:

• 50-70% time reduction compared to non-SRS methods

Sources:

• What spaced repetition algorithm does Anki use?
• FSRS vs SM-2 Guide

Comparative Technical Analysis#

Memory Model Comparison#

Formula Complexity#

SM-2: Simple arithmetic (linear EF adjustment)

• Easiest to understand and implement
• ~50 lines of code

FSRS: Moderate complexity (power functions, 21 parameters)

• Can be implemented in ~100 lines
• Requires parameter optimization (ML)

SM-18: High complexity (proprietary matrices)

• Full implementation details not publicly available
• Requires SuperMemo licensing

Implementation Comparison#

Sources:

• Implementing FSRS in 100 Lines
• GitHub - cnnrhill/sm-2

FSRS Algorithm Technical Architecture#

DSR Model (Difficulty, Stability, Retrievability)#

Origin: DHP model from MaiMemo (variant of DSR model)

Three Core Variables:

1. Retrievability (R): Probability of successful recall at given moment

   • Depends on: Time elapsed since last review, memory stability (S)

2. Stability (S): Time (days) for R to decrease from 100% to 90%

   • Example: S = 365 → entire year before recall probability drops to 90%

3. Difficulty (D): Inherent complexity of information

   • Affects: How fast stability grows after each review

Sources:

• The Algorithm
• A technical explanation of FSRS

Mathematical Formulas#

Retrievability Formula (Forgetting Curve):

R(t, S) = (1.0 + F * (t / S))^C

Where:

• F = 19.0 / 81.0 (decay factor)
• C = -0.5 (decay power)
• t = Time elapsed since review
• S = Stability

Sources:

• Implementing FSRS in 100 Lines
• The fundamental of FSRS

FSRS-6 Parameters#

Version: FSRS-6 (latest as of 2026) Parameter Count: 21 parameters (denoted as $w_i$)

Purpose: Used in formulas for D, S, and R calculations

Training: Machine learning optimizes parameters to best fit user’s review history

Sources:

• The Algorithm
• Technical Principles of FSRS

Implementation Details#

Card State:

• Retrievability: Computed dynamically
• Stability: Property of card object (persistent)
• Difficulty: Property of card object (persistent)

Algorithm Flow:

1. Calculate current retrievability (R)
2. Update stability (S) and difficulty (D) after review
3. Calculate next review interval
4. Schedule card for that day

Sources:

• Implementing FSRS in 100 Lines
• ABC of FSRS

Training Data#

• Initial (2023): 700M reviews from 20K users
• Current (2026): ~1.7B reviews from 20K Anki users

Sources:

• The History of FSRS for Anki

Integration Complexity#

SM-2 Integration#

Complexity: Low

• Simple state (3 variables per card)
• No training required
• Stateless (no cross-card dependencies)

Typical Integration Steps:

1. Install library: pip install supermemo2
2. Initialize card state (n=0, EF=2.5, I=0)
3. After each review: Pass quality (0-5), get next interval
4. Store updated state

Code Example (pseudocode):

from supermemo2 import SMTwo

card = SMTwo(quality=0, interval=0, repetitions=0, efactor=2.5)
quality = 4  # User rated "correct after hesitation"
card.review(quality)
next_interval = card.interval  # Days until next review

Sources:

• supermemo2 · PyPI
• GitHub - thyagoluciano/sm2

FSRS Integration#

Complexity: Moderate

• Complex state (D, S, R per card)
• Requires parameter optimization (initial training)
• Benefits from large review history dataset

Typical Integration Steps:

1. Install library: pip install fsrs
2. Collect user review history (if available)
3. Optimize 21 parameters using ML (or use defaults)
4. Initialize card state (D, S)
5. After each review: Calculate R, update D/S, get next interval
6. Periodically re-optimize parameters

Anki Integration (built-in as of 23.10):

• Toggle FSRS in Deck Options → Advanced section
• Anki auto-optimizes parameters from review history
• Migration: 1-5 minutes depending on deck size

Sources:

• How to use FSRS on Anki
• ABC of FSRS

SM-18 Integration#

Complexity: Not Applicable (Proprietary)

• Requires SuperMemo license
• Source code not publicly available
• Integration only possible via SuperMemo API (expected 2026)

Sources:

• SuperMemo Algorithm FAQ

Production Considerations#

Scalability#

SM-2:

• ✅ Scales to millions of cards (stateless, simple calculations)
• ✅ Constant-time operations
• ✅ No training required

FSRS:

• ✅ Scales to millions of cards (per-card state)
• ⚠️ Parameter optimization requires significant review history
• ⚠️ Retraining becomes expensive with large datasets

SM-18:

• ✅ Production-proven in SuperMemo
• ⚠️ Proprietary licensing required

Observability#

SM-2:

• Simple metrics: EF distribution, interval distribution
• Easy to debug (few variables)

FSRS:

• Complex metrics: D/S/R distributions, parameter values
• Requires visualization tools for debugging
• FSRS Helper add-on provides observability

Sources:

• FSRS Helper

Maintenance Burden#

Python Library Implementations#

SM-2 Libraries#

1. anki-sm-2 (GitHub: open-spaced-repetition)

   • Implements Anki’s SM-2-based algorithm
   • Available on PyPI
   • Active maintenance

2. sm-2 (GitHub: open-spaced-repetition)

   • Standalone SM-2 implementation
   • Minimal dependencies

3. supermemo2 (PyPI)

   • Pure Python implementation
   • Simple API

Sources:

• GitHub - anki-sm-2
• GitHub - sm-2
• supermemo2 · PyPI

FSRS Libraries#

1. fsrs-rs-python

   • Python bindings for fsrs-rs (Rust implementation)
   • Size: 6MB (vs 2GB pure Python)
   • Performance optimized

2. py-fsrs

   • Pure Python implementation
   • Optimization-focused

3. fsrs4anki

   • Anki integration
   • Includes helper utilities
   • Active development

Sources:

• Open Spaced Repetition GitHub
• GitHub - fsrs4anki

Library Comparison#

Summary#

SM-2 Strengths#

• ✅ Simplicity (50 lines of code)
• ✅ Zero-configuration
• ✅ Well-understood (40+ years of use)
• ✅ No training required
• ❌ Lower performance (47-60% success rate)
• ❌ Static difficulty assumption

FSRS Strengths#

• ✅ High performance (89.6% success rate)
• ✅ 20-30% fewer reviews than SM-2
• ✅ Dynamic difficulty modeling
• ✅ Open-source, ML-optimized
• ❌ More complex (100-200 lines, 21 parameters)
• ❌ Requires optimization step

SM-18 Strengths#

• ✅ Most advanced model (two-component memory)
• ✅ Dynamic difficulty (anchoring effects)
• ✅ Production-proven (SuperMemo)
• ❌ Proprietary (licensing required)
• ❌ Not available for open-source projects
• ❌ No public benchmarks

Research Duration: 3 hours Primary Sources: Official documentation, mathematical papers, implementation guides Confidence Level: High for SM-2 and FSRS, Medium for SM-18 (proprietary, limited public info)

SM-18 Algorithm Technical Architecture#

Two-Component Model of Memory#

Fundamental Variables:

1. Stability (S): Duration of memory if undisturbed (measured in days)
2. Retrievability (R): Probability of successful recall at any given time

Theory: Two variables are sufficient to describe the status of unitary memory

Sources:

• Two components of memory
• Algorithm SM-17

Key Improvements Over SM-17#

1. Dynamic Item Difficulty: Departure from assumption that difficulty is constant

   • Evidence: Dramatic changes in item difficulty during learning
   • Explanation: Anchoring - new mnemonic context converts difficult → easy overnight

2. Improved Stabilization Function: Better approximation of memory stability increase

3. Parameter Optimizations: Several minor tuning improvements

Sources:

• Algorithm SM-18
• SuperMemo Algorithm

Stabilization Function#

Inputs:

• Stability at review (S, in days)
• Retrievability at review (R)
• Memory complexity (item difficulty)

Outputs:

• New stability (S')

Implementation: Uses memory matrices:

• Stabilization matrix (SInc[]): Stores stability increase factors
• Recall matrix (Recall[]): Stores recall probabilities

Sources:

• Algorithm SM-18
• Stabilization

Release and Status#

• Release Date: 2019 (May)
• Used in: SuperMemo 18
• Predecessor: SM-17 (2016) - first two-component model implementation
• Availability: Proprietary (licensing required)

Sources:

• SuperMemo - Wikipedia
• SuperMemo Algorithm

SM-2 Algorithm Technical Architecture#

Mathematical Foundation#

Core Formula: Easiness Factor (EF)

EF' = EF + (0.1 - (5-q) * (0.08 + (5-q) * 0.02))

Where:

• EF' = New easiness factor
• EF = Old easiness factor
• q = Quality of response (0-5 grade scale)

Initial Values:

• All items start with EF = 2.5
• Minimum allowed: EF = 1.3 (if calculated EF < 1.3, set to 1.3)

Sources:

• SuperMemo 2: Algorithm
• SM-2 Algorithm Explained

Interval Calculation#

I(1) = 1 day
I(2) = 6 days
For n > 2: I(n) = I(n-1) * EF

Where:

• I(n) = Inter-repetition interval after the n-th repetition (in days)
• EF = E-Factor of the item

Sources:

• SuperMemo 2: Algorithm

Quality Rating Scale (0-5)#

Logic:

• If q >= 3 (correct): Proceed with normal interval progression
• If q < 3 (incorrect): Reset n = 0, I = 1, EF unchanged

Sources:

• SM-2 Algorithm Explained
• SATHEE: SM-2 Algorithm

Three Core Variables#

1. Repetition Number (n): Count of successful reviews
2. Easiness Factor (EF): Difficulty rating (1.1 to 2.5)
3. Interval (I): Days until next review

Limitations#

1. Hardcoded Initial Intervals: 1-day and 6-day first intervals don’t account for individual differences
2. Static Difficulty: Assumes item difficulty is constant over time
3. Coarse Granularity: 6-point scale (0-5) lacks nuance
4. No Forgetting Curve: Doesn’t model retrievability probability

Sources:

• Application of a computer to improve results

S3: Need-Driven Discovery - Approach#

Research Date: 2026-01-16 Focus: Production use cases, cost analysis, framework selection criteria Audience: Product managers, CTOs, application developers

What This Pass Asks#

S2 established what the algorithms do. S3 asks who chooses which one, and on what grounds — which is rarely the benchmark number. A scheduling algorithm is chosen under constraints that have nothing to do with retention curves: what the team can maintain, what the license permits, what the review history already contains, and what the product can afford to get wrong.

Method#

Use cases were drawn from documented deployments rather than from imagination. Where a segment had peer-reviewed evidence, that evidence is cited with its sample size and p-values; where it did not, the segment is described as a pattern without a number attached.

Cost figures come from published 2026 development-cost surveys and from the providers’ own posted pricing. They are order-of-magnitude planning figures, not quotes, and are labeled as such.

Personas Covered#

Each is a WHO with a WHY — a constraint that changes the answer, not a market segment:

• Medical education — the segment with the strongest published evidence, and the one where review volume is high enough that a 20-30% reduction is felt
• Language learning — long retention horizons, very large decks, and the segment where the 50-70% time-reduction figure originates
• Professional certification — fixed exam date, so scheduling is optimized against a deadline rather than against indefinite retention
• K-12 and corporate training — the learner did not choose to be there, which changes what a scheduler is allowed to demand
• Teams shipping an MVP — where implementation cost dominates every other consideration

Scope Boundary#

This is a survey of the category, so the personas are the category’s readers. It does not recommend an algorithm for any one product; it says which constraints push toward which algorithm.

Decision Tree#

1. Are you building an MVP or prototype?
   ├─ Yes → SM-2 (fast, simple, proven)
   └─ No → Go to 2

2. Do you have >10K expected users?
   ├─ Yes → Go to 3
   └─ No → SM-2 (sufficient for small scale)

3. Is user retention critical to business model?
   ├─ Yes → FSRS (20-30% fewer reviews → better retention)
   └─ No → SM-2 (cost-effective)

4. Do you have review history data for training?
   ├─ Yes → FSRS (optimize from day 1)
   └─ No → SM-2 initially, migrate to FSRS after 3-6 months

5. Is licensing cost acceptable?
   ├─ Yes → Evaluate SM-18 (best performance, but licensing fees)
   └─ No → FSRS (open-source, no licensing)

6. Is open-source a requirement?
   ├─ Yes → SM-2 or FSRS only
   └─ No → FSRS or SM-18

Cost of Ownership#

Only one cost in this category is a property of the algorithm. The rest is the cost of running any application, and it does not vary with the scheduler you pick — so it cannot help you choose one.

Algorithm Licensing — the cost that actually decides#

This is the whole cost story, and it is a stark one. Two of the three algorithms are free — one because it has been in the public domain since 1988, the other because its authors gave it away under MIT. The third cannot be obtained at any published price, which is a fact about availability rather than about budget: SM-18 has no public specification and no third-party implementation, so it is not something a team can decide to afford.

Strategic implication: licensing is not a line item in this category unless you are choosing SM-18, and choosing SM-18 is not really a licensing decision — it is a decision to build inside SuperMemo’s product.

What Scheduler Choice Does Not Change#

Hosting, database, storage and maintenance are costs of running an application. They scale with users and media, not with the scheduling algorithm. FSRS does more arithmetic per review than SM-2, and at any plausible review volume that difference is lost in the noise of everything else a request does.

Two consequences worth stating, because they are the ones people get backwards:

• You cannot save money by choosing SM-2. The saving people imagine — a simpler algorithm, cheaper to run — does not exist at application scale.
• You can save reviews by choosing FSRS, which is a cost borne by your users rather than by you: 20-30% fewer reviews for the same retention. If anything in this category has an ROI, that is where it is, and it is measured in other people’s time.

Storage, For Sizing Rather Than Budgeting#

Roughly 1-5 MB per active user for cards and review history; media (audio, images) dominates that wherever it is present and is unrelated to scheduling. Useful for capacity planning, not for choosing an algorithm.

Removed 2026-08-25: this file previously carried hosting tiers, database pricing, per-GB storage rates, and an annual-maintenance-as-percentage rule, alongside sibling files of app-development budgets and revenue projections. They came from third-party app-cost marketing surveys, they were not specific to spaced repetition, and none of them bore on the SM-2/FSRS/SM-18 choice this survey exists to inform. See the survey’s metadata for the record.

Market Positioning Recommendations#

For Language Learning Apps#

Algorithm: FSRS Rationale:

• 20-30% fewer reviews → better user retention
• Competitive with Duolingo, Memrise (both using advanced SRS)
• Open-source avoids licensing costs
• ML-driven optimization appeals to users

Timeline: 4-6 months MVP → production

For Medical Education Apps#

Algorithm: FSRS (or SM-2 for MVP) Rationale:

• Medical students already familiar with Anki (FSRS native since 23.10)
• Performance critical (board exam preparation)
• Evidence-based (multiple studies supporting efficacy)

Timeline: 6-9 months MVP → production

For Corporate Training Apps#

Algorithm: SM-2 (simple) or FSRS (if budget allows) Rationale:

• Focus on compliance/onboarding (lower engagement than language learning)
• SM-2 sufficient for basic retention needs
• FSRS if competing on user experience

Timeline: 3-6 months MVP → production

For K-12 Educational Apps#

Algorithm: SM-2 Rationale:

• Simplicity valued over optimization
• Lower budget constraints (schools)
• Proven effectiveness (50-70% time reduction)

Timeline: 3-4 months MVP → production

Summary: Choosing an Algorithm#

For the fastest route to something working#

→ SM-2. About fifty lines of arithmetic, no parameters to fit, no dependency required. Public domain.

For the best retention per review#

→ FSRS. 20-30% fewer reviews for the same retention, and the reduction falls on your users’ time rather than your budget. MIT, actively released, and the algorithm Anki itself adopted in 23.10.

For best-in-class benchmark performance#

→ SM-18 — and note this is not a purchasable option. No public specification, no third-party implementation, licensing terms not published. Treat it as the reference point the others are measured against.

For open-source projects#

→ FSRS. The only modern option whose license permits it.

For a team that expects to migrate later#

→ SM-2 first, FSRS after. That direction is the cheap one: SM-2 state maps into FSRS with minimal loss, and the reverse discards difficulty and stability irrecoverably. Migration asymmetry, not implementation cost, is the reason to sequence it this way.

Research Duration: 2 hours Primary Sources: Academic studies, algorithm specifications, open-source benchmarks Confidence Level: High for algorithm behavior and licensing; the medical-education effect sizes carry their own sample sizes and p-values in use-cases.md.

Algorithm Selection Decision Framework#

Step 1: Define Complexity Needs#

Use SM-2 if:

• MVP/prototype stage
• A small team, or one person
• Simple use case (flashcards only)
• No personalization required
• Team has limited ML expertise

Use FSRS if:

• Production app
• Enough engineering capacity to fit and monitor parameters
• Need performance optimization (20-30% fewer reviews)
• Willing to invest in parameter optimization
• Have user review history data

Use SM-18 if:

• Licensed SuperMemo integration
• Budget allows proprietary licensing
• Need absolute best performance
• Not building open-source product

Step 2: Assess Technical Requirements#

Implementation Complexity:

Performance Requirements:

Step 3: Evaluate Team Constraints#

Team Size:

• Solo/Small (1-3): SM-2 (fast, simple)
• Medium (3-10): FSRS (balance of performance and complexity)
• Large (10+): FSRS or SM-18 (resources for optimization)

Team Expertise:

• Beginners: SM-2 (minimal learning curve)
• Intermediate: FSRS (moderate ML familiarity helpful)
• Advanced: FSRS or SM-18 (full optimization capability)

Open-Source Requirement:

• Yes: SM-2 or FSRS only
• No: SM-2, FSRS, or SM-18

Step 4: Budget Considerations#

Development Budget:

• Neither SM-2 nor FSRS costs anything to license. The budget question people ask here has no answer, because there is no price to compare.
• What differs is engineering capacity, not spend: SM-2 is ~50 lines and needs no tuning; FSRS is ~100-200 lines, has 21 parameters, and wants a review corpus and an optimizer run to be worth its advantage.
• SM-18 is not a budget tier. It has no public specification and no third-party implementation, so it cannot be bought into an application.

Operating Budget (per 10K active users):

• FSRS does more arithmetic per review than SM-2. At any plausible review volume the difference disappears into the cost of serving the request.
• Parameter optimization is a periodic batch job over review history, not a per-review cost. Run it monthly, not on the request path.
• SM-18: Unknown (licensing fees)

Production Use Cases#

Medical Education (Primary Use Case)#

Adoption Scale: Widespread across medical schools globally

Recent Research (2026 Class):

• Kirk Kerkorian School of Osteopathic Medicine (KKSOM) class of 2026 study (n=36)
• Results: Anki use correlated with increased CBSE exam performance
• Metrics: Higher matured card counts → higher exam scores

Performance Gains:

• Course I: +6.4% (p < 0.001)
• Course II: +6.2% (p = 0.002)
• Course III: +7.0% (p = 0.002)
• CBSE: +12.9% (p = 0.003)

Board Exam Correlation:

• Daily Anki use → increased Step 1 scores (p = 0.039)
• No significant correlation with Step 2 scores

Wellness Benefits:

• Association with increased sleep quality (p = 0.01)

Sources:

• Exploring Impact of Spaced Repetition Through Anki - 2025
• PMC Article on Preclinical Exam Performance
• Academic and Wellness Outcomes - 2023

Language Learning#

Market Demand: Core driver of SRS market growth

Effectiveness: 50-70% time reduction vs traditional methods

Popular Applications:

• Vocabulary acquisition
• Grammar pattern memorization
• Pronunciation practice
• Reading comprehension

Sources:

• Effective SRS Language Learning Guide
• Best Language Learning Apps with SRS 2025

Professional Certification#

Use Cases:

• Bar exam preparation (legal)
• CPA exam (accounting)
• Professional certification programs
• Technical skill retention

Growth Driver: Post-pandemic e-learning surge

Other Applications#

1. Academic Learning: K-12 and university courses
2. Corporate Training: Employee onboarding, compliance training
3. Personal Development: Skill acquisition, hobby learning
4. Healthcare: Patient education, medical terminology for nurses

Sources:

• Spaced Repetition Software Market Research 2033

S4: Strategic Selection - Approach#

Research Date: 2026-01-16 Focus: Vendor lock-in risk, migration complexity, market consolidation trends Audience: CTOs, technical strategists, product leads

What This Pass Asks#

Not “which is best today” but “what does this choice cost to reverse in three years”. In spaced repetition the reversal cost is unusually asymmetric, and that asymmetry is the most decision-relevant fact in the whole survey: review history recorded under one memory model does not translate cleanly into another.

Method#

Lock-in is scored across five dimensions — algorithm, data, platform, ecosystem and knowledge — each 0-10, and the total is reported rather than averaged so a single catastrophic dimension is visible instead of diluted.

Migration paths are assessed in both directions. A path that is cheap one way and impossible the other is a lock-in finding, not a migration finding, and is reported as such.

Longevity signals used: release cadence over the last three years, number of independent implementations, whether the specification is public, and whether the algorithm survives its originator disappearing.

What This Pass Does Not Do#

It does not forecast which algorithm wins. The 5- and 10-year outlook sections state what would have to happen for each outcome, and what a reader should watch for, rather than assigning probabilities to a market nobody can measure.

Exit Strategy Planning#

What If Your Algorithm Becomes Obsolete?#

Scenario 1: FSRS Superseded by FSRS v2/v3

Likelihood: Moderate (iterative improvements expected)

Mitigation:

1. Open-source nature ensures smooth upgrades
2. Parameters can be re-optimized
3. No vendor lock-in (can fork if needed)

Scenario 2: SuperMemo Discontinues SM-18

Likelihood: Low (but possible)

Mitigation:

1. License agreement should include source code escrow
2. Plan migration to FSRS (4-8 weeks)
3. Maintain abstraction layer in codebase

Scenario 3: Regulatory Requirements Force Algorithm Change

Likelihood: Very Low (but considered in healthcare/education)

Mitigation:

1. Explainability: SM-2 > FSRS > SM-18
2. If required, fallback to SM-2 (simple, auditable)
3. Budget 1-2 weeks for migration

General Exit Strategy#

Every 12 months:

1. Audit Algorithm Performance: Benchmark against latest research
2. Evaluate Alternatives: Monitor new algorithms (LECTOR, SSP-MMC, etc.)
3. Maintain Abstraction: Keep algorithm swappable
4. Document State: Clear mapping of algorithm state to universal format (CSV)

Red Flags (trigger exit planning):

• Community activity drops >50% YoY (FSRS risk)
• Licensing fees increase >20% YoY (SM-18 risk)
• Major security vulnerability discovered
• Regulatory compliance issues

Algorithm Vendor Lock-in Analysis#

Lock-in Risk Dimensions#

5 Lock-in Categories:

1. Algorithm Lock-in: Switching cost if algorithm is proprietary
2. Data Lock-in: Export/import difficulty for review history
3. Platform Lock-in: Mobile vs web vs desktop compatibility
4. Ecosystem Lock-in: Integrations, add-ons, community
5. Knowledge Lock-in: Team expertise in specific algorithm

Algorithm Lock-in Scores (0-10, 10 = highest lock-in)#

Analysis:

• SM-2: Minimal lock-in (public domain, simple state, widely implemented)
• FSRS: Low lock-in (open-source, but 21 parameters create data migration complexity)
• SM-18: Very high lock-in (proprietary, SuperMemo exclusive, no public implementation)

Portability Solutions#

Data Export Standards:

• Anki: .apkg format (open, well-documented)
• SuperMemo: .kno format (proprietary)
• Universal: CSV export (lowest common denominator)

Algorithm Abstraction:

• Design abstraction layer: separate algorithm logic from app logic
• Enables swapping SM-2 ↔ FSRS without full rewrite

State Migration:

• SM-2 → FSRS: Moderate complexity (map EF to D/S)
• FSRS → SM-2: High complexity (loss of D/S granularity)
• SM-18 → anything: Impossible (proprietary state)

Algorithm Comparison: Long-Term Strategy#

5-Year Outlook#

SM-2:

• ✅ Will remain viable for MVPs, simple use cases
• ✅ Public domain ensures eternal availability
• ⚠️ Competitive disadvantage vs FSRS (20-30% fewer reviews)

FSRS:

• ✅ Likely to become industry standard (Anki adoption drives this)
• ✅ Open-source community ensures ongoing development
• ✅ ML-driven optimization improves over time
• ⚠️ Potential disruption from LECTOR or next-gen algorithms

SM-18:

• ✅ Best performance (until SM-19/SM-20 if released)
• ⚠️ Licensing model limits ecosystem growth
• ⚠️ Proprietary nature creates dependency on SuperMemo

10-Year Outlook#

Prediction: FSRS variants dominate open-source SRS apps

Reasoning:

1. Anki’s multi-million user base drives FSRS adoption
2. Open-source enables rapid iteration (FSRS-6 → FSRS-7+)
3. ML-driven optimization aligns with AI/ML trends
4. SuperMemo’s proprietary model limits SM-18 adoption

Wild Card: LLM-enhanced SRS (LECTOR-style) may disrupt entirely

• LECTOR (2025): 90.2% success rate (vs FSRS 89.6%)
• Combines LLM reasoning with traditional SRS
• Requires significant compute (cost barrier for now)

Sources:

• LECTOR: LLM-Enhanced SRS

Market Trends (2026)#

Spaced Repetition Software Market#

Market Size:

• 2024: USD $1.23 billion
• Growth Driver: Personalized/adaptive learning demand, scientific validation of SRS

Flashcard App Market (broader category including SRS):

• 2035 Projection: USD $4 billion
• CAGR: 6.3% (2025-2035)
• Education Segment (2024): $900M

Sources:

• Spaced Repetition Software Market Research 2033
• Flashcard App Market Size 2035

Growth Drivers#

1. Post-Pandemic E-Learning Surge: Accelerated SRS adoption
2. Smartphone Proliferation: Mobile-first SRS apps dominant
3. Scientific Validation: Growing research supporting efficacy
4. Expansion Beyond Education: Healthcare, professional certification, corporate training

Sources:

• Spaced Repetition Software Market Research 2033

Competitive Landscape#

Market Leaders:

1. Anki: Open-source, millions of users, FSRS native (since 23.10)
2. SuperMemo: Proprietary, SM-18 algorithm, licensing model
3. Memrise: Freemium, custom algorithm (likely SM-2 variant)
4. Duolingo: Language-focused, custom SRS (advanced)
5. Quizlet: Freemium, basic SRS features

Open-Source Dominance:

• Anki’s open-source model drives innovation (FSRS integration)
• Community-driven development vs proprietary SuperMemo

Migration Paths & Complexity#

SM-2 → FSRS Migration#

Complexity: Moderate

Steps:

1. Export review history (CSV or database dump)
2. Map SM-2 state to FSRS state:
   • Easiness Factor (EF) → Difficulty (D) approximation
   • Interval (I) → Stability (S) approximation
3. Optimize FSRS parameters using review history
4. Test with subset of users (A/B test)
5. Gradual rollout

Duration: 2-4 weeks

Data Mapping:

D (Difficulty) ≈ f(EF)  // Lower EF → Higher D
S (Stability) ≈ I       // Interval approximates stability
R (Retrievability) = 0.9  // Initial assumption

Anki Example:

• Built-in migration: 1-5 minutes per user
• Preserves review history
• Can revert to SM-2 if needed

Sources:

• How to use FSRS on Anki
• FSRS vs SM-2 Guide

FSRS → SM-2 Migration#

Complexity: High (data loss)

Challenge: FSRS has 3 variables (D, S, R) → SM-2 has 2 (EF, I)

Data Loss:

• Retrievability (R) discarded
• Difficulty (D) → Easiness Factor (EF) mapping lossy
• 21 parameters lost

When Necessary:

• Downgrading to simpler system (cost reduction)
• Moving to platform that only supports SM-2
• Regulatory/compliance requirements (explainability)

Duration: 1-2 weeks

SM-18 → FSRS Migration#

Complexity: Very High (proprietary state)

Challenge: SuperMemo state is proprietary, no public mapping

Approach:

1. Export review history from SuperMemo (if allowed by license)
2. Treat as new FSRS dataset
3. Optimize FSRS parameters from scratch
4. No direct state transfer possible

Duration: 4-8 weeks (mostly re-training)

Migration Strategy Matrix#

Open Standards & Future-Proofing#

Emerging Standards (2026)#

No Universal SRS Standard Yet, but trends:

1. Open Review History Format: CSV/JSON export becoming standard
2. Anki .apkg Format: De-facto standard for flashcard apps
3. FSRS Influence: Other apps adopting FSRS or FSRS-inspired algorithms

Future Possibility: W3C or IEEE standard for SRS data exchange (not yet proposed)

Future-Proofing Checklist#

Data Architecture:

• Store review history in platform-agnostic format (CSV/JSON)
• Avoid proprietary binary formats
• Document data schemas

Code Architecture:

• Abstract algorithm behind interface (Strategy pattern)
• Avoid hardcoding algorithm-specific logic throughout codebase
• Use standard formats for state serialization

Deployment Architecture:

• Containerize (Docker) for platform-agnostic deployment
• Avoid vendor-specific APIs (AWS-only, Azure-only)
• Use infrastructure-as-code (Terraform, Pulumi)

Team Architecture:

• Cross-train team on multiple algorithms
• Maintain documentation of algorithm-specific decisions
• Budget 10-15% annual time for algorithm evaluation

Summary: Lock-in Risk Mitigation#

Lowest Risk Algorithms#

1. SM-2: Zero lock-in (public domain, simple state, widely implemented)
2. FSRS: Low lock-in (open-source, active community, Anki integration)

Highest Risk Algorithm#

1. SM-18: Very high lock-in (proprietary, SuperMemo exclusive, licensing required)

Best Practices#

For Startups: Use SM-2 (MVP), migrate to FSRS post-PMF For Mid-Market: Use FSRS (balance of performance and flexibility) For Enterprise: Use FSRS (open-source preferred) or SM-18 (if licensing budget allows)

Universal Rule: Maintain abstraction layer and data portability to enable migration if needed

Research Duration: 2.5 hours Primary Sources: Market reports, algorithm documentation, migration case studies Confidence Level: High for migration paths, Medium for 10-year predictions (inherently uncertain)

Framework Stability & Longevity#

Algorithm Maturity#

Analysis:

• SM-2: Decades of use, no updates needed (stable algorithm)
• SM-18: Proprietary, but SuperMemo has 30+ year track record
• FSRS: Rapid development, but open-source community ensures continuity

Community Support#

SM-2:

• ✅ Massive ecosystem (Anki, Mnemosyne, custom implementations)
• ✅ Public domain (no licensing risk)
• ✅ Well-understood (extensive documentation)

FSRS:

• ✅ Growing ecosystem (Anki native, RemNote, third-party apps)
• ✅ Open-source (MIT license, GitHub: open-spaced-repetition org)
• ✅ Active development (2023-2026, ongoing improvements)

SM-18:

• ⚠️ SuperMemo exclusive
• ⚠️ Proprietary licensing
• ⚠️ Limited third-party implementations (licensing restrictions)

Funding & Backing#

SM-2: N/A (public domain) FSRS: Community-funded (open-source, no corporate backing needed) SM-18: SuperMemo company (profitable, 30+ year history)

Risk Assessment:

• SM-2: Zero risk (public domain, can’t be discontinued)
• FSRS: Low risk (open-source, forkable, active community)
• SM-18: Low-Moderate risk (dependent on SuperMemo business continuity)

Strategic Recommendations#

For Startups (<10 employees, <$500K revenue)#

Phase 1 (MVP): SM-2

• Fast implementation (3-4 weeks)
• Zero licensing cost
• Validate product-market fit

Phase 2 (Post-PMF): Migrate to FSRS

• After achieving product-market fit
• User retention becomes critical
• 20-30% review reduction = competitive advantage

Why not SM-18?: Licensing cost unjustified for startups

For Mid-Market (10-100 employees, $500K-$10M revenue)#

Default Choice: FSRS

• Production-ready from day 1
• Proven performance gains
• Open-source eliminates licensing risk

Alternative: SM-2 → FSRS migration

• If already using SM-2, plan migration within 6-12 months
• Budget 2-4 weeks of engineering for the migration

For Enterprise (100+ employees, $10M+ revenue)#

Default Choice: FSRS

• Open-source preferred (no vendor lock-in)
• Community support + internal expertise

Alternative: SM-18 (via SuperMemo licensing)

• If best-in-class performance required
• Budget allows proprietary licensing
• Compliance/audit requirements met by SuperMemo

Avoid: SM-2 (insufficient for enterprise scale)

For Agencies/Consultancies#

Default: FSRS

• Flexibility across clients
• No licensing fees to pass through
• Modern, ML-driven (appeals to clients)

Avoid: SM-18 (client lock-in concerns)