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, choose Build Your Own under Game system. Start blank, clone a template, or import a mode file a friend sent you.
Every section is optional: attributes, pools, computed numbers, checks, states, advancement. A diceless narrative game can be nothing but rules text; a crunchy system can use it all.
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.
The check style covers both families of system: roll over means dice plus modifier against a difficulty, the d20 way. Roll under means the roll succeeds at or below the target, the way percentile systems work, with your modifiers raising the target instead of the roll. Leave the dice field empty for a diceless system, and the Game Master resolves outcomes narratively from your rules text.
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.
States are the temporary things your system tracks on a character: conditions, injuries, stances, forms, whatever your book calls them. Not every game has them, and the section only appears if yours does. Each one carries its own mechanics. The effects text tells the Game Master exactly what the condition does, and it enforces that in play. The check modifier applies to every roll automatically while the condition is active, so a poison that gives -2 to everything actually gives -2 to everything. Mark a condition as valued when it comes in levels, like Frightened 2; the modifier multiplies by the value.
The Game Master applies and removes conditions with a dedicated tool, on your character and on enemies. Active conditions show as chips on your sheet, and both templates ship with the full condition list of their system, effects included.
Every value your game tracks that is not a plain number: on/off flags like Inspiration, a choice from fixed options like a stance or an exploration activity, stepped clocks and condition tracks with labeled stages, or a short text value like the spell a character is concentrating on. The Game Master records every change with a dedicated tool and the current values sit on your sheet as live controls, so nothing depends on the Game Master's memory.
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 your own notes or reference documents in-game. The Game Master searches uploaded documents during play, so the mode carries the sheet and the core loop while your notes cover 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("1d8+2") | Roll dice, with an optional flat modifier, 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 |
addSkillBonus(skill, bonus) getSkillBonus(skill) | Register or read a flat skill/save bonus |
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 way the 5e and PF2e library systems import their character sheet exports. 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.
A mode can carry its own reference documents, the same way worlds do. Attach rule summaries or house-rule notes in the builder and the Game Master can search them while running your system. Exporting the mode bundles the documents into the file, so anyone who imports it gets the rules reference along with the mechanics. Up to four documents, 8 MB each.
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.
You can also publish a mode straight from the builder. Published modes appear on the Game modes shelf of the library, where anyone can browse them, add them with one click, rate them, and leave comments. The published file lives in your own Google Drive, so you keep ownership and can pull it any time. Reference documents you attached travel with it.
A world can declare the system it runs. When you create a world, pick Custom system and choose one of your modes; the mode embeds inside the world, so anyone who plays that world plays it under your rules, no separate install needed. And any world built without a declared system runs under whatever mode you have active, so your favorite homebrew system works in every freeform world in the library.
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 published in the game modes library by the Auferet team, with scripted attack, save, and rest tools plus a character sheet import. Install either from the library in one click, and clone it in the builder 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 Builder