Pack SDXL Tuple

SDXL's base-plus-refiner design means eight wires travelling together across your graph: model, CLIP, positive and negative conditioning, once for the base and once for the refiner. Drag those across a big workflow and it turns into spaghetti fast. Pack SDXL Tuple bundles all eight into a single SDXL_TUPLE wire you can route around cleanly, then unpack at the other end. It's pure plumbing, and that's exactly the point - the whole Efficiency Nodes pack exists to cut node count and make workflows readable.

How it works

The node takes the full SDXL base+refiner set as inputs and packs them into one opaque bundle. Nothing is transformed - it's a container. You wire it up once near your loaders, run the single SDXL_TUPLE line wherever it needs to go, and expand it back into eight wires with Unpack SDXL Tuple when you need the individual pieces again (or feed it straight into a node that accepts the tuple, like the pack's SDXL Efficient KSampler).

If you've used rgthree's Context node, it's the same idea applied narrowly to SDXL: carry a bundle of connections down one wire so a workflow that's too large to read becomes one you can still work in.

The inputs and outputs

All eight inputs are required, and they're exactly what you'd expect from an SDXL setup:

• base_model / base_clip and base_positive / base_negative - the base stage.
• refiner_model / refiner_clip and refiner_positive / refiner_negative - the refiner stage.

The single output is SDXL_TUPLE, which goes to Unpack SDXL Tuple or a tuple-aware sampler.

There are no dials to tune here - you're not setting values, just consolidating connections. The only "skill" is remembering which conditioning is which when you pack it, because a swapped positive/negative won't error, it'll just quietly wreck your output.

Installing it

ComfyUI Manager → search Efficiency Nodes for ComfyUI, install, restart. Or clone it:

cd ComfyUI/custom_nodes
git clone https://github.com/jags111/efficiency-nodes-comfyui

Restart ComfyUI. No model files needed for this node - you supply the SDXL checkpoints and CLIP through your loaders as usual.

Common issues

Worth knowing before you lean on the SDXL tuple flow: the community found years ago that a LoRA stack applied through the Efficiency SDXL setup only affects the base model, not the refiner. One user deconstructed the whole thing and confirmed the LoRA never reaches the refiner stage. If your custom LoRA "sort of works but not quite" on an SDXL base+refiner workflow, that's the likely cause - and the fix is to unpack the tuple and inject the LoRA into the refiner branch by hand.

That's also the honest context for the whole base+refiner apparatus: it's the part of SDXL's two-stage design that the community "promptly ignored half of." Plenty of people run the base alone and skip the refiner entirely, which makes this node moot for them. Reach for it when you're genuinely running both stages and the wire clutter is hurting.

And the pack-level failure mode: if Efficiency Nodes shows IMPORT FAILED at startup (a pip freeze non-zero exit is the recurring culprit), this node disappears with the rest of the pack. Update ComfyUI, update the node, verify your Python environment.