Overview

Every Rule already runs a straightforward list of Actions from top to bottom. That covers most of what a stream needs. But some ideas don’t fit a flat list — only shock if the last shock was more than 30 seconds ago, wait for both a follow AND a chat message before triggering, flash the lights five times then stop. The Action Flow Designer is a second, graph-based view of the same automation system, built for exactly those cases.

You’ll find it inside Rules & Actions, under the Flow Designer tab, sitting alongside the existing flat Rules list. Switching between the two is a simple slide-and-fade — your Rules and Actions aren’t duplicated or reconfigured, they’re just referenced and wired together on the canvas.

Note: Flow Designer is additive. Nothing about your existing Rules changes by opening it, and a Rule that isn’t part of any flow keeps firing exactly as it always has.

Canvas & Node Types

The canvas is full-bleed and pans/zooms freely: scroll to zoom, and pan with a middle-mouse drag or Alt+drag. Along the bottom sits the orb dock — four draggable node types you can drop straight onto the canvas. Your existing Rules and Actions become nodes too, dragged in from the same dock (they open a picker so you choose which Rule or Action to reference).

Node	Sockets	What it does
Rule	Output only	An entry point. References one of your configured Rules and fires from the real event system — nothing can be wired into a Rule node.
Action	Input + Output	Runs one of your configured Actions. Has both sockets, so Actions can be chained one after another.
Delay	Input + Output	Waits a set number of seconds before continuing to whatever’s wired after it.
Logic	Input + Output	An AND / OR / NOT gate for combining multiple triggers. See below for how each operator behaves.
Branch	Input + `true`/`false` outputs	The “if” node. Routes down one of two paths depending on its `Mode` — see Branch Modes below.
Loop	Input + `body`/`done` outputs	Repeats its `body` path a set number of times, then continues out `done` once finished.

Logic Gates

AND — waits until every distinct wire feeding into it has fired at least once (within a short correlation window) before continuing.
OR — continues as soon as the very first incoming wire fires.
NOT — inverts the result.

Building a Flow

You’re not limited to dragging orbs one at a time. Press Tab, or double-click any empty patch of canvas, to open the spotlight — a quick-add popup for searching and inserting Rules, Actions, or flow-only nodes without touching the dock.

A single Flow Designer instance can hold multiple named flows at once, switchable from tabs along the top — add, rename, switch, or delete a flow without leaving the canvas. Within a flow, drag a box around nodes to marquee-select several at once, then use the align-row, align-column, and distribute-horizontally tools to tidy a busy graph, or duplicate/delete the whole group in one action.

Every change is undoable with Ctrl+Z (redo with Ctrl+Shift+Z), and selected nodes nudge with the arrow keys for pixel-precise placement.

Wiring & Connections

To connect two nodes, drag from a node’s output socket — the small dot on its right edge — onto another compatible node. The same exact wire can’t be created twice between the same two sockets.

There are three ways to remove a wire:

Click its delete button — a small × sits at the wire’s own midpoint, always visible regardless of how nodes overlap, so you never have to hunt for a pixel-thin line to click.
Right-click a node → Disconnect wires — removes every wire touching that node in one go.
The node inspector’s Inputs/Outputs lists — see below.

The Node Inspector

Selecting a node opens a floating inspector panel in the top-right of the canvas. Alongside that node’s own settings, the inspector lists every wire touching it in two scrollable lists — Inputs and Outputs — each entry showing the node on the other end, with its own small delete button to remove that one connection individually. It’s the fastest way to audit or prune a node’s wiring without squinting at the graph.

Right-clicking any node also opens a context menu with Duplicate, Disconnect wires, and Delete.

Test Fire

The Test Fire button runs the active flow for real, starting from every Rule node in it. This isn’t a dry run or a simulation — it executes your actual configured Actions, exactly as if the real trigger had happened, and animates the executed path across the nodes as it goes so you can watch the run travel through your graph in real time.

Note: Because Test Fire runs real Actions, anything with a visible or physical effect — lights, PiShock, overlays, chat messages — will actually happen. Treat it the same as triggering the Rule for real.

Branch Modes

The Branch node’s Mode setting, in its inspector panel, controls which path it takes:

Mode	Behavior
Logic (default)	Reads whichever Logic gate is wired into the Branch’s input and routes to `true` or `false` based on its result.
True	Always takes the `true` path, regardless of what’s wired upstream.
False	Always takes the `false` path, regardless of what’s wired upstream.

Tip: True and False mode aren’t just for finished flows — they’re a fast way to test one side of a branch in isolation while you’re still building the other, without needing a full Logic-gate setup wired in yet.

Safety Rails

Loops and Logic gates open the door to a wire cycle that could, in theory, run forever. The engine guards against that with a few hard, non-user-configurable ceilings: a per-loop-node iteration cap, a total-node-executions cap for a single run, and a time-windowed cap on how many times a Logic gate may fire. These exist specifically so a wire looping back through a gate can’t spiral out of control.

If a run ever hits one of these ceilings, it aborts just that branch of the flow gracefully — nothing crashes, and the rest of your app keeps running normally.

Where This Fits vs. Plain Rules

A plain Rule is still the right tool for most automations: one trigger, one ordered list of Actions, done. Reach for the Flow Designer specifically when you need something a flat list structurally can’t express:

Branching — do one thing or another depending on a condition, instead of always running the same steps.
Looping — repeat a short sequence a bounded number of times.
Combining multiple triggers — wait for two or more separate Rules to fire together (or take the first of several) before continuing, via a Logic gate.

Both systems read from and write to the same Rules and Actions — nothing you build in one is invisible to the other. Think of Flow Designer as the layer you add on top once a flat list stops being enough.