How to Create a Custom RPG System on Mini Kraken

Sooner or later, every group bumps into the limits of off-the-shelf tools. Maybe you're writing your own game. Maybe you play an indie system that never got an official sheet. Maybe your table has bent a popular system so far with house rules that the "official" sheet no longer fits. Whatever the reason, the answer is usually the same frustrating one: you make do.

Mini Kraken's modular sheet exists precisely so you don't have to make do. Because a sheet is built from blocks, you can build one for any system — and then turn it into a reusable template that you and other players can spin up new characters from in a single click. That's what "creating a custom system" means here: not writing code, but designing a sheet and saving it as a blueprint.

This guide walks through that journey, from a blank canvas to a system you can share.

What a "system" actually is on Mini Kraken

It helps to get the vocabulary straight first, because two words do a lot of work.

• A sheet is one character — Aldric the paladin, with his specific hit points and his specific sword.
• A template (or system) is the blueprint every Aldric is stamped from — the layout, the attributes, the formulas, the resource setups that every character in your game shares.

When you create a custom system, you're building that blueprint once. After that, anyone can create a new character from it and immediately have the right sheet, already laid out, already doing the math. Update the blueprint and the changes can flow down to the characters built from it. One source of truth, many characters.

Step 1: Start from the closest thing you have

You don't have to begin with an empty page, and usually you shouldn't. Ask yourself what your system is closest to:

• If it's a variant of a system Mini Kraken already supports — a hacked version of D&D, a 3DeT spin, a tweaked Ordem Paranormal — start from that ready-made template. You'll keep everything that already works and only change what's different.
• If it's genuinely its own thing, start from a blank sheet and build up.

Either way, the first real work is the same: get a single character sheet looking and behaving the way every character in your system should.

Step 2: Build the sheet with blocks

This is where the modular sheet earns its keep. Switch into Layout Mode and assemble the sheet from blocks (if you haven't met them yet, our tour of the modular sheet is a good primer). For a custom system, a few decisions matter most:

• Pick your core stats. Add an Attributes block and define the stats your game actually uses — three attributes or thirteen, named whatever your game names them. Set up modifier handling if your system derives bonuses from stats.
• Decide what's tracked. A Vitals block for the resources that go up and down constantly — health, stress, mana, sanity, whatever your game runs on.
• Add the lists. A Skills block, Tables for things like maneuvers or talents, Text Input blocks for the prose your game cares about.
• Organize it. Group related blocks in Containers, and if the sheet gets busy, split it into Tabs so combat, inventory, and story each get their own space.

The goal of this step is a sheet that feels like your game — laid out the way you'd want every player to see it.

Step 3: Make it think with variables

A blueprint that only holds blank fields is a glorified PDF. The magic of a custom system is that the math is baked in, so your players never have to compute a derived value by hand.

Give your important values names and reference them with the @{...} syntax. Then build your system's rules as formulas:

• Derived stats: a defense value that's 10 + @{AGILITY}, a carry limit that scales with @{STRENGTH}.
• Growth: a max-HP field that grows with @{LEVEL}, so leveling up just works.
• Rolls: actions written as dice expressions like 1d20 + @{SKILL}, so the sheet rolls correctly out of the box.

Names are forgiving — case and accents don't matter, and spaces become underscores automatically — so you can name variables in plain language. Get this layer right and you've encoded your system's rules, not just its appearance. Every character built from the template will calculate the same way, every time.

Step 4: Define your items, spells, and gear

Most systems have a library of "things" — weapons, spells, talents, gadgets, rituals. On Mini Kraken these are Resource Cards, and a custom system is the moment to define what one of your cards looks like.

You design the shape of a card once — what fields it carries (a weapon's damage and range, a spell's cost and level), what roll actions it offers, what trackers it needs (charges, slots, ammo), and what happens when it's used via triggers. That shape becomes a reusable schema, so when a player adds a new weapon to their character, it already has the right fields waiting to be filled in. You're not just listing your game's content — you're teaching the system what your content is.

If your game has monsters or NPCs with stat blocks, you can enable a creature catalog for your system too, so the same care you put into player sheets extends to everything the party fights.

Step 5: Turn the sheet into a template

Once your sheet looks right and does the math, you promote it from "a character" to "a system." This is the step that makes everything reusable: you turn the finished sheet into a template, and from then on it can be used to create brand-new characters that all start from your blueprint.

Then you give the system its identity. A template can carry:

• A name and a description — what your game is and who it's for.
• A longer about section in rich text, for setting, tone, and how-to-play notes.
• A cover and banner image, so it looks like a real product in the gallery.
• Links out to where people can buy or learn about the game, and a place to credit its author and license.

This metadata isn't busywork — it's what turns a private sheet into something that looks and feels like a system other people would want to play.

Step 6: Share it (or keep it yours)

A custom system is more fun when it's not locked in a drawer. Mini Kraken gives you a few ways to handle that:

• Keep it private while it's a work in progress, visible only to you and your table.
• Share it so others can see your system and create characters from it.
• Let others fork it — make their own copy to adapt for their table — with your authorship still credited on the original. This is how a homebrew grows: someone takes your skeleton and builds their own variant, and the lineage stays visible.

Homebrew you create can be linked back to the official system it's based on, so a "D&D, but our way" variant lives alongside the system it descends from rather than floating off on its own. Your custom resource schemas and creature variants can live in a personal library tied to the system, ready to reuse across characters and campaigns.

A realistic first project

If this all sounds like a lot, here's the honest reassurance: you don't have to do it in one sitting, and your first system doesn't have to be perfect. The most rewarding way to learn is to pick something small and real:

1. Take a one-page indie game you love that has no sheet yet.
2. Build a single sheet for it — attributes, a tracker or two, one Resource Card shape.
3. Wire up the handful of formulas it needs.
4. Save it as a template and make your next character from it.

That loop — build, save, reuse — is the entire skill. Do it once on something small and you'll understand the whole thing, and the next system will go faster.

The bigger point is this: Mini Kraken doesn't decide which games are worth supporting. You do. If your game can be written down, it can be a system here — laid out the way you imagined it, doing its own math, and ready for the next person to roll a character and play.

Not sure where the building blocks come from? Start with our friendly tour of the modular character sheet, then come back and turn what you've learned into a system of your own.