Inspiration
I have watched people put a thousand hours into a game they lose at constantly, and then avoid a forty-minute study session because they might get something wrong.
That gap bothered me. It is not a discipline problem. It is a design problem.
Roguelikes Hades, Slay the Spire, and Dead Cells are the only genres where dying is the content, not the failure state. You lose, you shrug, you hit play again. Nobody has ever been ashamed of dying in a video game.
Exams are the exact inverse. One shot, no retries, and the score reads as a verdict on you as a person. Test anxiety is a measurable performance drag, and its root cause is that the stakes are unrepeatable.
So the question became: what if a study session had the structure of a roguelike run instead of the structure of an exam?
Every existing study app borrows from casual games streaks, XP bars, badges. Those reward showing up. Roguelikes reward getting better. That is a completely different loop, and nobody had built it.
What it does
GAUNTLET turns any study material into a roguelike run.
You paste in a syllabus, a chapter, or your own messy lecture notes. GAUNTLET generates a randomized gauntlet of questions from it and drops you into a branching 8-floor map.
- You start with 3 HP. A wrong answer costs one. Zero HP ends the run.
- Correct answers earn relics permanent-for-that-run modifiers that bend the rules.
- The map branches. Take the safe path through topics you have mastered, or the risky path through your weak areas for better rewards.
- A boss on the final floor asks one synthesis question combining several concepts from earlier in the run.
- A run takes about 15 minutes.
Relics are where the pedagogy hides. A sample:
| Relic | Effect |
|---|---|
| Scalpel | Once per run, remove two wrong options |
| Glass Cannon | Double points, but wrong answers cost 2 HP |
| Compound Interest | Each consecutive correct answer is worth more than the last |
| The Mirror | Re-face a question you already missed. Beat it to gain +1 max HP. |
| Second Wind | Survive your first death at 1 HP. Consumed on use. |
The Mirror is spaced repetition wearing a costume. Glass Cannon is desirable difficulty. Cartographer is metacognitive planner. The design principle for the whole project was this: every proven learning technique ships as a reward the student chooses, not an exercise they are assigned.
When a run ends, you do not get a percentage. You get a run report that names which concepts cost you the most HP "you bled on beta-blocker contraindications," not "you scored 62%."
How we built it
The stack is deliberately thin so that all the effort went into game feel rather than infrastructure.
- React + Tailwind on the front end, single page, no router
- Gemini 2.5 Flash for question generation, using structured output with a
responseSchemaso the model returns parseable JSON rather than prose - All state in React no backend, no database, no accounts for v1
The generation step runs once per run. One call produces a bank of 25 questions, each carrying a prompt, four options, the correct index, a difficulty rating of 1–3, a concept tag, and an explanation of why the tempting distractor is wrong. That bank is then the ammunition for the whole run the map draws from it, and no further model calls happen mid-run. This keeps latency at zero once you are playing, which matters enormously for the feel of a fast run.
The relic system turned out to be far simpler than expected. Game state holds an array like:
relics: ["glassCannon", "compoundInterest", "scalpel"]
Every scoring and damage calculation checks that array. Points for a question resolve as:
$$\text{points} = d \times 100 \times m_{\text{relic}} + 50 \cdot s$$
where $d$ is difficulty $(1..3)$, $m_{\text{relic}}$ is the product of active multipliers, and $s$ is the current correct-answer streak when Compound Interest is held.
Fourteen relics, one array, one formula. The combinatorial variety comes almost free — two runs with the same question bank play completely differently depending on what you picked up.
The map generates procedurally: 8 rows, 2–3 nodes per row, with node types constrained by row (Elites only on rows 3 and 6, Rests on 4 and 7, boss on 8), so pacing stays intentional even though layout is random.
Challenges we ran into
1. Ambiguous questions destroy the entire design.
This was the biggest one, and it is existential. In a normal quiz, a badly worded question is annoying. In GAUNTLET, a badly worded question on floor 7 with 1 HP left ends your run unfairly, and the player rightly rages at the app instead of the material.
We ended up putting most of our prompt engineering effort into a single instruction: if a question could be argued either way, discard it and write another. We also forced every question to carry an explanation of why the most tempting distractor is wrong, which turned out to double as a self-check, because a model that cannot articulate why a distractor is wrong usually wrote a bad distractor.
2. Balancing HP.
The number of starting lives is the single most load-bearing decision in the project. The target is that a student who knows roughly 70% of the material just barely survives a run. Too generous and HP means nothing, so the tension evaporates, and it is a quiz again. Too tight, and it is simply a cruel test with a health bar.
We landed on 3 HP across 8 floors, with Rest nodes as a pacing valve, but this needed real playtesting rather than a spec. It is still the number we would tune first.
3. Wanting to add a timer.
We built one, then removed it. Time pressure plus HP pressure is too much; it stopped feeling like a strategic run and started feeling like a panic attack, which is precisely the thing the project exists to remove. HP alone carries the tension. Deleting that feature was the right call, and it took playtesting to see it.
4. Not letting it look like edtech.
Early versions were technically correct and completely dead. Dark background, hearts that visibly break, screen shake on damage, relics that slide in with weight; none of this is decoration. If it looks like a dashboard, the roguelike reframe never lands, and the whole psychological premise collapses.
What we learned
Game genre is a pedagogical choice. We did not set out to prove this, but it turned out that picking the right genre did more work than any feature we designed. Roguelike players voluntarily replay content they have already seen for thousands of hours, because randomization keeps the decision space fresh even when the material is familiar. Repetition is simultaneously the thing that works best in learning and the thing students avoid most, and this genre has already solved making repetition wanted. We just had to not get in its way.
The best gamification is invisible. The moment a student can tell that a mechanic is "actually a learning technique," it stops being a reward and becomes homework. The Mirror works because it feels like a power-up you were lucky to draw.
Structured output is not optional. Free-text parsing with regex was our first approach, and it was fragile in exactly the way that ruins a game intermittently. Moving to a responseSchema removed an entire class of crashes.
Cold-start is a content problem, and we sidestepped it. Traditional edtech dies waiting for a curriculum. Because GAUNTLET's product is the system HP, relics, paths, run structure, and questions are just ammunition, it works for any subject on day one.
What's next
- Tune the HP curve against real playtest data across subjects
- Meta-progression between runs is a persistent map of concepts you have actually conquered
- Daily challenge: everyone gets the same seed, same question bank, and a shared leaderboard
- Multiplayer runs, where two students share an HP pool
The metric that matters is not accuracy or time on task. It is runs per session. If people voluntarily start a second and third run, the reframe worked, and everything else is tuning.
Log in or sign up for Devpost to join the conversation.