Getting to Know Mini Kraken's Modular Character Sheet

Most virtual tabletops treat the character sheet as a fixed form. You get the boxes the developers decided you should have, in the order they decided, and if your game does something different, you improvise in a notes field. It works, but it always feels a little like wearing someone else's coat.

Mini Kraken takes a different approach. The character sheet isn't a form — it's a canvas you build from blocks. You decide what goes on it, where, and how it behaves. That sounds intimidating at first, but the whole point is that you don't have to start from scratch unless you want to. This is a friendly tour of how the modular sheet works, so the next time you open one you know exactly what you're looking at.

The big idea: a sheet made of blocks

Everything on a Mini Kraken sheet is a block. An attributes panel is a block. Your HP and AC tracker is a block. A section heading, a free-text backstory field, a table of spells, a button that rolls a saving throw — all blocks. The sheet is just an arrangement of these pieces on a grid.

That single idea is what makes the sheet "modular." Instead of one giant fixed layout, you have a set of interchangeable parts you can add, remove, rearrange, and resize. A rules-heavy game can have a dense sheet full of trackers and tables; a narrative game can have a clean sheet that's mostly prose and a few stats. Same tool, completely different sheets.

The building blocks you'll actually use

When you add a block, you pick from a small catalog grouped by purpose. You don't need to memorize it — here are the ones that matter most:

The essentials:

• Vitals — your at-a-glance survival stats: hit points, armor class, initiative, speed. The trackers you reach for every turn.
• Attributes — the core numbers of your character (Strength, Dexterity, and friends), with automatic modifier handling so you're not doing mental math mid-fight.
• Skills — proficiencies, languages, and the long list of things your character is good (or bad) at.
• Portrait — your character's face and basic identity at the top of the sheet.

For content and flavor:

• Text — display-only text for headings, rules reminders, or formatted notes.
• Text Input — editable fields for backstory, bonds, session notes — anything you want to type and keep.
• Table — rows of grouped fields, perfect for things like attack lists or consumables.
• Canvas — a custom image with editable fields laid over it, for when you want a sheet that looks like your sheet.
• Dynamic Button — a custom button that fires an action you define, with its own icon.

For organizing:

• Container — a section that groups other blocks together, so related things stay together.
• Tabs — split a busy sheet into tabs (Combat, Inventory, Story) instead of one endless scroll.

And the one that deserves its own section:

• Resource Cards — the system for items, spells, and equipment. More on these below.

Building the layout: drag, drop, resize

To rearrange a sheet you switch into Layout Mode. This is where the "modular" promise pays off. Blocks become movable: you drag them around the grid, resize them to take up more or fewer columns, and drop them where they make sense for your eye.

The sheet lives on a grid, and you can choose how wide that grid is — a comfortable two-column layout, a denser three-column one for crunchy systems, or a centered, compact column when you want something tidy and focused. Because it's grid-based, things line up neatly instead of drifting into a mess.

Each block also has its own settings. You can give it a title (or hide the title), choose whether it can collapse to save space, make its background transparent or give it a custom color, and even set rules for when it should be visible at all. That last part is quietly powerful: a block can appear only when it's relevant, so spellcasters see their spell section and everyone else doesn't.

Variables and formulas: the sheet does the math

A static sheet just holds numbers. Mini Kraken's sheet can calculate with them, and that's where it starts to feel alive.

Every value on the sheet can be a variable that other parts of the sheet refer to. You reference one by name with the @{...} syntax — for example, @{LEVEL} or @{STRENGTH}. Once a value has a name, you can build formulas on top of it: a field that's always "twice your level," a max-HP value that grows as you level up, a tracker whose ceiling is calculated rather than typed in by hand.

A couple of friendly things to know:

• Variable names are forgiving. Capitalization and accents don't matter — @{Nível}, @{nivel}, and @{NIVEL} all point to the same value. Spaces and special characters become underscores behind the scenes, so you don't have to think about it.
• Formulas understand dice. You can write something like 2d6 + @{MODIFIER} and the sheet knows it's a roll, not just arithmetic.

The payoff is that you set the rules of your character once, and the sheet keeps everything consistent. Level up, change a single number, and every value that depends on it updates itself.

Rolling: real 3D dice, straight from the sheet

A character sheet you can't roll from is just a spreadsheet. On Mini Kraken, the numbers are clickable. Tap an attribute, a skill, or an action on a resource card, and it rolls — with the same real 3D physics dice the rest of the platform uses. The dice actually tumble across the table and settle, instead of a number quietly appearing in a log.

Because the roll knows about your sheet, your modifiers come along for the ride. You're not retyping +5 every time; the sheet already knows your bonus and folds it in. You get the satisfying clatter of physical dice and the convenience of automation, without choosing between them.

Resource Cards: items, spells, and gear that do things

Most of what makes a character interesting beyond their core stats lives in Resource Cards — the structured system for items, spells, equipment, and anything else worth tracking as its own little object.

A resource card is more than a name in a list. Each one can hold:

• A title and a rich, formatted description (with its own image or icon).
• Roll actions — named rolls attached to the card, like a weapon's damage or a spell's effect, ready to fire with a click.
• Trackers — consumable counters like charges, spell slots, or ammunition, with maximums that can be formula-driven.
• Custom fields — typed properties (text, number, yes/no, dropdowns) so a potion, a sword, and a spell can each carry exactly the data they need.
• Triggers — actions that fire on use, so equipping an item or casting a spell can actually change your sheet.
• States like equipped or stored, with quantities, so your inventory behaves like an inventory.

This is what lets a sheet model a real character: not just "Longsword" written in a box, but a longsword you can equip, that rolls its own damage, and that knows how many you're carrying.

You don't start from a blank page

All of this flexibility raises a fair question: do I have to build every sheet by hand? No. Mini Kraken ships with a catalog of ready-made sheet templates for popular systems — D&D 5e and the 2024 edition, 3DeT Victory, Ordem Paranormal, and more. Pick one and you get a complete, properly laid-out sheet in seconds, with all the blocks, variables, and resource setups already done for you.

The modular part is still there waiting whenever you want it. You can play a ready-made sheet exactly as-is, tweak it slightly to match a house rule, or rebuild it entirely. The blank canvas is an option, not an obligation.

There's one more quiet nicety: because Mini Kraken is multilingual, block labels can carry translations, so a sheet can show its labels in the reader's own language. A sheet built once can be comfortable for a table that doesn't all speak the same first language.

A sheet that's always in sync

Finally, none of this would matter if your group couldn't see it. Mini Kraken sheets sync in real time and live in the cloud, with undo and redo if you change your mind. Update a value and your table sees it. Open the sheet on a different device and it's right where you left it. The sheet you built is the sheet everyone's looking at, instantly.

Where to go from here

The modular sheet rewards a little curiosity. The fastest way to understand it isn't to read about it — it's to open a ready-made template, flip into Layout Mode, and drag a block somewhere new. Add a tracker. Name a variable and reference it somewhere else. Watch a roll tumble across the table.

Once the "it's all just blocks" idea clicks, you stop thinking about the sheet as a form you have to live with and start treating it as a tool you can shape. And if your game does something no existing sheet quite captures — that's not a problem to work around anymore. That's just the next sheet you'll build.

If you're ready to take the next step and design a sheet for a game that doesn't have one yet, that's a whole craft of its own — and a great place to start is learning how to turn a sheet into a reusable system other players can pick up too.