from Dynamic Pipe

to Dynamic Pipe packs your values into one wire; this node is the other half of the trick. from Dynamic Pipe takes that single dynamic_pipe connection and unfolds it back into named, typed outputs on the canvas - same names, same types, same order as the inputs on the pack node. Drop one at the end of a messy region and the rest of the workflow plugs into it like nothing happened.

How it works

It's a reassuringly thin node under the hood. The dynamic_pipe input (type DYNAMIC_PIPE) is the only thing you wire. The other input, _schema, is a hidden socketless string widget that mirrors the bundle's description - it defaults to [] and you never set it by hand. When the workflow runs, the node checks two things before doing anything: that what arrived really is a dynamic pipe (a dict carrying the pack's marker and a values map), and that every field its schema expects is actually present in that map. Only then does it hand the values back, in schema order.

The outputs you see on the node are generated live by the frontend as you work - one per packed value, with their original types restored. A MODEL you stuffed in upstream comes out as a MODEL socket, not a vague *. That's the whole design: you only ever deal with the generic pipe inside the pair, and real typed sockets everywhere else.

The inputs that matter

• dynamic_pipe - the one real input. Feed it the output of to Dynamic Pipe.
• _schema - hidden bookkeeping; ignore it.

The outputs are the list you never typed: every value you packed upstream appears here as its own named output. Wire these into samplers, VAEs, anything downstream, and the graph reads as if the values were local.

One behavior here is genuinely thoughtful. Disconnect dynamic_pipe from this node and it keeps its last layout and downstream connections, so you can reorganize without the graph falling apart. Reconnect it to a different to Dynamic Pipe, and it only removes downstream links whose name or type changed - the author's way of stopping values from silently routing to the wrong place.

Where it bites

• "Dynamic Pipe Unpack received an invalid pipe" - what you connected isn't a real pipe from the pack. Usually the wrong output, or a node whose output merely looks similar.
• "Dynamic Pipe schema does not match the connected pipe: ..." - the layout it remembers (its _schema) doesn't match what the to node is now sending. This is the stale-layout trap: you rewired the to node, and this one is still expecting the old bundle. Reconnect and let the schemas resync.
• Lock-in and legibility. The DYNAMIC_PIPE type is private to this pack, so no other pack's nodes can read it - you've committed to this pair. And like every bundling node, one wire hides what's inside. The knowledge base frames this as the mirror image of the spaghetti it cures: with forty wires you can see a wrong connection, with one pipe you can't, because the connection is present and the contents are off.

Installing

Same as its sibling - ComfyUI Manager, search "ComfyUI-DynamicPipe", or:

cd ComfyUI/custom_nodes
git clone https://github.com/palealloy2999-prog/ComfyUI-DynamicPipe.git

Then restart ComfyUI and reload the browser. No dependencies, no model downloads.

It's a young pack from a new author (v2.1.0 within days of release, zero stars), so treat it as a tidy convenience rather than infrastructure. But the unpack node itself is exactly what you want at the end of a long bundled stretch: one wire in, your real typed values out, no naming ceremony required.