Resolution Divider

The Resolution Divider is the answer to a very specific, very annoying problem: you've got a 1920x1080 source image, you want to feed it into a Wan 2.2 image-to-video workflow, and you know that running it at full res is going to OOM your GPU before the first frame. So you need to downscale - but you need to keep the exact aspect ratio, and you'd rather not punch 1920/1.5 into a calculator for the tenth time today. That's this node. It's a pure utility, a calculator that lives on your canvas, and it does exactly one thing: take a resolution, divide it by a number, and show you the result.

What it actually is

It's a single-node pack from CraftBlack, aimed squarely at Wan 2.2 I2V users. Wan is the open video base everyone's building on these days (the 14B I2V model is a heavy beast), and the 27B MoE in 2.2 is even hungrier - high-res input images are one of the fastest ways to run out of VRAM. The README's whole pitch is finding the "sweet spot" like 480p or 720p without manual math.

Here's the thing that makes it different from a Scale node: it divides instead of multiplying. Scale nodes upscale; this downscales by a fixed factor, which preserves the aspect ratio perfectly because both dimensions get divided by the same number. No squashing, no stretching, no cropping decisions.

The nicest detail is that it's a "visual" node. It has no output sockets at all - it's marked as an output node so ComfyUI runs it anyway, and the result just displays on the node itself. You don't wire anything from it into your graph; it's a companion you park next to your image loader to read a number off. That means you never accidentally add it into your latent pipeline and break something.

How it works

Under the hood it's a tiny bit of Python plus a little JavaScript. The Python side (res_node.py) takes your resolution string, replaces any x, X, *, or comma with a space, grabs the first two integers, and computes int(width / divider) × int(height / divider).

The clever part is the JS (js/realtime_calc.js). It injects a "Live Result" display straight into the node widget list and recalculates it as you drag the divider slider - no need to hit Queue Prompt. The moment you release the slider, the number updates. That's the feature that makes it worth installing over just doing the division yourself: instant feedback while you hunt for the resolution that fits your card.

It also reads the image dropdown live - pick a file (or upload one) and it fetches the image through ComfyUI's /view endpoint, reads the real pixel dimensions, and auto-fills the resolution string for you. No more typing 1920x1080 by hand.

The inputs that matter

There are only three, and two of them do the work:

• res_string - type the resolution. 1920x1080, 1920 x 1080, 1920, 1080, even 1920 1080 all parse fine.
• divider - the float you divide by. Defaults to 1.5, which the README recommends for Wan 2.2; 1.0 is original size, 2.0 is half. It goes from 0.1 to 10, so you can also do light downscales or go tiny.
• image - a dropdown of your ComfyUI/input folder. Picking one auto-fills the resolution. This is also where you upload a fresh image without touching your file browser.

That's the whole thing. No hidden outputs, no optional inputs.

Installing it

Easiest install in the world, because there are no dependencies to fight with. Grab it via ComfyUI Manager (search "ComfyUI-Resolution-Divider") or clone it manually:

cd ComfyUI/custom_nodes
git clone https://github.com/CraftBlack/ComfyUI-Resolution-Divider.git

Then restart ComfyUI. There's no requirements.txt, no model downloads, no Python packages - the pack uses only re, os, and ComfyUI's own folder_paths. You'll find it under right-click → Resolution Divider in the "Resolution Utils" category.

Things worth knowing

• It doesn't snap to model-friendly multiples. 1280x720 ÷ 1.5 = 853x480 - the README calls that a "safe zone," but note it's not a standard video size, and if your model's VAE wants dimensions divisible by 8 or 16 you'll still round manually. The node preserves the ratio, which is its job; snapping is yours.
• The image input is cosmetic. The dropdown feeds the display; the actual graph never uses the image pixels for anything.
• Don't expect fanfare. This is a zero-impression niche utility with no community footprint yet. That's not a red flag - it's a tiny MIT-licensed calculator - but treat it as a convenience, not a workflow savior. The heavy lifting (running Wan at all on your GPU) still comes from picking the right quantized checkpoint and VRAM settings.