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 for Personal Language Learning#

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 clear winner for personal language learning use case (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: “What should I use for my language learning app?”
• 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 for Personal Language Learning#

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 for Personal Language Learning#

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

Sources#

• supermemo2 PyPI
• SuperMemo2 GitHub

S2-Comprehensive: Technical Architecture Analysis#

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

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

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

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

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

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

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#

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#

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)

S3-Need-Driven: Use Cases and Decision Criteria#

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

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

Development Costs (2026)#

SRS App Development Budget#

Budget Ranges:

Sources:

• App Development Costs 2026
• Education App Development Cost 2026
• How Much Does Education App Cost

General Mobile App Development Costs (2026)#

Industry Averages:

• Overall range: $40,000-$400,000+
• Average: $80,000-$250,000
• Simple apps: $5,000-$50,000 (few screens, minimal backend)
• Medium complexity: $50,000-$180,000 (richer UX, integrations)
• Complex apps: $100,000-$500,000+ (custom backends, third-party integrations)

Sources:

• Mobile App Development Cost 2026
• Complete Pricing Guide

Educational App Specific Costs#

Range: $30,000-$600,000+

By Type:

• Content-focused: $30,000-$100,000
• Interactive: $100,000-$300,000
• AI-driven: $200,000-$600,000+

Sources:

• Cost to Build Education App 2026
• eLearning App Development Costs 2026

MVP Development Timeline#

4-Week SRS MVP Plan:

Week 1: Data model and local persistence

• Establish interfaces for decks, notes, and cards
• Budget: ~$7,500-$15,000

Week 2: Basic scheduling function

• Implement simplified SM-2
• Create review interface
• Budget: ~$7,500-$15,000

Week 3: User experience features

• Onboarding and daily review features
• Notification systems
• Budget: ~$7,500-$15,000

Week 4: Import/export and analytics

• Export/import functionalities
• Metrics dashboard
• Budget: ~$7,500-$15,000

Total MVP Budget: $30,000-$60,000 (4 weeks)

Sources:

• How to Implement SRS: Beginner’s Guide

Cost-Saving Strategies#

Cross-Platform Development:

• React Native or Flutter
• Savings: 30-40% lower cost vs native (iOS + Android separately)
• Trade-off: Near-native performance, single codebase

Open-Source Algorithms:

• Use SM-2 (zero licensing cost)
• Use FSRS (open-source, free)
• Savings: Avoid SuperMemo licensing fees

Cloud vs Self-Hosted:

• Self-hosted (AWS, DigitalOcean): $50-$500/month
• Managed services (Firebase, Supabase): $100-$2,000/month
• Trade-off: Management complexity vs convenience

Sources:

• Mobile App Development Cost 2026

Operating Costs#

Infrastructure Costs#

Backend Hosting:

• Tier 1 (MVP): $50-$200/month (DigitalOcean droplet, AWS t3.medium)
• Tier 2 (Growth): $200-$1,000/month (Load balancing, database scaling)
• Tier 3 (Scale): $1,000-$10,000+/month (Multi-region, CDN, high availability)

Database:

• SQLite (local): $0 (mobile-only, no sync)
• PostgreSQL (hosted): $15-$500/month (Supabase, AWS RDS)
• Firebase: Free tier, $25-$500/month (scale-dependent)

Storage:

• User data: ~1-5MB per active user (cards, review history)
• Media (images, audio): Variable (10-100MB per user for language apps)
• Cost: $0.023/GB/month (S3), $0.01-$0.03/GB (CDN transfer)

Algorithm Licensing#

Strategic Implication: Open-source dominance (SM-2, FSRS) eliminates licensing costs for startups

Maintenance Costs#

Annual Maintenance: 15-20% of development cost

• Example: $100K app → $15K-$20K/year

Breakdown:

• Bug fixes: 30-40%
• OS updates (iOS/Android): 20-30%
• Feature enhancements: 30-40%
• Security patches: 10-20%

Algorithm Selection Decision Framework#

Step 1: Define Complexity Needs#

Use SM-2 if:

• MVP/prototype stage
• Tight budget (<$50K)
• Simple use case (flashcards only)
• No personalization required
• Team has limited ML expertise

Use FSRS if:

• Production app
• Moderate budget ($80K+)
• 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:

• <$50K: SM-2 (MVP, simple implementation)
• $50K-$150K: FSRS (production-ready)
• >$150K: FSRS with advanced features, or explore SM-18 licensing

Operating Budget (per 10K active users):

• SM-2: $200-$500/month (minimal compute)
• FSRS: $300-$800/month (parameter optimization compute)
• SM-18: Unknown (licensing fees)

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

Budget: $100K-$200K development 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)

Budget: $150K-$300K development (includes specialized medical content management) 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

Budget: $50K-$150K development 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)

Budget: $30K-$80K development Timeline: 3-4 months MVP → production

ROI Analysis#

User Retention Impact#

FSRS Advantage: 20-30% fewer reviews

• Implication: Higher user retention (less review fatigue)
• Metric: 15-25% increase in DAU (daily active users) estimated

SM-2 Baseline: Standard SRS performance

• 50-70% time savings vs traditional methods
• Sufficient for most use cases

Competitive Advantage#

Market Leaders Using Advanced SRS:

• Anki: FSRS (integrated 2023)
• Duolingo: Custom algorithm (likely FSRS-inspired)
• SuperMemo: SM-18 (proprietary)

Competitive Positioning:

• SM-2: Commodity feature (table stakes)
• FSRS: Competitive advantage (proven performance gains)
• SM-18: Best-in-class (but licensing barrier)

Development Cost vs Performance Trade-off#

Recommendation: FSRS offers best ROI for most production apps

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

Summary: Choosing Your Algorithm#

For Fastest Time-to-Market#

→ SM-2 (3-4 weeks MVP, $30K-$50K)

For Best User Retention#

→ FSRS (20-30% fewer reviews, 4-6 months, $80K-$150K)

For Best-in-Class Performance#

→ SM-18 (proprietary licensing, enterprise budget)

For Open-Source Projects#

→ FSRS (modern, ML-optimized, free)

For Budget-Constrained Startups#

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

Research Duration: 2 hours Primary Sources: Medical research papers, app development cost reports, market analysis Confidence Level: High for use cases and development costs, Medium for operating cost estimates (variable by scale)

S4-Strategic: Lock-in Analysis and Migration Paths#

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

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

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)

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 Cost: $10K-$30K (development + testing)

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 Cost: $5K-$15K

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) Cost: $20K-$50K (includes parameter optimization)

Migration Strategy Matrix#

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 $10K-$30K for 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)

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, $20K-$50K)
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

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

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

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)