easy outputToList

ComfyUI has two ways of moving multiple things down one wire, and they are not the same thing: a batch (several items packed into one tensor, processed together) and a list (several items the graph iterates over one at a time). Plenty of nodes only accept one form, and the mismatch is a classic head-scratcher - you've got several outputs but the next node treats them as one blob, or vice versa. easy outputToList converts to the list form, so downstream nodes iterate over the items individually.

It's pure plumbing, the kind of node that has no visible effect on your images but quietly unblocks a workflow that otherwise refuses to wire up. If you're building loops or fan-out logic, this is one of the adapters you keep in your back pocket.

How it works

The node takes an input (tuple) - a wildcard type, so it works on whatever you're passing - and re-emits it as a list output flagged as a genuine list. That flag is the whole point: ComfyUI's execution engine treats list-flagged outputs specially, running downstream nodes once per element instead of once for the whole thing. So a value that was arriving as a single grouped item now arrives as N separate iterations.

The input and output

• tuple - the value to convert. Wildcard, so images, latents, strings, numbers, anything.
• Output: list - the same contents, now presented as a list the graph iterates over.

That's the entire surface. There's nothing to configure, which is appropriate for an adapter.

How to install it

Via ComfyUI Manager: search "ComfyUI Easy Use", install, restart. Or:

cd ComfyUI/custom_nodes
git clone https://github.com/yolain/ComfyUI-Easy-Use

Then install.bat / pip install -r requirements.txt, restart. Preinstalled on comfy.icu.

Common issues

The whole difficulty with this node is knowing when you need it, because the symptom is confusing. Batch-versus-list problems usually show up as a type error when you connect two nodes, or as a node processing your items all at once when you wanted them handled separately (or the reverse). If a downstream node is choking on a multi-item input, or only acting on the first item, a batch/list mismatch is a prime suspect and this node is one of the fixes.

Be careful, though: list mode changes execution semantics. Once something is a list, the nodes after it run once per element, which can multiply your run count and your GPU time if you're not expecting it. That's exactly what you want for a deliberate loop and exactly what you don't want if you accidentally list-ified something that a batch node would have handled in a single efficient pass. Convert on purpose, at the point where you actually want per-item iteration - not preemptively. And note the pack also ships list/batch converters in the other direction; reach for the one that matches which form your next node demands.