to Dynamic Pipe

Every ComfyUI workflow that does more than a single straight pass hits the same wall: the model, the clip, the vae, the conditioning, the latent, the seed - a dozen values that every downstream node wants, each dragged across the canvas as its own wire. Ten wires times ten nodes and your graph is noodles. to Dynamic Pipe is the tidy-up. You plug whatever values you like into one side and it hands you a single dynamic_pipe wire carrying all of them.

It belongs to an old and respected family - the "context bus" pattern that Efficiency Nodes, rgthree's Context, and Easy-Use all lean on. Where those fix the bundle to a preset list of fields, this one is genuinely dynamic: nothing is defined until you connect it. Wire in an IMAGE, a STRING, and a MODEL and those three travel the wire. Wire in seven things and seven travel. It's the least opinionated version of the pattern you'll find, and that's exactly why it's worth knowing.

How it works

The magic is split between backend and frontend. On the backend, the node declares a * wildcard input - ComfyUI's "accept anything" type - so there's no type-checking to fight. On the frontend, a small JS file watches the canvas: connect a value to the * socket and a fresh empty * socket appears automatically, ready for the next value. Each input adopts the name of whatever upstream output you plugged in, so you never name anything yourself. And if two values share a name, you get _2, _3 suffixes to keep the keys unique.

Everything you connect gets packed into a dictionary alongside the schema that describes it, and that whole thing emerges from the single dynamic_pipe output. The _schema slot is a hidden, socketless string widget that stores that bookkeeping as JSON - it defaults to [] and you will never touch it. In practice there are exactly two things to know:

• * input - the one you actually use. It accepts anything, and a new one spawns after every connection.
• dynamic_pipe output - the bundle. Feed it to from Dynamic Pipe.

What it wires into

Nothing downstream can read a DYNAMIC_PIPE on its own, and that's the point. You route the wire into from Dynamic Pipe (same pack), which regenerates the named, typed outputs so the rest of your graph keeps using real sockets. The pipe type is private to this pack, which cuts both ways: no other pack's nodes understand it, so a workflow that adopts it is committing to this pair. That's the standard cost of the pattern - the knowledge base calls it lock-in, and core ComfyUI's own answer is the newer Subgraph node for collapsing a region instead.

Installing

Easiest is ComfyUI Manager - search "ComfyUI-DynamicPipe" and install. Or the manual way:

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

Restart ComfyUI and reload the browser tab. That's the whole install: no model downloads, no Python packages - the pack's pyproject.toml explicitly declares zero dependencies.

Where people get burned

• It's a very young pack. At the time of writing the repo is days old, zero stars, and already at v2.1.0 - the author iterates fast. Fine for tinkering; don't anchor a production pipeline on it yet.
• The wire hides what's inside. A * connection erases the type from view, and a pipe is a black box until you open it. This is the same tradeoff that earned "Anything Anywhere"-style nodes their reputation - convenient to build, harder to debug. If you're actively iterating, sometimes forty visible wires beat one tidy one.
• Duplicate names get suffixed. Two upstream outputs both called image come out as image and image_2. Not a bug, just don't assume the second one is whatever you pictured.

It's a small, clean tool from a new author, and for graph hygiene it does one thing well. Bundle when the canvas stops being readable; keep explicit wires where you're still iterating.