Operator nodes
All 17 operator nodes share the same shape: pure, value-producing, no execution pins — they never sit in a handler chain themselves, only feed a value into one. Every operator has an empty config schema; instead, an unwired input's literal default is edited directly on the pin itself, right on the canvas.
Every operator resolves its result the same way: resultIdentifier is
`_op_<sanitized node id>`, and it emits
const _op_<id> = (<expression>);
If an input pin is left unwired with no literal typed in, arithmetic/comparison
operators fall back to 0 and boolean operators fall back to false — they never throw
for a merely-unwired input.
Usable both on the main canvas and inside a Function Graph — full parity, no exceptions.
Arithmetic
Inputs a, b (value); output result (value).
| Node type | Label | Generated expression |
|---|---|---|
operators.add | Add | a + b |
operators.subtract | Subtract | a - b |
operators.multiply | Multiply | a * b |
operators.divide | Divide | a / b |
operators.modulo | Modulo | a % b |
// Add, a = 17, b = 5
const _op_add1 = (17 + 5);
Comparison
Inputs a, b (value); output result (value). Same shape as arithmetic, just a
different operator.
| Node type | Label | Generated expression (default) |
|---|---|---|
operators.equal | Equal | a === b (strict); a == b (loose) |
operators.notEqual | Not Equal | a !== b (strict); a != b (loose) |
operators.greaterThan | Greater Than | a > b |
operators.lessThan | Less Than | a < b |
operators.greaterOrEqual | Greater Or Equal | a >= b |
operators.lessOrEqual | Less Or Equal | a <= b |
Strict vs. Loose Comparison (Equal and Not Equal)
Equal and Not Equal nodes have a Strict checkbox in their config panel (on by
default). When enabled, they use JavaScript's strict comparison operators (=== / !==),
which compare both value and type. When disabled, they use loose comparison operators
(== / !=), which perform type coercion before comparing — for example, 1 == "1"
evaluates to true, while 1 === "1" evaluates to false.
Other comparison nodes (Greater Than, Less Than, Greater Or Equal, Less Or Equal) do
not have a Strict option — JavaScript has no loose-comparison counterparts for >, <,
>=, <=, so they always use their single behavior unchanged.
Equal and Not Equal's unwired literal inputs accept any JS value — strings (type them
with quotes, e.g. "hello"), booleans (true/false), null, object/array expressions,
not just numbers. A wired connection already accepted any type; this only affects the
inline literal box on the pin itself. The other four comparisons (Greater Than, Less Than,
Greater Or Equal, Less Or Equal) are unchanged and remain numeric-only, since >/< on a
non-number is rarely what's intended.
Boolean (variadic)
Inputs a, b, plus any number of extra inputs added on canvas via a "+ Add pin"
button (stable, non-renumbered ids like extra-0, extra-3); output result (value).
Every operand is wrapped in Boolean(...) before combining, so the result is always a
real boolean, never a raw truthy passthrough.
| Node type | Label | Combines operands with |
|---|---|---|
operators.and | AND | && — true only if every input is truthy |
operators.nand | NAND | negated AND — false only if every input is truthy |
operators.or | OR | || — true if at least one input is truthy |
operators.nor | NOR | negated OR — true only if every input is falsy |
operators.xor | XOR | pairwise !== fold — true if an odd number of inputs are truthy |
// AND with 3 inputs
const _op_and1 = (Boolean(a) && Boolean(b) && Boolean(c));
// XOR with 2 inputs
const _op_xor1 = (Boolean(a)) !== (Boolean(b));
Unary
The one operator with a single input.
NOT — operators.not
- Inputs:
a(value) - Outputs:
result(value)
const _op_not1 = !(Boolean(a));
A main-canvas example
Operators aren't limited to Function Graphs — wiring operators.add (with literals
a: 5, b: 7) into a Set Variable node's Value pin, reached from a Begin node,
hoists the declaration ahead of it automatically:
const _op_add1 = 5 + 7;
sum = _op_add1;
See How Code Generation Works for why this hoisting happens even though nothing wired the operator directly into the exec chain. The same hoisting also applies inside a Handler Function's blueprint-mode body — wiring an operator into a Console Log node's Value pin there works the same way.