Groups and Batches
As your sheet gets more complex, the Logic Editor canvas can get crowded. Groups and batch nodes are your two tools for keeping things manageable.
- Groups are visual containers that organize your nodes — like folders for your logic.
- Batch nodes handle repetitive patterns — one node replaces dozens of identical chains.

Logic Groups
A Logic Group is a visual box you place around a set of related nodes. It has no effect on how your logic runs — it is purely organizational.
Creating a Group
There are two ways to create a group:
- From existing nodes — Select the nodes you want to group (box-select by dragging on empty canvas, or Shift-click individual nodes), then right-click and choose to group the selected nodes. The group wraps around everything you selected.
- From the sidebar — Drag a Logic Group node from the Groups category in the sidebar onto the canvas. This creates an empty group that you can then drag nodes into.
Give the group a descriptive name (e.g., "Ability Modifiers", "Combat Calculations", "Spell DCs") so you can identify it at a glance.
Customizing Groups
- Name — Click the group title to rename it. Use descriptive names so you can find things quickly.
- Color — Each group can have a background color to visually distinguish different sections of your graph. For example, you might use blue for ability-related logic, red for combat, and green for skills.
- Resize — Drag the edges of a group to make it larger or smaller.
Moving Groups
When you drag a group, all the nodes inside it move together. This makes it easy to rearrange your canvas without breaking the layout of a carefully arranged set of nodes.
Groups and Connections
When you connect two nodes, if they are not in a group a group will be created. If one of them is in a group, the other one will be added to the group. If both nodes are in a group, the groups will be merged into a single group.
Batch Nodes
Batch nodes solve a specific problem: repetitive formulas.
Consider D&D 5e ability scores. The modifier formula is the same for all six abilities — floor((score - 10) / 2). Without batch nodes, you would need to build that chain of nodes six separate times, once for Strength, once for Dexterity, and so on. That is 42 nodes and 36 connections for what is conceptually a single formula.
A Batch Processor lets you define the formula once and apply it across a table of data points.
How Batch Nodes Work
A Batch Processor has two parts:
- Slots — The inputs and outputs of your formula. You define what goes in and what comes out.
- Rows — A table where each row maps to one instance of the formula. Each row specifies which attributes plug into which slots.
The Batch Processor runs your formula once for each row, substituting the row's attribute names into the slots.
Walkthrough: Ability Score Batch
Here is how you would set up a batch node that calculates all six D&D 5e ability modifiers.
Step 1: Define the Slots
Create the following slots on your Batch Processor:
| Slot Name | Direction | Purpose |
|---|---|---|
| Score | Input | The raw ability score |
| Modifier | Output | The calculated modifier |
Step 2: Build the Subgraph
Inside the batch node, you build the formula just once using the slot names as stand-ins:
- Read Score (input slot)
- Subtract
10 - Divide by
2 - Floor the result
- Write to Modifier (output slot)
This is the same chain of nodes from the ability modifier example, but instead of referencing specific attributes like strength, it uses the generic slot names.
Step 3: Fill the Table
Each row tells the batch which real attributes to use:
| Row | Score | Modifier |
|---|---|---|
| Strength | strength | strength_mod |
| Dexterity | dexterity | dexterity_mod |
| Constitution | constitution | constitution_mod |
| Intelligence | intelligence | intelligence_mod |
| Wisdom | wisdom | wisdom_mod |
| Charisma | charisma | charisma_mod |
The Batch Processor applies the formula to every row. All six modifiers are calculated from a single set of nodes.
You can add a default value to any slot. If a row leaves a slot blank, the default is used instead. This is handy when most rows share a common value but a few are different.
Walkthrough: Skill Batch
Skills in D&D 5e follow another repetitive pattern: each skill bonus equals the relevant ability modifier plus the proficiency bonus (if proficient). That is 18 skills, all with the same formula but different ability scores and attribute names.
A skill batch might have these slots:
| Slot Name | Direction | Purpose |
|---|---|---|
| Ability Mod | Input | The relevant ability modifier (varies by skill) |
| Proficiency Flag | Input | Whether the character is proficient (0 or 1) |
| Prof Bonus | Input | The proficiency bonus value |
| Skill Bonus | Output | The calculated skill bonus |
The subgraph multiplies Prof Bonus by Proficiency Flag, then adds Ability Mod to get the final Skill Bonus.
Each row maps a skill to its specific attributes:
| Row | Ability Mod | Proficiency Flag | Prof Bonus | Skill Bonus |
|---|---|---|---|---|
| Athletics | strength_mod | athletics_prof | proficiency_bonus | athletics_bonus |
| Acrobatics | dexterity_mod | acrobatics_prof | proficiency_bonus | acrobatics_bonus |
| Arcana | intelligence_mod | arcana_prof | proficiency_bonus | arcana_bonus |
| Stealth | dexterity_mod | stealth_prof | proficiency_bonus | stealth_bonus |
| Perception | wisdom_mod | perception_prof | proficiency_bonus | perception_bonus |
| ... | ... | ... | ... | ... |
Notice that proficiency_bonus repeats in every single row — you could set it as the default for the Prof Bonus slot and leave those cells blank. Only rows that need a different value would need to fill that column in.
Adding Rows Later
One of the advantages of batch nodes is that adding more instances is easy. If you homebrew a new skill or your game system has additional ability scores, you just add a row to the table. No new nodes or connections needed.
When to Use Batches vs. Individual Nodes
Use a Batch Processor when:
- You have the same formula applied to three or more sets of attributes
- The formula is identical except for which attributes are read and written
- You might add more rows later (e.g., adding homebrew skills)
Use individual nodes when:
- The calculation is unique (e.g., Armor Class, which has its own special formula)
- There are only one or two instances of a pattern
- The logic varies significantly between instances
A good rule of thumb: if you catch yourself copying and pasting a chain of nodes, stop and consider whether a Batch Processor would be cleaner.
Batch nodes generate the same sheet worker code as individual nodes during export. There is no performance difference — it is purely about how you organize your graph in the editor.