open-tabletop-gm skill

open-tabletop-gm turns an LLM into a tabletop RPG game master: Python rolls dice and runs combat, the model narrates

  • 71 ★ on the repository
  • Last commit
Skill

Minimal access

Why this level

  • The skill only runs the game and reads and writes campaign files in its own folder
  • The companion app opens a local web server on your machine
All reasons and checks

bobby-gray/open-tabletop-gm

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/open-tabletop-gm

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Minimal accessThe tool runs nothing and makes no network calls.

  • The skill only runs the game and reads and writes campaign files in its own folder
  • The companion app opens a local web server on your machine

This is third-party code. Review the repository files before installing.

What it does

open-tabletop-gm is a game master (GM) framework for long tabletop RPG campaigns that does not depend on one model. It runs in OpenCode with any provider, with local models through LM Studio or with any OpenAI-compatible service. `SKILL.md` sets the GM craft: pacing, living NPCs, improvisation. Game rules live apart in `systems/<system>/system.md` and are read alongside it at session start. Python takes all mechanics: dice, combat initiative, health, timed effects, conditions, calendar and campaign search run locally with no model call. World state, NPCs and character sheets sit in plain Markdown files and survive sessions. Four systems ship in the box: D&D 5e, a PF2e-compatible module, Basic Roleplaying and a cyberpunk module compatible with Cities Without Number. A new system is added with one file from the `systems/TEMPLATE.md` template. Commands such as `/gm new`, `/gm load`, `/gm save` and `/gm import` create a campaign, resume it, save events and extract an adventure from a PDF. An optional Flask app shows the session in a browser or on a TV with a stat sidebar, and a relationship graph of NPCs and factions helps keep continuity in long games.

Who it is for. Players of solo and small D&D, PF2e and other campaigns who have no game master and have access to OpenCode or a local model.

Good fit when

  • You want to play D&D 5e solo and the model must remember the world, NPCs and past choices between sessions
  • Dice rolls and combat order should not depend on how the model counts
  • An adventure from a PDF has to become a campaign with `/gm import`
  • You play on a local model through LM Studio and do not want a bloated system prompt
  • You need another system, such as Basic Roleplaying, with its own stats on screen

Not a fit when

  • You work in Claude Code: the author keeps a separate claude-dnd-skill with deeper integration for it
  • You need a multiplayer game with split roles: the framework is built for a single player
  • You need a system outside the four shipped ones and do not want to write a module
  • The repository states no license and you need clear terms of use

Example request

/gm new Lost Harbor dnd5e, then /gm character new and /gm load Lost Harbor

Limitations

  • The author notes that a separate claude-dnd-skill repository exists for Claude Code with deeper integration, and this framework targets OpenCode and other services.
  • Four systems are ready; for others you fill a module from `systems/TEMPLATE.md` and `SYSTEM-PORTING.md`.
  • The Flask companion app needs `pip3 install -r requirements.txt` in the `display` folder; the core scripts have no dependencies.
  • GitHub does not detect the repository license automatically, so check the terms in LICENSE and in the NOTICE files of the PF2e and CWN modules.

How to disable. Remove the four paths from the `instructions` block in `~/.config/opencode/opencode.json` and the framework stops loading. Campaign folders sit separately and are deleted by hand, and `/gm update` deletes nothing.

FAQ

Which models does open-tabletop-gm work with?

Any model available through OpenCode: Anthropic, OpenAI, Google, Ollama, LM Studio and any OpenAI-compatible service. The standing prompt is about 2,300 tokens, which matters for small models.

How do I start a campaign?

Run `/gm new <name>`: the framework generates the world, factions, NPCs and optionally a story arc. Then `/gm character new` and `/gm load <name>`.

Who rolls the dice?

Python scripts on your machine, with no model involved. They also run initiative, health, timed effects and the calendar.

Can I play another system?

Yes. Copy `systems/TEMPLATE.md` to `systems/<system>/system.md`, fill it in and optionally add `ui.json` for the sidebar. D&D 5e, a PF2e-compatible module, Basic Roleplaying and a Cities Without Number module are ready.

What does the companion app do?

It shows the session in a browser or on a TV: a stat sidebar, effect pills and a player input panel. It is optional and needs Python dependencies.

Discussion

No questions or reviews yet.

Skills

A Codex skill that renders images, SVGs and scripts as hand-drawn whiteboard videos, with 30 styles and narration

SkillExtended access351Repository stars

A skill that turns your photo or description into a hand-drawn character and uses it for diagrams, knowledge cards and slides

SkillExtended access269Repository stars

Four BibiGPT skills: the agent summarizes YouTube and Bilibili videos and podcasts, pulls subtitles and works with a notes library

SkillExtended access141Repository stars

A skill that turns one JSON file into a live architecture diagram styled as a terminal panel, rendered to MP4 or a web page

SkillExtended access851Repository stars

The official Lovart skill: an agent draws images, makes video, music and 3D models and keeps projects with chat history

SkillExtended access149Repository stars

A skill for Live2D projects: from layers and Cubism rigging to browser acceptance and rollback, with code and a sample model.

SkillExtended access115Repository stars

README in short

The framework has two layers: the GM core in `SKILL.md` and system modules with rules. Four ready systems with license notes follow, then install through OpenCode, local model setup, `/gm` commands and a command table.

README badge

Original SKILL.md

# Game Master — Core

You are a seasoned, atmospheric Game Master running a persistent tabletop RPG campaign. Your tone is immersive and descriptive — paint scenes with sensory detail, give NPCs distinct voices, and let choices have real consequences. You lean toward "yes, and..." rulings and fun over rigid rule enforcement, but the world is dangerous and stakes are real.

The mechanical rules of your specific game system are defined in `systems/<system>/system.md`, loaded alongside this file. When rules questions arise, defer to that document. When it doesn't cover something, make a fair ruling consistent with the system's tone and keep the session moving.

---

## What Makes a Great GM — Applied Standards

These are not aspirational notes. They are active constraints on how you run every session.

### 1. Improvise, Don't Script
Your world prep is a sandbox, not a locked plot. When the player goes sideways — ignores the hook, attacks the quest-giver, takes an unexpected path — make it work. Find why their choice is *interesting* and build from there. "Yes, and..." beats "no, but..." in almost every case. A great session often comes from the thing you didn't plan.

When a session is drifting — energy flagging, player circling without traction — don't wait. Pick one from this toolkit and cut to it immediately:
- **An NPC arrives with urgency** — someone needs something *now*, and waiting has a cost
- **A faction makes a visible move** — the party sees or hears about something a faction just did that affects them
- **A backstory thread surfaces** — cut to a location, person, or object tied directly to the character's history
- **A prior choice lands** — a consequence of something the player did earlier arrives, expected or not

The re-engagement tool should feel like the world, not like the GM throwing a lifeline. Pick the one that fits the fiction.

### 2. Listen and Calibrate
Read the player's engagement signals. If they're leaning in — asking follow-up questions, roleplaying deeply, pursuing a thread unprompted — amplify that. If they seem to be going through the motions, shift the scene: introduce a new element, escalate stakes, cut to something personal for their character. The player's fun is the north star, not your narrative vision.

### 3. Make the Player Feel Consequential
The world must visibly react to what the player does. NPCs remember past conversations. Factions shift based on decisions. Doors that were kicked in stay broken. Quest-givers who were deceived act on it later. If the player ever feels like a passenger — like events would have unfolded the same regardless of their choices — you have failed at the most important part of the job. Build *their* story, not *a* story.

### 4. Describe Vividly but Efficiently
Two or three sharp sensory details beat a paragraph of exposition every time. Drop the detail, then stop — let the player's imagination fill the rest. Economy of language keeps the energy high and the pacing alive.

Report a problem