Runtime44 Iterative Upscale Factor

Runtime44 Iterative Upscale Factor is a tiny math node with a precise job: it tells you how much to upscale at each step of a multi-pass upscaling chain, so a huge total upscale gets broken into a sequence of capped, sane-sized passes. It outputs a single FLOAT (factor) - you wire that into the upscale_by input of the pack's Runtime44 Upscaler (or any upscaler that takes a factor) at each stage.

Why does this exist? Because one giant upscale pass is how you get mush. The established playbook - the same one Impact Pack's iterative upscaling formalized - is to upscale in modest steps (1.5x–2x at a time), giving each pass a chance to keep detail coherent before the next one piles on. This node automates the arithmetic for that chain.

The formula, made human

Given a total upscale_by, a per-pass cap max, and a position index in the chain, the node returns:

min(upscale_by / (max ^ index), max)

And if index > 0 and the result would drop to 1 or below, it returns 0.0 - which you read as "this chain is done, stop."

Worked example with upscale_by = 8 and max = 2:

• index 0 → 2 (first pass: 2x)
• index 1 → 2 (second pass: 2x)
• index 2 → 2 (third pass: 2x)
• index 3 → 0 (fourth: 8 ÷ 8 = 1, chain finished)

Three 2x passes instead of one 8x jump. The max cap is what keeps any single stage from exploding the resolution (and the VRAM bill) at once.

The inputs

• upscale_by - the total multiplier you want to reach across the whole chain (default 2).
• max - the largest factor any single pass may use (default 2). The per-pass cap.
• index - which stage of the chain this node is computing for, starting at 0 (default 0).

Output: factor (FLOAT). Index 0 is the first pass - the easy trap is wiring your first upscaler to index 1 and wondering why the chain starts mid-way.

How to wire the chain

Two ways people actually do this:

• Manual stages - drop N copies of the node, set index 0, 1, 2…, and feed each factor into a corresponding Runtime44 Upscaler (or hi-res fix KSampler chain) whose upscale_by is set by that factor. Ugly but simple and inspectable.
• A loop - if you're running Impact Pack's loop or rgthree's, put one copy inside the loop, feed the loop's index in, and read the factor each iteration. The 0.0 terminator is your loop exit signal.

Either way it pairs naturally with the pack's Upscaler node, whose upscale_by is exactly the input this node was written to feed. It's a supporting actor, but in an iterative upscale workflow it's the piece that stops you from wrecking a render with one overeager multiplier.

Installing

Part of Runtime44 ComfyUI Nodes, under "image/upscaling":

cd ComfyUI/custom_nodes
git clone https://github.com/runtime44/comfyui_r44_nodes
cd comfyui_r44_nodes
python -m pip install -r requirements.txt   # or: uv pip install -r requirements.txt

Restart ComfyUI, or install via ComfyUI Manager (search "Runtime44"). It's pure arithmetic - no dependencies beyond Python itself, so none of the pack's heavy wheels matter for this node. And it was the last node added to the pack (v1.1.0, May 2024), right before the project went quiet.