Note
Open Game Master was called Open Dungeon Master until October 2026. The apps, worlds and accounts carry over unchanged; only the name and the website (now opengamemaster.com) moved.
Open Game Master runs multiplayer (and solo) 5e campaigns with an AI Game Master, on your own machine. The narrator is whichever AI you already have: a local model (llama.cpp, Ollama, LM Studio, vLLM), an API key (OpenAI, OpenRouter, or any OpenAI-compatible endpoint), or a CLI agent you already pay for (Codex, Grok Build, Claude Code, opencode, Pi), which narrates on its own subscription with no API key handed over; Codex and Grok Build paint the pictures too. The model is the creative mind and narrator; a stack of server-side engines enforces the 5e rules for both the players and the GM. The narrator never owns the numbers: dice, hit points, spell slots, conditions, and the death track are computed and clamped by the backend, and the model changes game state only through tools the server validates.
The AI drives the session, requesting rolls, starting encounters, and playing NPCs and companions, following a secret story arc it regenerates as the campaign moves.
Tip
New here? Start with the knowledge base on the website. It covers choosing a setup, the system requirements, installing the desktop and Android apps or this server, playing, leading a table, running one as a human Game Master and every setting, and it is checked against each release. Most players never need a server: the apps host a world themselves. This README and docs/ are the reference for people running and changing the server.
A live session of Embers of the Saltglass Coast. Your hand holds every action the sheet allows, each card says what it rolls and what it costs, and the server does the rolling. The battle map, the turn order and the party sit around it.
![]() The battle map, fogged and in initiative |
![]() The character builder, placing ability scores |
![]() The workshop, where prep lives |
![]() The map studio: paint it, light it, put it on the table |
The same table on a phone. The apps compile these pages into native screens.
- The engines own the rules. The model narrates and makes creative calls, but it can only touch game state through server tools that are clamped, audit-logged, and published live to every player. It treats player messages as intent, not outcome.
- The AI drives the table. It asks the server for rolls, starts and runs combat, plays NPCs and AI companions, moves the party, and decides when to spotlight specific players for input.
- It follows a secret story arc. Every campaign gets a hidden spine that advances as chapters close; player-safe pieces surface as the quest log.
The fifty-odd engines behind this: docs/engines.md. What is enforced and what is guidance: docs/rules-coverage.md.
You need Node 22.18+, 24 or 26+ (or Docker) and a storyteller: a local model server (llama.cpp recommended; Ollama, LM Studio and vLLM also work), an API key (OpenAI, OpenRouter or any OpenAI-compatible provider), or a CLI agent you already pay for (Codex, Grok Build, Claude Code, opencode, Pi). Pictures and voice are optional.
The two simplest storytellers: a ChatGPT Plus or SuperGrok plan, whose Codex or Grok Build agent narrates and paints the pictures on one subscription, signed in on the server's computer; or a gaming PC with a 16 GB graphics card running gpt-oss-20b, free and private.
A local model needs at least 16 GB of graphics memory. A 16 GB card (a GeForce
RTX 4060 Ti 16 GB, 4070 Ti Super, 4080, 5060 Ti 16 GB, 5070 Ti or 5080, or a Radeon
RX 7600 XT, 7800 XT, 9060 XT 16 GB or 9070) runs gpt-oss-20b whole on the card,
the pick for that card, and about 28 GB runs the recommended Qwen3.6-35B-A3B
(what each size of card runs,
and the system requirements).
Below 16 GB a local model is not supported; use an API key, an agent program or
a human Game Master. Run it on llama.cpp. The storyteller needs a context
window of at least 64K tokens to play the full rules; smaller windows are not
supported (llama-server -c 65536, the window the default storyteller runs
at). The guided setup's Test backend reads the window a server runs
(what each size plays). Hosted models
and agent programs have far more.
git clone --depth 1 -b stable https://github.com/Lebbitheplow/open-game-master.git
cd open-game-master
npm install
npm run setup # database key, content pack, memory model, production build
npm run start:lan # 0.0.0.0:3005 so your party can reach it on the LANThe server prints a link with a one-time setup code. Open it on the same computer, create the admin account, and the guided setup finds what is running on the machine and walks through the storyteller, pictures, voice, players and your own agent, one question at a time.
With Docker instead, in a folder of its own:
mkdir open-game-master && cd open-game-master
curl -O https://raw.githubusercontent.com/Lebbitheplow/open-game-master/stable/docker-compose.yml
docker compose up -d
docker compose logs # open the setup link it printsThe link creates the admin account and starts the same guided setup (Run with Docker: Windows, your model server, backing up the key).
Both follow the stable releases. To run the newest beta instead (a GitHub
pre-release, promoted to stable unchanged once it holds up), switch Docker to the
beta image in the same folder:
echo "ODM_IMAGE=lebbi/open-game-master" >> .env
echo "ODM_IMAGE_TAG=beta" >> .env
docker compose pull && docker compose up -d # run again to updateFrom a clone, check out the beta's tag instead. The beta channel on opengamemaster.com links the current beta's release archive and content pack, and says when there is none because the newest release is stable. How the channels work and how a beta becomes stable: docs/releases.md.
Playing, hosting from the apps, leading a table and every setting are in the knowledge base on opengamemaster.com, with a FAQ and what changed in each release. The documents below are the server's own reference.
- Getting started
- Install and first run: requirements, the guided setup, setup by hand, the first admin account, the content pack, tests
- Run with Docker: the image, reaching AI services on the host, volumes and maintenance, publishing
- Backups and moving to another server
- Releases and update channels: stable, the nightly betas, and how a beta is promoted
- The storyteller
- Text backends: the recommended GM model and its settings, the hardware each model needs (16 GB and gpt-oss-20b at the least, the BC-250), Ollama, choosing a model (the models.dev catalog, no model named in code), OpenAI and other APIs, long-story memory
- Agent programs as the GM: Claude Code, Codex, opencode, Grok Build and Pi on their own sign-in
- Pictures, voice and sound
- Setting up pictures, narration and dictation: ComfyUI, an OpenAI key, Kokoro, Whisper
- Image generation: the image models, measured hardware, AMD GPUs
- Voice chat and real dice: live voice with turn-taking and proximity, physical and Pixels dice
- Running a server
- Settings, admin panel and sign-in: which setting wins, the admin panel, Discord sign-in
- Configuration reference: every environment variable, phones, sharing a server, ambience
- Storage and the single-writer rule: the encrypted database, one process per database, changing the embedding model
- Player agents and webhooks: a player's own agent, woken on its turn
- Multiple characters per player
- Content and worlds
- Campaign plugins (world packs): renaming the rules into a setting, the registry, building a pack in the workshop
- Workshop portability: bundles, imports and shared workshops
- The content pack and licenses
- Addons
- Addons: installing from the audited list, permissions, where addons run
- Writing an addon, the extension points and the catalog guidelines
- Working on the addon framework: the code map, the rules it keeps, how to add a field, a message or an extension point
- How it works
- The engines: combat, sheets, world simulation, narrative, memory, AI integration, the human GM and the workshop
- Rules coverage: what is enforced, what is guidance, what is out of scope
- Roadmap
- Contributing
- Contributing guide: the conventions, the checks, a new DM tool, route or test suite, and what a pull request carries
For palettes, painted borders, materials, registration and disposable preview checks, see Build an appearance theme. The guide uses Ancient Woodland as a worked example and includes the commands needed to validate a new theme without live campaign data.
Addons are their creators' own projects, each kept in its creator's GitHub repository and audited before it joins the downloader list under Admin > Addons. Their repositories are the place to follow, star and support their work; the app credits each one wherever what it adds appears, and on the licenses page. Anyone can write an addon and submit it to the list.
| Addon | Creator | Repository | What it adds |
|---|---|---|---|
| Isometric Tabletop | Laurent Sparks (@laurentsparks-art) | laurentsparks-art/isometric-tabletop | Board view: Isometric |
The application is MIT licensed. Third-party and unofficial campaign
content is not included with this repository and is not covered by the MIT license.
Community world packs are installed at runtime into the gitignored data/worlds/
directory. They are the work of their own authors, distributed by whoever
publishes them, and are neither shipped nor vetted by this project. A pack that
references an existing setting is an unofficial fan work with no affiliation with
or endorsement from that setting's rights holders, and the app labels it as such
wherever it appears. Only original works are bundled in this repository.
- The workshop's WorldForge tool is ported from WorldForge, Smoebo's world-building app, with their permission. What came from it is listed in docs/LICENSES.md.
- Game rules data derives from the System Reference Document 5.1 by Wizards of the Coast LLC, licensed under CC-BY-4.0. See docs/LICENSES.md.
- Expanded options (the widely played subclasses, spells, feats and lineages that no open dataset carries) are original content: the mechanics are stated in our own wording, and no publisher's descriptive text is reproduced.
This project is not affiliated with, endorsed, or sponsored by Wizards of the Coast.




