AI D&D
+Open-ended adventures narrated by an LLM — with an engine that keeps the numbers honest.
+Create a world, play it in second person, and let the model improvise the story while a Python + referee enforces what's actually true: hit points, an ally's trust, a raised alarm, a quest milestone. + Bring your own model, or play the demo with none.
+ + +No sign-up, no API key. Hosted on a free tier that sleeps — the first load takes ~30–60s to wake.
+ +
+ What makes it more than a chat wrapper
+Three things a plain "talk to a model" app doesn't do.
+ +The AI proposes, Python referees
+A scenario declares stats, flags, milestones and a named cast. Each turn the model appends the changes
+ it thinks happened — and the engine clamps them to range, enforces per-turn caps and cooldowns, keeps
+ counters monotonic and milestones sticky, then strips the machine-readable block out of the prose.
+ Word-labelled bands (40–60: minor damage) are what make the model reliable at it.
+ No dice, no scripting required.
+ You can see the entire prompt
+Every turn stores exactly what was sent to the model. Open Insights on any action to see each context + component, what it cost in tokens, and why it was there — including which trigger word pulled in each + story card and the similarity score behind each retrieved memory.
+
+ Real AI Dungeon scripts run
+The three familiar hooks — onInput, onModelContext, onOutput —
+ with shared persistent state and a worldEntries API, executed in an embedded
+ quickjs sandbox. Scripts written for AI Dungeon import and work, and there's a CodeMirror editor in the app.
+ Memory that survives a long story
+The modern AI Dungeon memory system: AI-generated memories every few actions, a running story summary, + and embedding-based retrieval that pulls an old-but-relevant fact back into context when it matters. + Undo and retry roll the world state back to a per-action snapshot rather than only rewriting the text. + Every story stays where you left it, and the home page opens on its most recent line.
+
+ How a turn works
+Player input goes through the script pipeline, into a token-budgeted context, out to whichever + model you configured, and back through the referee.
+player input
+ → onInput script modifier
+ → assemble context: [narrator prompt] + [world state + stat guide] + [AI instructions]
+ + [plot essentials] + [story summary] + [retrieved memories]
+ + [triggered story cards] + [story history, token-budgeted]
+ + [author's note] + [player action]
+ → onModelContext script modifier
+ → snapshot context (Insights)
+ → provider adapter → AI (streamed)
+ → extract + referee the world-state delta block, strip it from the prose
+ → onOutput script modifier
+ → store & renderEngineering notes
+The parts that were measured rather than guessed at.
+ +-
+
- Database egress, cut ~189×. Every adventure load was pulling the entire assembled + prompt — about 74 KB per turn — just to read two small fields off it. Moving those into their own columns + and deferring the heavy ones took one load from 38.5 MB to 0.20 MB. A test hooks into SQLAlchemy's cursor + events and fails if a bulk load ever names those columns again. +
- Turn cost, made flat. Assembling a turn walked the whole story, so it grew with story + length — 839 KB of reads by turn 200. History is now served as tails and slices from SQL: the same turn + costs 129 KB and stops growing at around turn 50. +
- A shared demo key that can't be drained. The hosted demo funds a model for visitors, so + model selection is pinned server-side with a structural backstop that raises if any code path tries to + resolve a model outside the allowed set — plus a daily per-visitor turn cap. +