Bubba Pipe In

Bubba Pipe In is the entry point to the pipe system that the whole Bubba Nodes pack is built around. In plain terms: it takes the ten or twelve sockets that normally sprawl across your whole graph - model, clip, vae, latents, prompts, conditioning - and bundles them into one object that travels down a single wire. If your workflows are starting to look like spaghetti, this is the fork that gets you out of it.

The pipe idea isn't unique to Bubba. rgthree's Context, Efficiency Nodes' dependencies tuple, Easy-Use's pipe dict - every one of those packs independently invented the same trick, because bundling a dozen values into one object is the single biggest readability win ComfyUI has (the modidex KB's node-plumbing essay calls it the "context object" and it's the right mental model). Bubba's version is a typed BUBBA_PIPE, which is important: unlike an "any" socket that will happily accept whatever you plug in, this is a real type, so the type-checker and you both know what's inside.

How it works

Every input on this node is optional. You hand it a partial pipe, or nothing at all, and it assembles a BUBBA_PIPE containing whatever you connected - model, clip, vae, positive and negative conditioning, image, mask, latent, metadata, plus the positive and negative prompt text. Feed it an existing pipe through the pipe input (the tooltip says "Optional incoming pipe to update") and it merges your new values into that instead of starting fresh. That update-in-place behavior is the real workhorse: you can build a pipe once, then use later Pipe In nodes to drop in a LoRA'd model or a new latent without re-running the whole chain.

It only outputs one thing: pipe. Everything else that could have been its own socket is now inside.

The inputs that actually matter

For a beginner the honest list is short:

• model, clip, vae - the three big ones from your checkpoint loader. Connect these and you've got the backbone of a pipe.
• positive and negative - the conditioning from your CLIP text encode (or from Bubba's own prompt builder nodes, which encode for you).
• positive_prompt / negative_prompt - plain text that rides along for metadata and for nodes like Bubba Save Image to embed.
• pipe - the optional incoming pipe you're updating. Leave it empty to mint a new one.

Everything else (mask, latent, metadata, image) you only wire when a stage of your workflow produces it.

How to install it

Bubba Pipe In ships with the Bubba_Nodes pack, so install the pack once and you get all 37 nodes. Easiest path is ComfyUI Manager - search "Bubba Nodes", install, restart. Manual is just as simple:

cd ComfyUI/custom_nodes
git clone https://github.com/bubbafett5611/bubba_nodes.git

then restart ComfyUI. Dependencies are light (aiohttp and pydantic, both already in most ComfyUI installs) but if the console complains, run python -m pip install -r requirements.txt in your ComfyUI Python environment. Note it targets ComfyUI v0.27.0+ and registers through the newer V3 comfy_api.latest API, so if you're running a very old ComfyUI, update that first.

Where people get tripped up

The classic pipe failure is stale context: unpacking a value from a pipe that was assembled before a downstream node changed it. With forty wires you can see the LoRA output isn't connected to the sampler; with one pipe wire the connection looks fine and the contents are wrong. The fix is discipline - when you're actively iterating on one value, keep it on an explicit wire instead of burying it. And no, your pipe won't survive a ComfyUI restart between sessions; it's a runtime object, not a saved state. Save with Bubba Save Image and reload with Bubba Load Image (With Metadata) if you want persistence.

One more note: this pack is new enough that there isn't a wall of tutorials about it yet. The README is genuinely good and the workflow example in it shows Pipe In → prompt builder → sampler → save in about eight nodes. That's the demo that makes the pipe system click.