ComfyUI conditionals

Predicates → boolean → branch. How the decision is formed, not where the signal goes after.

Four packs contribute predicate primitives. The split:

When to Use This Skill

Sources of truth

• custom_nodes/comfyui-easy-use/py/nodes/logic.py — ifElse, compare, blocker, is* probes
• custom_nodes/comfyui-impact-pack/modules/impact/special_samplers.py — ImpactCompare, ImpactConditionalBranch
• custom_nodes/comfyui_essentials/misc.py — SimpleMath / SimpleCondition / SimpleComparison
• custom_nodes/comfyui-logicutils/logic_gates.py — logic gate nodes

Which compare node?

Type coercion footgun

ImpactConditionalBranch.cond is BOOLEAN. Don't feed it:

• SimpleMathCondition output → that's FLOAT (0.0 / 1.0) — convert via comparator first
• easy compare output → that IS BOOLEAN, fine
• LogicGateCompare output → BOOLEAN, fine
• A raw INT from a math node → not BOOLEAN; pass through ImpactCompare (a > 0) or convert

When in doubt, route through easy compare and pick the comparison operator that yields the boolean you want.

Boolean algebra

For combining multiple predicates into one branch input:

isMaskEmpty(face_mask) ──┐
                         ▼
                ImpactNeg (NOT)  ──┐
                                   ▼
            ImpactLogicalOperators (AND) ──→ ImpactConditionalBranch
                                   ▲
isFileExist(reference.png) ────────┘

This combination says: "face mask is non-empty AND reference image exists on disk → run the detailer branch".

Branching

Lazy if-then-else (skips the discarded branch)

These are predicate-side nodes that ALSO act as switches — they form the boolean and route in one step. If your predicate is simple (one comparison) and the branches are large (samplers, models), ImpactConditionalBranch is the cleanest single-node solution.

If the predicate is complex (multi-criteria), form it explicitly in this skill's primitives, then pass the resulting BOOLEAN to a switch from comfy-flow-control.

Ternary (compute, don't route)

SimpleCondition (essentials) — given condition, returns value_if_true or value_if_false. Both inputs are computed (eager), so it's a value picker, not an execution gate. Use it for selecting between two constants or already-computed scalars; never for selecting between sampler chains.

ExecutionBlocker — the kill-path primitive

easy blocker is the canonical "kill this path" node. Behavior:

• Input: any value + continue BOOLEAN.
• If continue=True: pass the value through unchanged.
• If continue=False: returns an ExecutionBlocker sentinel.

The sentinel propagates downstream: any node that receives an ExecutionBlocker on any input is silently skipped (its execute() is never called). The skip cascades through the rest of the graph downstream of the blocker.

LoadImage ── easy compare (size > 1024) ─┐
                                         ▼
LoadImage ──────────────► easy blocker ───► ResizeImage ─► KSampler ─► SaveImage
                            ▲ continue

When the loaded image is smaller than 1024px, the blocker fires; ResizeImage / KSampler / SaveImage are all skipped without errors.

ExecutionBlocker gotchas

• Preview Bridge swallows the sentinel — see comfy-flow-control gotchas. The blocker fires, but a Preview Bridge tee downstream reports nothing visibly, and fails to propagate the abort. Use FastPreview (kjnodes) downstream of a blocker if you need visual confirmation.
• Cannot be visualized — there's no "is this currently blocked?" light. Add an easy showAnything on the BOOLEAN that drives the blocker to confirm at queue time.
• No partial recovery — once a path is blocked, every downstream node in that chain is skipped, period. To preserve a parallel path through the same upstream value, tee BEFORE the blocker, not after.

Null / empty / type probes

Use cases:

• Detector pipelines: isMaskEmpty(face_mask) → blocker to skip detailer when no face is found.
• Optional reference image: isFileExist(ref_path) → switch between "use reference" and "no reference" branches.
• Multi-architecture workflows that need different sampler defaults: isSDXL(pipe) → switch sampler configuration.

Logicutils — strings, bits, regex

comfyui-logicutils is the sole source for:

• Regex / substring on strings — LogicGateCompareString (also registered as AContainsB). Pass a regex pattern in b, a string in a, get BOOLEAN.
• Bitwise integer ops — for flags packed into a single INT. Niche; mostly useful when interfacing with external systems that send flag bitmasks.
• LogicGateInvertBasic — generic invert that handles any truthy/falsy input (more lenient than ImpactNeg, which expects strict BOOLEAN).

Iterator stop

ImpactConditionalStopIteration — only useful inside an Impact detector→detailer iterator loop. Takes a BOOLEAN; when True, halts the iterator's next round. The iterator must support stop signals (detector-pipeline variants do; non-iterating Impact paths ignore it).

Recipes

Skip face-detailer when no face detected

LoadImage ──► BBoxDetector ──► IMAGE/MASK output
                                    │
                                    ▼
                            easy isMaskEmpty ──► (BOOLEAN)
                                                    │
                                                    ▼ (invert: empty → skip)
                                              ImpactNeg
                                                    │
                                                    ▼
                            ┌───────► easy blocker ◄────── (the image+mask payload)
                            │           continue
                            ▼
                  (downstream FaceDetailer chain, silently skipped on empty)

isMaskEmpty → True when no face found → ImpactNeg flips it → False → blocker fires → FaceDetailer + SaveImage chain is skipped without error.

Multi-criteria gate

"Run the high-quality upscale path only if the image is large AND the reference exists AND we're not in SDXL mode":

GetImageSize&Count(image) ──► width  ──► easy compare (> 1024) ──┐ (BOOL)
                                                                  │
easy isFileExist(ref_path) ──► (BOOL) ───────────────────────────┤
                                                                  │
easy isSDXL(pipe) ──► ImpactNeg (NOT SDXL) ──► (BOOL) ───────────┤
                                                                  ▼
                                              ImpactLogicalOperators (AND of 3)
                                                                  │
                                                                  ▼
                                                  ImpactConditionalBranch
                                                  tt = upscale chain
                                                  ff = passthrough

Three independent predicates combined with AND. The downstream branch is fully lazy: when any predicate is False, none of the upscale chain runs.

Distinguish "first run" from "rerun" via file existence

Useful for caching: if an output file already exists, skip regeneration.

easy isFileExist("output/cached_step1.png") ──► (BOOL)
                                                  │
                                                  ▼
                                  ImpactConditionalBranch
                                  tt = LoadImage from cache
                                  ff = run full pipeline + SaveImage

Gotchas

• Floats and equality: easy compare with == on FLOATs is a trap. Use SimpleComparison (epsilon-aware) or easy compare with < / > instead. 1.0 + 2.0 == 3.0 is True, but 0.1 + 0.2 == 0.3 is False.
• Lazy branch + ComfyExecutionBlocker: lazy nodes (easy ifElse, ImpactConditionalBranch) won't evaluate the unselected branch, but they pass through whatever node-graph value the selected branch produces — including an ExecutionBlocker sentinel. If both branches can emit blockers, plan the merge carefully.
• SimpleMathCondition returns FLOAT (1.0 / 0.0), not BOOLEAN. Pass through ImpactCompare (> 0.5) before feeding a switch that wants BOOLEAN.
• easy isNone on a pipe: pipes (PIPE_LINE) are tuples — isNone returns False on an empty pipe (the tuple exists, just with None fields). To detect missing pipe content, unpack with pipeOut and probe individual fields.
• AContainsB is regex, not substring: special characters need escaping. To do a plain substring check, escape with \Q...\E or use Python regex-special escapes manually.

Cross-refs

• comfy-flow-control — once the boolean is formed, this skill points at the switches that consume it (typed switches, ExecutionBlocker propagation, broadcast routing).
• comfy-math-strings — math primitives that feed comparisons (constants, sliders, SimpleMath expressions, GetImageSize&Count outputs).
• comfy-debug-preview — ShowAnything / ShowText for inspecting the BOOLEAN being passed to a branch at queue time.

Things this skill does NOT cover

• Switching / routing AFTER the decision — that's comfy-flow-control.
• Numerical computation that doesn't yield a BOOLEAN — arithmetic, math expressions, string formatting → comfy-math-strings.
• Image / mask manipulation upstream of the probe — getting a mask in the first place via segmentation, detection, etc. is model-inference work, not utility.
• Sampler-time conditionals — model_sampling, CFG scheduling, step gating within the diffusion loop is sampler/model territory, not workflow logic.