Put knowledge in.
Leave repetition to yourself.
Data, template and engine decoupled into three layers — learn anything with your own templates.
DragonCard doesn't decide what your cards look like, and it doesn't schedule your reviews. It offers one stable container: you put knowledge in, and you show up every day.
DragonCard is not Anki.
It has no complex spaced-repetition algorithm — just one simple, categorized approach.
Show knowledge to you quickly: mark what you don't know, and difficult ones stay ahead while mastered words fall behind. That's all.
It doesn't schedule your reviews, and it makes no promise of "remember it in N days". Because memory was never about tricks; it's about repetition.
Memory was never about tricks.
It's about repetition.
Ebbinghaus proved it with a lifetime of research. So we believe in you — in your consistency.
The brain is remarkably good at being lazy. When you do the same thing consistently over time, it stops feeling hard and gradually becomes easier.
DragonCard taps into exactly this mechanism — it offers no magic, just a simple container: put knowledge in, and leave the most basic act of "repetition" to the self that shows up every day.
Persistence pays off.
We make no promises. We just build the container.
DragonCard vs Anki
| Dimension | Anki | DragonCard |
|---|---|---|
| Scheduling unit | Each card independently computes its next review time | A complete ordered list as the unit; priority via sorting |
| Time constraint | Strictly date-driven | Elastic — when to continue and how long to wait is up to you |
| Known words | Lower review frequency after mastery, or leave the pool | Kept at the tail of the list, refreshed with a light pass |
| Strength | Higher theoretical ceiling for memory efficiency | Simple, stable flow; easy to resume after a break; keeps word context order |
| Weakness | Uncontrollable workload, high maintenance after breaks | No precise review at the forgetting threshold; slightly lower theoretical single-item ceiling |
We list our own weakness in the table too. DragonCard doesn't chase the theoretical ceiling — it chases one thing: that you still come back tomorrow.
Data, template, engine — three decoupled layers
One JSON template file defines everything about a card. The framework only provides the "shelf": the study flow and backend APIs stay fixed.
Data is just data
Card content is a plain JSON array, and the field names are defined by your own template. Learn whatever you want — there is no preset schema.
// cards.json — one entry per item [ { "item_order": 1, "word": "spect / spic", "meaning_en": "to look, to see" }, { "item_order": 2, "word": "dict", "meaning_en": "to say, to speak" } ]
The template defines everything
Structure, styles, interaction, pronunciation language and telemetry events — all wrapped in a single JSON file. The framework talks to it through window.cardTemplate's render / init / update.
// template.json { "name": "My Card", "lang": "en", // selects the TTS voice "cardHtml": "<div class=\"card\">…</div>", "cardCss": ".card { padding: 16px }", "cardJs": "window.cardTemplate = { render, init }", "trackedActions": [ { "action": "audio_play", "label": "Pronounce" } ] }
The engine does one thing: makes you repeat
Mark unknown → reshuffle → study in rounds; progress persists automatically. It doesn't know your content and doesn't care whether you're studying English or chemistry — it maintains one ordered list, and your place in it.
// the fixed study flow GET /v1/learn/page → fetch a page of cards POST /v1/learn/mark → mark as unknown POST /v1/reorder → reshuffle: difficult ahead, known behind GET /v1/rounds → enter the next round
The whole mechanism, in four steps
This list actually works. Mark a few items as unknown, then hit reshuffle and watch what happens.
After reshuffling: unknown items float to the front, known ones sink to the tail — but they never disappear. They simply wait their turn for a light pass in the next round.
How far can a card be customised?
Short answer: almost entirely. The framework only asks your template to expose render — the rest is yours.
Your own HTML / CSS / JS
Structure, styles and interaction are all in your hands. Tailwind utility classes and Font Awesome work out of the box.
Language-aware TTS
The template declares lang (en / ja / zh …); pronunciation picks the matching voice, remembered per language.
Up to 5 actions + telemetry
Declare events via trackedActions; the framework aggregates them per template and shows them in the observability view.
Hideable fields
Declare fields and toggle each one while studying — or lock the ones that must never be hidden.
Live preview
Upload a template and see the real card render instantly in the management panel — no need to enter study mode.
Local-first
Flask + SQLite, works out of the box. Your data stays on your own machine; no external service required.
Your consistency, made visible
Not designed to make you anxious — just an honest picture of how often you showed up.
Activity heatmap
Mastery distribution
Round pyramid
Getting it running takes one sentence
Installing dependencies, creating a virtualenv, changing ports — let an AI tool handle that. Hand the repo to any one of these and ask it to run the project.
WorkBuddy
Hand it the repo, say "run this for me", and it does the rest.
Codex
An AI assistant in your terminal, ideal for working right inside the repo.
OpenCode
Open-source terminal agent — bring your own model to deploy and debug.
It's deliberately simple
DragonCard is not a “feature-complete” product. It's a simple version the author built around one plain belief: put knowledge in, and show up every day.
It doesn't decide what you should learn, and it doesn't ship a pile of features you'll never use. Which is exactly why it can be yours.
- Data is JSON. Templates are JSON. Swap the template and it becomes a different learning tool.
- Want to study something new? Have AI generate it — template plus data in one go, import and go.
- Not happy with it? Have AI restyle it, add fields, change the interaction — no waiting for the author.
If you like the direction but it doesn't do what you need yet — hand it over.
Give the repo to WorkBuddy, Codex or OpenCode and simply tell it: what do you want to learn?
The data and template format is universal — with a small adaptation, it becomes any learning tool you want.