🔄 Image List

Small plumbing node with one job: take up to ten separate images and combine them into a single image list, so downstream nodes process them one after another. If you've ever wanted to run the same upscale, the same style transfer, or the same save routine across a handful of images without duplicating your whole graph ten times, this is how you feed them in as a batch.

Lists vs batches, the thing that trips everyone

Worth getting straight up front, because ComfyUI has two ways to carry multiple images and they behave differently. A batch is a stack of images glued into one tensor - nodes see it as a single item with N frames, and every image has to be the same size. A list is N genuinely separate items, and the graph re-runs each downstream node once per item. This node makes a list (its output is flagged as a list), which means the images can be different sizes and each one flows through the rest of the workflow independently. That's exactly what you want when the images don't share dimensions or you want per-image processing.

The inputs and outputs that matter

• image1 through image10 - ten optional image inputs. Connect as many as you have; leave the rest empty. Each one becomes an entry in the output list, in order.

The single output is image, a list of every image you connected. Wire it into whatever you want applied to all of them - an upscaler, a save node, a preview - and ComfyUI will iterate through the list, running that branch once per image.

Installing it

ComfyUI Manager: search SDVN_Comfy_node, install, restart. Or by hand:

cd ComfyUI/custom_nodes
git clone https://github.com/StableDiffusionVN/SDVN_Comfy_node

Then pip install -r custom_nodes/SDVN_Comfy_node/requirements.txt from your ComfyUI root, and restart. This node is pure graph plumbing - no models, nothing to download, and aria2c doesn't matter for it.

Where people get burned

Expecting a batch and getting a list (or vice versa). Some downstream nodes want a batched tensor, not a list. If you feed this list into a node that assumes a single batched input, you may get it processed one-at-a-time when you wanted them stacked, or an error. When you specifically need a batch, look for a "make image batch" node instead; use this one when you want independent, possibly differently-sized items.

List execution multiplies runtime. Because a list re-runs the downstream branch per image, a ten-image list means ten passes of everything after it. That's the intended behavior, but don't be surprised when a heavy branch takes ten times as long - that's the cost of processing each image separately.

Ordering. The list keeps the order of the input slots (image1 first, image2 second, and so on), so wire them in the order you want them handled.