For Loop Open

Core ComfyUI is a DAG - data flows one way, no node ever runs twice. That's great for diffusion pipelines and a wall the moment you want to do something n times: process every file in a folder, run a denoise pass ten times carrying state between runs, or step a value through a sequence. WAS For Loop Open is half of the pack's answer - the "repeat this part of the graph" node. Pair it with For Loop Close and the slice of graph between them runs again and again, with values carried forward each iteration.

Its natural partner in crime is WAS Directory Listing: list a folder, wire the paths into this loop's body, and you've just turned "I will type these twenty filenames by hand" into "loop over the directory."

How it works - the mode and the counter

A loop needs to know when to stop, and this node gives you two ways to decide:

• mode: iterations - runs a fixed count, set with iterations (1 to 10000). The simple, predictable mode.
• mode: total_frames - runs until For Loop Close has collected total_frames frames. This is the video/animation mode: you don't count loop passes, you count output frames, and the loop keeps going until that pile reaches the target. Two guards keep it sane - max_iterations is a safety limit that stops the loop even if the frame target is never reached, and total_frames mode needs accumulate switched on at the Close end for frames to be collected at all.

Whatever the mode, start sets the first value of index, the loop's counter. Index starts there and counts up by one each iteration - wire it into a Text List Get and you've got "give me entry 0, then entry 1, then entry 2…".

The value slots - how state survives the trip

This is the part that confuses people coming from a normal programming language, because a graph has no variables. The answer is the value slots: value_1 through value_8 on the Open node, mirrored on the Close node. A slot starts with whatever you hand it; inside the loop you read it out, transform it, hand the result to For Loop Close's matching slot; and next iteration For Loop Open's value_1 holds what Close received. That's the loop's state, flowing around the circle. A new slot appears as you wire one, and you can carry anything - images, latents, numbers, text.

The output worth naming: iterator, a WAS_LOOP value that identifies the loop and where it's up to. Wire it straight to For Loop Close's iterator input and nothing else - that connection is what tells Close which Open it belongs to, and it's the one wire you must not improvise with.

Installing it

WAS Node Suite v3: ComfyUI Manager → search WAS Node Suite v3, or clone into custom_nodes, restart. No models, no dependencies.

Two failure modes worth knowing before you queue something ambitious. In total_frames mode, forget to enable accumulate on the Close node and frames are never collected - the loop relies on max_iterations to save you. And remember only nodes wired back to Close re-run each iteration; anything hanging off the Open node outside that loop runs once, which is how you accidentally compute something once and assume it ran n times. Wire the loop body deliberately, and the Open node's index output is your best friend for debugging what iteration you're on.