Resolution Scale

What it is

Resolution Scale is a tiny math node with an outsize job: it takes a width and height, multiplies them by a factor, and snaps the result to a multiple you choose. No pixels are touched - this operates on numbers, and it feeds the numbers into other nodes.

Why would a node that just does multiplication exist? Because in ComfyUI the resolution you want to generate at is a value you pass around, and it has constraints. Most image models want dimensions that divide evenly by 8 (latent space is downsampled 8×). Wan video wants 16. And if you've ever typed 832×1216 into an Empty Latent node and gotten a "not divisible by 8" failure, you know the pain this exists to kill. Multiply, snap, and hand the result on.

How it works

The math is exactly what the description says: snap the inputs to the nearest multiple of divisible_by, multiply by factor, snap again, and output. It also reports the actual factor it applied - the average of the width ratio and height ratio after snapping - because rounding means the real scale factor rarely equals the one you typed. That actual factor is genuinely useful when you're driving a denoise or a detailer that needs to know exactly how much you upscaled.

The outputs are width and height as INTs plus factor as a FLOAT, so they drop straight into an Empty Latent, a resolution selector, or a sampler's width/height inputs. Defaults are sensible: width 576, height 1088, factor 1.5, divisible by 8. That 576×1088 default isn't an accident - it's the Wan 1.3B-friendly portrait size, and 1.5× from there lands you in a nicely round 864×1632.

The inputs that matter

• width, height - the starting dimensions.
• factor - the scale multiplier, 0.01 to 16.
• divisible_by - snap the result to this multiple. 8 for most image models; 16 for Wan; 64 if you're feeling strict.

Outputs: width, height, factor (the actual applied factor).

When you'd use it

Whenever a pipeline needs dimensions derived from other dimensions. Upscale-then-detail loops: read the latent's resolution, multiply by 1.5, and feed the snapped result into the hi-res pass. Video work: take your base resolution and scale it up to a target that still respects Wan's divisibility rules. Resolution presets: define one source size and derive every other size in the workflow from it, so changing one number updates the whole graph.

Installing it

Ships with ComfyUI_Eclipse:

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

then restart, or use Manager and search "Eclipse". Old-workflow note, same as every node in this pack: it was formerly RvTools_v2, and v4.0.0 removed legacy nodes - the bundled migration tool handles old graphs.

Common issues

The one trap is forgetting the divisibility requirement on the far side of the multiply. Snapping happens, but if you feed the result into a node that needs a different divisor than the one you chose, you'll get the error you were trying to avoid - match divisible_by to whatever consumes the output. And remember the factor output is the post-snap actual factor, not your input; use it, don't assume.