ListConcat (Yogurt Nodes)

In a batch workflow, lists accumulate: prompts from one source, strengths from another, seeds from a third. Eventually you just need them all in one list - in order, duplicates and all - so a single loop can walk through everything. ListConcat is that merge. Two required inputs, up to thirty more optional ones, one combined list out.

It's a logic node in the YogurtNodes pack (yogurt7771/ComfyUI-YogurtNodes), and it's the "obviously I need this" node of the list family. Where ListBinaryOps gives you set math and dedupe, ListConcat is the plain, literal concatenation - [1,2] + [3,4] → [1,2,3,4], no dedupe, no sorting, nothing clever.

How it works

It takes list1 and list2 (both required) and extends the result with list3 through list32 as you wire them in. Unused inputs are simply ignored, so you can start with two lists and add more later without restructuring your graph - just draw a wire and the node grows. The output result is a flat list preserving order: everything from list1 first, then list2, and so on.

The inputs are any-type, so you can concatenate lists of strings, numbers, images - anything list-shaped. It's the classic glue for batch loops: merge all your per-item values into parallel lists, then iterate with an index node, or feed the combined list into a node that takes a LIST wholesale.

Inputs that matter

• list1, list2 - required. Everything else is gravy.
• list3–list32 - optional, wire as needed.

Output: result.

Install

Pack-wide routine - ComfyUI Manager (search "YogurtNodes") or:

cd ComfyUI/custom_nodes
git clone https://github.com/yogurt7771/ComfyUI-YogurtNodes.git
cd ComfyUI-YogurtNodes
pip install -r requirements.txt

Restart, find it under Yogurt Nodes / Logic. No extra dependencies.

Troubleshooting

• "My lists are eating each other." That's not this node - concatenation appends. If you're getting dedupe or override behavior, you grabbed ListBinaryOps union or JsonMerge instead. Concatenation keeps duplicates; if you don't want them, chain a ListUnique-style node after.
• "I have more than 32 lists." Thirty-two inputs is a lot, but batch workflows can get wild. If you're past that, concatenate in stages - two ListConcat nodes feeding a third.
• Ordering surprises. The result order is strictly input order: list1's items all come before list2's. If you expected interleaving (a1, b1, a2, b2), that's ListBinaryOps interleave, not concatenation.
• Any-type means the types are on you. Concatenating a list of strings with a list of numbers gives you a mixed list, which is fine until a downstream node expects uniform types. Keep lists homogeneous unless you know why you're mixing.

The pattern that makes this earn its keep: three parallel lists - prompts, denoise values, seeds - concatenated into three aligned lists, then zipped or indexed together per batch item. It's boring, it's bulletproof, and it's the difference between wiring five sources by hand and letting the graph do it.