FreeScale

You've got a good native-resolution render and you want it bigger - without the whole hi-res-fix ritual of generating once, upscaling pixels, then re-diffusing a second pass at low denoise. FreeScale is the one-node version of that: feed it the base latent and it runs a self-cascade upscale, handing back a larger latent ready to decode. It's tuning-free, so there's no training, no LoRA, no new checkpoint - just a model patch and some patience.

Before you use it, get the upscaling categories straight, because this node lives in the second one. Plain pixel upscalers (ESRGAN, Lanczos) add no content and can't invent anything. FreeScale is a generative upscale: it re-runs the diffusion model at each step up and invents coherent detail that was never in the base. That means it rewrites fine structure - a face you recognise can drift, which is true of every generative rung and not a settings problem. If you only need the same image larger, use an ESRGAN model instead; FreeScale is for when you want the upscale to look like a new, higher-resolution generation.

How it works

The mechanism, straight from the source, is three inference-time operations bolted onto the model's self-attention:

1. Self-cascade upscaling - decode → bicubic upscale → re-encode → add noise → denoise, repeated per cascade level.
2. Frequency-aware scale fusion - recombines global high-frequency and local low-frequency content instead of just blurring-and-predicting.
3. Detail-controlled latent blending with a cosine decay schedule that decides how much of the model's invented detail makes it through.

Because it works through scale-fused attention, it runs on any ComfyUI model with self-attention - SDXL, FLUX, Qwen, whatever. Base-resolution inputs pass through untouched, so it's only doing work when you're actually above native.

The inputs that matter

The full schema is bigger than the README's stale table suggests, so trust the node here: it takes model, vae, positive, negative and a base latent_image at native resolution, then these four are the ones you'll touch:

• target_resolution (default 2048) - the target. The tooltip's example says it plainly: "2048 for 2x from 1024."
• cosine_scale (default 2.0) - the detail-control alpha from the paper. Drop it to 1.0 or below at 8K, where aggressive detail turns to mush.
• num_inference_steps (default 50) - denoising steps per resolution level. This multiplies, so a two-level cascade is 100 steps' worth of GPU time. Don't be shy about lowering it.
• noise_timestep (default 700) - the forward-noise timestep K from the paper. Leave it alone unless you know what you're doing.
• fast_mode (on by default) - uses 4-global-window attention: faster, marginally lower quality. Off if you're chasing max sharpness.

The output is a single High-Res Latent; wire it to a VAE decode and Save Image.

Installing it

FreeScale ships inside ComfyUI-DyPE, so you install the pack, not the node:

cd ComfyUI/custom_nodes
git clone https://github.com/wildminder/ComfyUI-DyPE.git

…then restart ComfyUI. ComfyUI Manager works too - search "ComfyUI-DyPE" and hit install. The README promises no extra dependencies and it's telling the truth: the pack's requirements are just torch and numpy, both of which ComfyUI already has. No model files to download.

Honest gotchas

The pack's own README is refreshingly blunt about the limits: at 4K you're pushing a model trained on ~1 megapixel toward 16, and minor artifacts can still appear. FreeScale specifically has a near-zero community footprint on Reddit - the pack's spotlight is DyPE, its sibling node - so treat the default settings as a starting point and A/B the cosine_scale and fast_mode. It's also not a VRAM shortcut: each cascade level runs the full model, so 2K on a 6GB card is still a 6GB-card problem. And one more honest note: num_inference_steps is per-level, and beginners miss that and wonder why a 2-level run takes twice as long as the number on the box suggests.