Friendly Pipe Out

Friendly Pipe Out is the mirror half of the pack. Friendly Pipe In squeezes a bundle of connections into one pipe wire; this node takes that wire back out into individual, normal-looking slots you can feed straight into Show Text, Preview Image, a KSampler, wherever. If the In node is the suitcase, this is the part where you actually unpack it.

The genuinely nice bit is the auto-sync. Wire a pipe in and the node doesn't just dump a generic "here are 80 slots" wall on you - its frontend looks at the source Friendly Pipe In or Edit node it's connected to and shows exactly the slots that exist, with the same labels you gave them. Add a slot upstream and the Out node updates to match. That's the whole "friendly" in the name, and it's the reason this beats manually re-typing a bundle of connections every time.

How it works

The pipe that arrives is a plain dictionary: {"slots": {1: <data>, 2: <data>, ...}, "names": {...}, "slot_count": N}. The Python unpacks it by returning one output per slot, using the wildcard type * so each output can carry whatever type was bundled - image, string, model, conditioning, all on the same node. Empty or missing slots come back as None rather than erroring, which is forgiving but worth knowing about (see below).

The JavaScript does the visible work. It declares 80 possible outputs but hides the ones that aren't in use, mirrors the labels from the source node, and listens for changes so a reconfigured In node updates this one live. It even tracks the original types for visual feedback, so you can see what each output holds.

Inputs and outputs

• pipe (input, required, type FRIENDLY_PIPE) - connect a Friendly Pipe In or Friendly Pipe Edit output here. That's the only input, and there's nothing to configure on this node.
• slot_1 through slot_80 (outputs, type *) - the unpacked values, in the order they went in, wearing the labels the In node gave them.

The one input is worth saying plainly: you don't add slots on this node. There's no ➕ button. It mirrors its source - which is convenient right up until you expect to configure it and find there's nothing to configure. If you need more outputs, add a slot on the In side.

How to install

Same pack as the other two nodes - installing Friendly Pipe In (or anything in logicalor/comfyui_friendly_pipe) brings this one along. No dependencies, no requirements.txt, no model downloads; pure Python plus one JS file.

ComfyUI Manager: Manager → Install Custom Nodes → search "Friendly Pipe" → Install → restart.

Manual:

cd ComfyUI/custom_nodes
git clone https://github.com/logicalor/comfyui_friendly_pipe.git

Restart ComfyUI and look under utils/pipe in the node menu.

Where people get burned

There's no real community lore on this pack yet - it's new, one maintainer, essentially zero footprint. So the gotchas are structural:

• Unconnected slots become None, and None travels. If a slot was empty at the In node, or you removed a wire, the matching output here returns None and whatever you wired it into may fail at execution. The node doesn't hide missing slots for you beyond what it can see - keep the source wired before you blame this one.
• The labels you see come from upstream. Rename a slot on the In node and this one follows; but if you bypass the In and hand it a pipe built some other way, the display can be generic. Labels aren't magic - they're just metadata carried in the pipe dictionary.
• The wildcard outputs won't police your types. Just like the In node, * means "matches anything," so ComfyUI won't stop you connecting an image slot into a text input. The error surfaces at runtime instead of at connect time. Trace the wire if something's weird.
• Missing-node errors on shared workflows. The FRIENDLY_PIPE type and the custom frontend mean anyone opening your saved workflow needs the pack installed.

It's a small, quiet node that does one job well: take one bundled wire and turn it back into something you can actually read. For a beginner it's a godsend on any workflow dense enough to need a pipe in the first place.