Classic space opera, out-of-print gems, your own homebrew. Build a mode with your system's stats, dice, and rules, and the Game Master runs it and keeps the sheet current.
Free to build and play. Modes live in your browser and export to a file you can share.
The short version
The builder is a form, not a programming language. If you can read your rulebook's character sheet, you can build a mode for it.
On the start page, switch on Custom Mode, then click Mode Builder. Start blank, clone a template, or import a mode file a friend sent you.
Add the system's stats, the resources that rise and fall in play, and the skill list. Optional formulas compute modifiers and maximums for you.
Tell the Game Master how checks, combat, and damage work, in plain language. It follows this text as written.
Pick your mode on the start page and begin. The Game Master rolls your dice convention, applies your modifiers, and updates the sheet turn by turn.
The full guide
The name is how the mode appears in your list. The dice convention is the die the system rolls for checks, written like d20, 2d6, or d100. The description is a sentence or two about what the system is; the Game Master reads it too, so a good description sets the tone.
Stats are the core numbers on the character sheet. Each one has a short key like STR, a full name, and a default value. The modifier formula is optional: use it when a stat implies a bonus, the way many d20 games derive a modifier from an ability score. Write it the way the book prints it:
floor((STR - 10) / 2) for the classic d20 modifierFormulas can use any stat key, plus level. Once a stat has a modifier formula, other formulas can reference it as STR_mod.
Resources are the numbers that go up and down in play: hit points, power points, ammo, sanity, luck. Each has a starting value and an optional maximum formula. When the maximum formula uses level or a stat, it recalculates automatically when those change, so leveling up raises your pools without bookkeeping.
Derived values are computed numbers the sheet displays but nobody edits by hand: defenses, initiative, damage thresholds. Give each a name and a formula. For example, a space opera game's Reflex Defense might be 10 + level + DEX_mod.
List each skill with the stat it keys off. When the Game Master resolves a check, it rolls your dice convention and applies that stat's modifier. You do not need to be exhaustive; the Game Master handles anything not listed as a plain stat check.
Conditions are the states the system tracks: stunned, prone, bleeding, whatever your book calls them. Categories are the sections of your character beyond numbers, like Inventory, Force Powers, or Mutations. Each category becomes a panel in your sidebar that the Game Master fills as you play.
Set the label the system uses for advancement (Level, Rank, Grade) and paste the XP thresholds as a comma-separated list, where each entry is the total XP needed for that level. When the Game Master awards XP, the level updates itself and any formula using level follows.
This is the heart of the mode. Write how the system actually plays: how checks resolve, how combat rounds work, how damage lands, what makes this system feel different. The Game Master treats this text as authoritative for the session. Concrete beats abstract; "damage that meets the threshold moves the target one step down the condition track" is exactly the kind of sentence that works.
For deep rules the mode does not cover, upload the rulebook you own as a document in-game. The Game Master searches uploaded documents during play, so the mode carries the sheet and the core loop while the book covers the long tail.
Formulas compute numbers; scripted tools run mechanics. A scripted tool is something the Game Master can call by name during play, with parameters you define, whose script rolls dice, reads and writes the sheet, damages scene NPCs, and reports results back into the story. The 5e and PF2e templates ship with working examples: an attack resolver, saving throws with degrees of success, and rests.
Scripts are small and readable. This one resolves a simple attack:
| let d20 = roll("d20") let total = d20 + getMod(stat) + getVar("proficiency") result("total", total) if (total >= targetAC) { let dmg = roll(damageDice) + getMod(stat) result("hit", "yes") result("damage", dmg) npcAdjustResource(target, "HP", 0 - dmg) } else { result("hit", "no") } |
The language has variables (let), if / else, while, return, arithmetic, comparisons, and and / or / not. Text handling covers split, match, capture, and friends. Game access goes through a fixed set of functions:
| Function | What it does |
|---|---|
roll("2d6") | Roll dice, get the total |
getStat(key) setStat(key, v) | Read or write a core stat |
getMod(key) | A stat's computed modifier |
getVar(key) | Any derived value, level, or xp |
getResource(key) adjustResource(key, delta) setResource(key, v, max) | Read and change resource pools |
setInfo(field, v) | Name, concept, level, or xp |
npcAdjustResource(name, key, delta) npcGetResource(name, key) | Damage or heal a scene NPC |
addFeature(category, name, desc) | Add an item to a category panel |
result(key, value) | Report a value back to the Game Master |
log(message) | Debug output while testing |
Scripts run in a closed sandbox with an operation budget, so a script can never touch anything outside the game or hang your browser. Errors show line numbers when you save.
A parser is a script that reads a character file and fills the sheet, the same way the built-in modes import from their exporters. The parser receives the file's contents as text and pulls values out with capture, which applies a pattern and returns the matched group. When a mode has a parser, an Import Character Sheet button appears with the mode on the start page. Both templates include one that reads plain-text sheets, ready to adapt to whatever format your group uses.
Every custom mode tracks the characters in the current scene. The Game Master adds enemies and allies as they appear, gives them stats and resource pools from your definitions, applies damage as fights progress, and clears them when the scene moves on. They show in the Scene Characters panel and in your scripted tools through the NPC functions.
Custom modes work in multiplayer. The host's mode definition syncs to every player in the session, so the whole table plays under the same rules without anyone importing anything first.
| You can write | Meaning |
|---|---|
+ - * / % | Arithmetic, with parentheses for grouping |
floor(x) ceil(x) round(x) | Rounding down, up, or to the nearest whole number |
min(a, b) max(a, b) | The smaller or larger of two values |
abs(x) | Absolute value |
Stat keys, level, xp | Current values from the sheet |
KEY_mod | A stat's computed modifier, when it has a modifier formula |
That is the whole language. Formulas are pure arithmetic evaluated in a small calculator; they cannot run code, which is what makes sharing mode files safe.
Export writes the mode to a small JSON file; Import loads one. Send them to friends, post them for your group, keep backups. Every save file made with a custom mode embeds the full mode inside it, so an adventure keeps working even on a browser that has never seen the mode.
Say you want to run a classic d20 space opera game. Stats are the six abilities with the standard modifier formula. Resources are hit points, a pool of luck points with max 5 + floor(level / 2), and a wound track counter. Derived values are the defenses, each 10 + level plus a modifier, and a damage threshold. Skills key off their abilities. The rules text explains how checks resolve, what moves the wound track, and when luck points can be spent. Clone the 5e template to start from a working d20 chassis and reshape it to match the book on your shelf.
Why it works
Checks roll the mode's dice convention and apply the modifiers your formulas define, not generic fantasy defaults.
Stats, resources, and progression render in your sidebar and update as the Game Master uses the mode's tools during play.
Upload the book you own and the Game Master searches it mid-game for anything the mode does not spell out.
Modes are data, not code. Imported files cannot run scripts, so trading modes with strangers is safe.
Save files embed the whole mode, so a campaign opens years later even if the mode was deleted.
Custom modes ride on the same persistent memory as everything else, so long campaigns stay consistent.
Questions
Yes, if you can describe the system. A custom mode gives the AI your stats, dice, resources, and rules text, and it runs checks and tracks the sheet by those rules. Older and out-of-print systems work as well as current ones.
No. The builder is a form: name your stats, list your skills, write the rules in plain language. Formulas are optional and look like the math already printed in your rulebook.
Yes. Export it as a small file and send it. Anyone can import it from the Mode Builder, and save files carry the whole mode inside them.
Yes. A mode is data, not code. Formulas run in a calculator that only does arithmetic, and every text field is treated as plain text. An imported mode cannot run scripts or touch your account.
Both are built in with full native support, and both also ship as builder templates with scripted attack, save, and rest tools plus an import parser, so you can clone either as a working d20 chassis for homebrew.
Yes. The host's mode syncs to everyone in the session automatically.
In your browser, like your saves and worlds. Export anything you care about to a file. Nothing is stored on a server.
Build the mode once, then play it with a Game Master that never needs to check the book twice.
Open the Mode BuilderMore: how to play a solo RPG with AI, upload your own lore, the 5e mode, the PF2e mode, or everything Auferet does.