Mute Group If (obvpm)

Every big ComfyUI workflow ends up with a region you only sometimes want: the upscale branch, the detail pass, the second sampler for the alternate look. Bypass the node at the end of it and everything upstream still runs - the loaders load, the sampler samples, you just throw the result away. Mute the group by hand and you have to remember to un-mute it tomorrow.

Mute Group If automates that second thing. Put it inside a group, feed it a boolean, and the whole frame goes off while that boolean says so - every node in it set to Never, which means ComfyUI leaves them out of the prompt entirely. Loaders included. Nothing in the group starts. The frame draws greyed, and it comes back the moment the value turns.

How it works

This is frontend work, not graph work. The node's Python side is a no-op with no outputs at all - it isn't in the execution graph, and that's deliberate, because the muting has already happened by the time the prompt exists. A script on the canvas (400 ms poll, plus one more pass immediately before each queue) reads the value, finds the group, and flips every node inside it into mute mode.

The grouping rule is the frontend's own: the smallest group frame containing the node's centre, and the nodes are those whose centres fall inside that frame - the same rule ComfyUI uses to decide what a group drags along with it. Two consequences you'll actually hit: drag the node to another group and the muting follows it without any rewiring, and a node that sits outside every group mutes nothing.

It's also polite about state it didn't create: it tags the nodes it muted, and only those come back, so something you'd muted or bypassed yourself keeps its mode. Two of these over overlapping groups coexist - a node stays muted while any of them wants it. And since 0.2.14 it climbs into subgraphs: one tucked inside a subgraph acts on the group around that subgraph in the graph holding it.

The inputs that matter

Two booleans, no outputs:

• mute - mute this node's group while true. Wire it from a value the graph knows before the run.
• invert - flip it: mute while mute is false instead. Handy when what you have is an "enabled" flag.

They start as checkboxes, and you'll usually convert mute to an input and wire it: a primitive, a Value Presets field (through Unbundle or a Get), a boolean invert node, or a node that declares its own output as known-before-the-run - the companion timeline pack's upscale toggle does that.

That "before the run" part is the whole design constraint: with no outputs there's no execution step in which it could read a value that only exists mid-run. A widget, a primitive, a preset field: fine. Something a loader or a file reader produces: too late, and the group is left on - safer, by the pack's own argument, than wrongly muting something a lazy switch was going to decide. If your group stubbornly refuses to switch off, check this first.

Installing it

cd ComfyUI/custom_nodes
git clone https://github.com/chanon/comfyui-obvpm
# restart ComfyUI, then hard-refresh the browser tab

Or search ComfyUI Manager for obvpm. No Python dependencies - the pack ships an empty dependency list rather than re-pinning what ComfyUI already provides. The hard refresh isn't optional advice here: this node is JavaScript, so a stale cached bundle looks exactly like a node that does nothing. Every name in the pack ends in (obvpm), so obvpm in the node search finds them all.

Where people get burned

Nothing happens at all. Nine times out of ten the node isn't inside a group, or it's in the wrong one - the rule is the group containing its centre, so a node parked on top of a frame border can belong to neither. Drop it squarely inside and the greying is instant.

It works in your test workflow and not in the one you downloaded. Group membership lives on the canvas, not on the node, so pasting Mute Group If elsewhere doesn't bring a frame with it - it sits there doing nothing until you put it in a group.

The group greys out and the run still runs it. Mutating a group that's decided at run time is the documented fallback: when the value can't be read before the prompt is built, the pack leaves the group on. Re-check what mute is wired to.

Something outside the group needs something inside it. A muted node produces nothing, so a consumer outside the frame is left with a dead input and the run fails. Keep shared work - loaders, VAEs, anything a second branch also uses - outside the region you automate.

Frontend risk, stated honestly. Value-driven group muting is a browser-side trick, and the last two years of ComfyUI have been rough on exactly that kind of node: the Nodes 2.0 canvas rewrite broke rgthree's Fast Groups Muter and Bypasser outright, and its author declined to port them. Mute Group If is the same category of thing, and the difference is that this pack is being actively developed against current frontends. If the frame stops greying after a ComfyUI update, suspect the frontend first.