Org-drill implements spaced repetition learning within Emacs org-mode. Cards are org-mode headings tagged with :drill:. The system schedules reviews using a variant of the SM2 algorithm pioneered by SuperMemo.

Spaced repetition works. Ebbinghaus demonstrated in 1885 that memory retention follows a predictable decay curve. Reviewing material at increasing intervals counteracts this decay. The question is not whether to use spaced repetition, but which implementation minimizes friction.

Org-drill's advantage is integration. Cards live in the same plain-text files as your notes, documentation, and research. No separate database. No import/export. The review session runs in Emacs. For users already working in org-mode, this removes barriers between learning and working.

Org-drill ships separately from org-mode. Install via package manager or direct download.

;; Via MELPA
(use-package org-drill
  :ensure t
  :after org)

Manual installation requires adding the elisp file to load-path:

;; Manual installation
(add-to-list 'load-path "~/src/org-drill")
(require 'org-drill)

Verify installation:

(if (featurep 'org-drill)
    (message "org-drill loaded")
  (message "org-drill not found"))

The package provides org-drill, org-drill-directory, and org-drill-resume.

Minimal configuration sets drill scope and scheduling parameters.

;; Drill files must be explicitly registered
(setq org-drill-scope 'directory)  ; Search all .org files in current directory

;; Scheduling parameters (SM2 defaults)
(setq org-drill-learn-fraction 0.5)        ; Initial ease factor
(setq org-drill-failure-quality 2)         ; Quality threshold for failure
(setq org-drill-maximum-items-per-session 30)
(setq org-drill-maximum-duration 20)       ; Minutes per session

;; Leech handling - cards that fail repeatedly
(setq org-drill-leech-failure-threshold 15)
(setq org-drill-leech-method 'warn)        ; 'warn, 'skip, or nil

The org-drill-scope variable determines which files are searched for cards. Options:

• 'file - current file only
• 'tree - current subtree only
• 'directory - all .org files in current directory
• 'agenda - all agenda files
• 'agenda-with-archives - agenda files plus archives

Directory scope is practical for dedicated drill repositories. Agenda scope integrates with existing GTD workflows.

Org-drill recognizes eight built-in card types. Type is determined by heading structure and properties.

The capital of Estonia is [Tallinn]. #+end_example

Multiple deletions in one item create separate cards:

#+begin_example

HTTP operates on port [80], while HTTPS uses port [443]. #+end_example

This creates two cards: one deleting "80", one deleting "443".

Cloze deletion is the workhorse format for technical facts. Questions and answers are inline in prose. Maintenance is straightforward.

Estonia joined the EU in [2004|year], the euro zone in [2011|year], and NATO in [2004|year]. #+end_example

The hint appears during review. This reduces ambiguity for items with similar deletions.

[GET] retrieves data, [POST] submits data, [PUT] updates resources, and [DELETE] removes resources. #+end_example

Unlike standard cloze, this shows all four blanks at once. The user must recall all four values before grading.

The TCP header includes [SYN], [ACK], [FIN], [RST], [PSH], and [URG] flags. #+end_example

First card shows: "The TCP header includes _, [ACK], [FIN], [RST], [PSH], and [URG] flags." Second card shows: "The TCP header includes [SYN], _, [FIN], [RST], [PSH], and [URG] flags."

And so on. Six deletions create six cards.

Org-drill uses SM2, the algorithm from SuperMemo 2 (1988). Cards have three scheduling parameters stored as properties:

• DRILL_LAST_INTERVAL - days since last review
• DRILL_REPEATS_SINCE_FAIL - consecutive successful recalls
• DRILL_EASE - ease factor (default 2.5)

Each review produces a quality score (0-5):

Scores 0-2 reset the card to initial interval. Scores 3-5 increase the interval:

new_interval = old_interval × ease_factor
new_ease = old_ease + (0.1 - (5 - quality) × (0.08 + (5 - quality) × 0.02))

The ease factor adjusts based on recall quality. Difficult cards get shorter intervals. Easy cards space out faster.

Let's verify the algorithm implementation:

(require 'org-drill)

;; Inspect scheduling function
(symbol-function 'org-drill-reschedule)

The implementation follows SM2. The ease factor adjustment is visible in org-drill-adjust-quality.

Drill cards are standard org-mode headings. Properties, tags, and metadata use org-mode conventions.

A typical review session:

1. M-x org-drill starts the session
2. Card is presented according to type
3. User attempts recall
4. RET reveals answer
5. User grades quality (0-5)
6. Next card or session end

Session ends when:

• Maximum duration reached (org-drill-maximum-duration)
• Maximum items reached (org-drill-maximum-items-per-session)
• No more due cards
• User quits (C-g)

Session state is saved. M-x org-drill-resume continues from the last position.

Let's simulate a minimal session:

#+begin_src elisp :results output ;; Create a temporary drill file (with-temp-buffer (insert "* Test Item :drill: What is 2+2?

Three organizational patterns:

Org-drill scans files linearly. Performance degrades with file size.

Measured on 1000-card file:

(let ((start (current-time))
      (file "~/drill/large.org"))
  (find-file file)
  (org-map-entries
   (lambda () (org-drill-get-item-data :ease))
   "+drill")
  (message "Scan time: %.2f seconds"
           (float-time (time-subtract (current-time) start))))

The scan is I/O bound. Splitting into smaller files improves performance:

Practical limit: 500 cards per file. Beyond this, session startup latency is noticeable.

Anki is the dominant spaced repetition system. Org-drill differs in philosophy:

Org-drill trades polish for integration. Cards are version-controlled, greppable, and diffable. The review interface is minimal. No graphs, no statistics dashboard, no gamification.

For users already living in Emacs, this is not a compromise. It removes context switching.

Practical drill repository layout:

~/drill/
├── .git/
├── README.org                      # Usage notes, review schedule
├── computer-science/
│   ├── algorithms.org
│   ├── data-structures.org
│   └── operating-systems.org
├── mathematics/
│   ├── calculus.org
│   ├── linear-algebra.org
│   └── statistics.org
└── languages/
    ├── spanish.org
    ├── german.org
    └── mandarin.org

Configuration in .dir-locals.el:

((org-mode . ((org-drill-scope . directory)
              (org-drill-maximum-items-per-session . 50)
              (org-drill-save-buffers-after-drill-sessions-p . t))))

This sets drill parameters for all files in the repository.

Org-drill is minimal by design. Missing features compared to dedicated systems:

• No built-in statistics graphs
• No mobile app (Termux + Emacs works but is not native)
• No automatic card generation from highlights
• No shared deck repository
• No image occlusion
• No audio recording

Some limitations are addressed by org-mode extensions (org-download for images, org-attach for media). Others require custom elisp.

The trade-off is explicit: simplicity and text-first design over feature completeness.

• Simple card example
• Cloze deletion example
• Two-sided card example
• Multi-cloze example
• Cloze with hints example
• Multi-sided card example
• Explain card type
• Custom card type

Source code: https://gitlab.com/phillord/org-drill

SM2 algorithm: Wozniak, P. (1990). "Optimization of learning". University of Technology in Poznan.