A guide to running the Dungeon Master on your own hardware. The server still thinks; your machine lends it a voice. Any model your Ollama can run is fully playable as the DM — uncensored ones included: the house models answer to their providers' content policies, a model on your hardware answers to you. This page covers the setup, the gotchas that actually bite (almost all of them CORS), and the questions people ask before and after.
One honest note before anything else: the prompt your Ollama receives is the same prompt our house DMs get. It is deliberately not a secret — you can watch exactly what your DM was asked. The DM step costs 0 turns; everything else at the table behaves as before.
And one honest difference: the house minds answer to their providers' content policies; a model on your own hardware answers only to you. Whatever your Ollama can run is fully playable — the uncensored ones included. The server still builds every prompt and keeps dice, HP and the Lorekeeper honest, so a frank local DM never means drifting numbers. Images and voices are the exception: image generation and TTS stay on house engines.
Before you ask the first question, the checklist should read like this:
In order of how often they bite. The first one is the big trap; most "the guide didn't work" stories are actually this story.
Cause: your Ollama is running and answering, but it refuses to be read from this site because it wasn't told the site is allowed. The exact value it needs, plain, no @url: prefix and no quotes needed beyond your shell's habits:
OLLAMA_ORIGINS=https://dnd.rostad.cc
The trap: setting that variable in a terminal does not reach an Ollama that is already running — on Linux that's a systemd service, on Windows the tray app, on macOS the menu-bar app. And if you then type OLLAMA_ORIGINS=https://dnd.rostad.cc ollama serve, it fails with bind: address already in use, which people read as the problem. It isn't — it's proof a healthy instance is already running (see the next card). Fix: stop the real instance first, then start one with the variable — or, better, set it permanently:
[Service] Environment="OLLAMA_ORIGINS=https://dnd.rostad.cc"then sudo systemctl daemon-reload && sudo systemctl restart ollama
After that, hit ⟳ in the settings row. 🟡 → 🟢 is the success condition.
Cause: nothing answered on the usual ports. Either Ollama isn't running at all, or it listens somewhere else.
Fix: start it — ollama serve in a terminal, or launch the desktop app. Confirm it answers: open http://127.0.0.1:11434 in the browser — it should print "Ollama is running". If it lives on a different port or a different machine, put that address in the base-URL field (e.g. http://127.0.0.1:11435) and press ⟳. The field is empty by default — leave it empty when everything runs on the same machine.
Cause: an Ollama is already running and holding the port. This is good news, not an error to fight.
Fix: stop that instance first (systemd restart / tray Quit / quit the menu-bar app), then start it with the environment variable — or skip the terminal entirely and set the variable permanently as in the first card. Restarting via systemd (sudo systemctl restart ollama) after systemctl edit is the least painful route on Linux.
Ask your Ollama directly whether it will honour this site. In bash (or fish — the line is the same):
curl -s -D - -H "Origin: https://dnd.rostad.cc" http://127.0.0.1:11434/api/tags -o /dev/null | grep -i access-control
Expected: an Access-Control-Allow-Origin: https://dnd.rostad.cc header line. No output ⇒ the origins variable isn't reaching the live process. In PowerShell:
curl.exe -s -D - -H "Origin: https://dnd.rostad.cc" http://127.0.0.1:11434/api/tags -o NUL | findstr /i access-control
Advanced (Linux): to see whether the variable actually reached the running process, read its environment: tr '\0' '\n' < /proc/$(pgrep -f ollama | head -1)/environ | grep -i origin
Nothing, if Ollama runs on the same machine as the browser — the game auto-detects http://127.0.0.1:11434 (and tries a couple of neighbours). The field is only for a custom port or another host, e.g. http://127.0.0.1:11435.
Another box on your LAN: run Ollama with OLLAMA_HOST=0.0.0.0 plus the same OLLAMA_ORIGINS line, then paste the address into the field. One honest caveat: this page is served over HTTPS, and browsers refuse plain-HTTP calls to a LAN address from an HTTPS page (loopback to your own machine is exempt). Reaching another box therefore needs TLS on its address — if both machines are on a tailnet, tailscale serve in front of Ollama does it in a minute.
The base URL lives only in your browser and is never sent to us.
Not supported — by design, for now. The game speaks Ollama's native API (/api/tags, /api/chat), not the OpenAI-style /v1/chat/completions those other servers expose, so the picker won't find them and no setting will fix that.
Fix: run real Ollama instead — it serves the same GGUF models, and on AMD hardware it builds against ROCm. An OpenAI-relay mode is on the roadmap; there is no date for it.
Cause: on CPU, a thinking model spends the whole budget on its internal reasoning before a single word of narration appears. Nothing is broken — your hardware is simply slower than the prompt is long.
Fix: pick a smaller or faster model, or lower the ctx selector (8k answers sooner than 32k). If narration still never arrives, a house-DM fallback button appears automatically — using it costs 1 turn, the same as a normal house message.
The DM step itself costs 0 turns — your hardware pays for it. If narration never arrives even though the dot is 🟢, the house fallback offers to answer per turn. Voice narration (TTS) and images are not local features and always cost house turns. While any background role still runs on house models the cap is roughly 100 local messages a day; with both the Lorekeeper and the Background local, roughly 300.
Anything you've ollama pull'ed shows up in the 🏮 group automatically — including custom tags like qwen3:14b-q4_K_M; quantized tags are fine. Thinking models also show their reasoning in a window before the narration, exactly as on the house models. Practical floor: 8B; comfortable: a 14B+ thinking model on a real GPU.
No — that's the point of your own hardware. The house minds (StepFun, Qwen, DeepSeek) are subject to their providers' content policies; a model running on your machine answers only to you. Whatever your Ollama can run is fully playable as the DM — uncensored models included. Two honest boundaries: the server still builds every prompt and keeps dice, HP and the Lorekeeper honest, so narration can be as frank as it likes without the books drifting — and image generation and TTS remain house engines, which stay under house policies.
16k is the recommended default — Ollama's own default of 4k is too small for a campaign prompt. The ctx selector (8k / 16k / 32k) in the settings row is applied per request; it does not change your Ollama globally. Go 32k only if your hardware swallows it without slowing the story to a crawl.
The DM step costs 0 turns — that's the point of bringing your own breath. While any background role (Lorekeeper, extraction) still runs on house models, local play is capped at roughly 100 messages per account per day. Pick 🏮 models for both of them and the cap lifts to roughly 300, because the house spends nearly nothing per turn then. TTS and images cost house turns as before.
Yes — per role, with no mode to flip. The 🏮 group appears in three dropdowns (in the in-game ⚙ settings and in the new-adventure setup): Dungeon Master, Lorekeeper (the Guardian: rules, dice checks, HP/XP/items bookkeeping) and Background (extraction: facts, journal, memory). Pick your own Ollama model for as many of them as you like; roles you leave on house models keep running on the house exactly as before. One dependency: local background roles only take effect when the DM is local too — the relay lives on that path. The bookkeeping roles ask a lot of instruction-following: their steps come back as JSON-like tasks, so use a 14B+ thinking model there; a tiny 3B model fumbles them. An earlier version had a separate on/off switch for this — it is gone, and campaigns set up with it keep behaving the same.
The DM prompt travels to your machine — your browser talks to your local Ollama directly; nothing of the story goes through it on the way. Your model list stays local. The base URL you type is stored in your browser only and never sent to the server. What does still live server-side, as always: your chat history, the ledger and the books — the house keeps the world state. If you want the story itself off our machines too, that is a different product than this one.
You can make your local DM say anything you like — but dice, HP and combat are server-authoritative. Rolls come from real code, and the books only change through the Guardian. A fabricated sentence of narration cannot forge a nat 20 or conjure gold; it just makes a fiction the ledger will contradict.
Not comfortably yet. The feature is built for a browser on the same machine as Ollama (loopback). A phone reaching Ollama on another box needs the LAN + TLS setup above, plus OLLAMA_HOST=0.0.0.0 — it works on a tailnet with tailscale serve, but we can't call it a smooth experience yet.
Honestly: under 8B, expect trouble. Long campaigns ask a model to juggle the transcript, the fact register and the rules in one breath — small models drop threads, contradict the ledger, and on the Lorekeeper and Background roles they simply fumble the JSON bookkeeping. A sub-8B model is fine for a one-shot; for a saga, 14B+ is the road.
The Minds — Local AI section for what runs where and the honest limitations. The Machinery for how the DM prompt and the Guardian work under the hood. How to Play for everything else at the table.
Powered by Qwen, DeepSeek & StepFun — and, in this mode, by your own machine. Questions? [email protected]