Put knowledge in.
Leave repetition to yourself.
Data, mini-tool and engine decoupled into three layers — learn anything with your own mini-tools.
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, mini-tool, engine — three decoupled layers
A deck is one data file plus one mini-tool. The framework only provides the "shelf": the study flow and backend APIs stay fixed.
cardAPI object into the tool; the study engine (mark / reshuffle / pagination / progress) stays fixedData is just data
Card content is a plain JSON array, and the field names are defined by your own mini-tool. Learn whatever you want — there is no preset schema.
// cards.json — one entry per item (HSK 1–9 deck) [ { "item_order": 1, "word": "学习", "pinyin": "xuéxí", "part_of_speech": "动", "definition": "to learn/to study", "traditional": "學習", "level": "1" }, { "item_order": 2, "word": "朋友", "pinyin": "péngyou", "part_of_speech": "名", "definition": "friend", "traditional": "朋友", "level": "1" } ]
The mini-tool defines everything
Structure, styles, interaction, pronunciation and telemetry all live in one self-contained H5 bundle — zip it and upload it. The framework talks to it only through window.cardAPI.
// your mini-tool — any HTML / CSS / JS var page = await cardAPI.getPage(1, 500); // fetch the cards cardAPI.mark(card.id, true); // flag as not mastered cardAPI.favorite(card.id, true); // bookmark it cardAPI.track('audio_play', card.id); // log an action cardAPI.playAudio(card.data.word); // read it aloud
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 mini-tool go?
Short answer: almost anywhere. The framework only asks a tool to render cards and pull data through cardAPI — the rest is yours.
Your own HTML / CSS / JS
Structure, styles and interaction are all in your hands. The host's bundled Tailwind, Font Awesome and Three.js are available too.
Language-aware TTS
The tool declares its language (en / ja / zh …); pronunciation matches a system voice and remembers the user's pick per language.
Telemetry as you go
Any interaction can be logged with cardAPI.track(action, itemId); the framework aggregates per deck and draws heatmaps and action stats in the observability view.
Zero build · upload and go
One zip is one tool: upload it in the admin page, bind it to a deck, and it is live. No compiler, no dependency install.
One tool, many decks
A single tool can serve several decks — a deck only decides which data it is fed. Re-uploading the zip keeps its id, its bindings and your progress.
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; a tool is an HTML/CSS/JS folder. Swap the tool and it becomes a different learning tool.
- Want to study something new? Have AI generate it — a mini-tool plus its 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 tool format is universal — with a small adaptation, it becomes any learning tool you want.