ASASR Upscale (4x)

"Upscale" is three different jobs wearing one word, and ASASR Upscale (4x) is squarely job two: more detail, not more pixels. It looks at a small image and paints in plausible fine texture - window frames, lettering, fabric weave - that was never in the file. If your source is already sharp and you just need it bigger, use Lanczos or a 4x ESRGAN model and save yourself 25 GB of VRAM.

The backbone is what makes it interesting. ASASR (weights from wafer-bob / Kuaishou, not this pack's author) is a FLUX.1-dev super-resolution model with a dual-LoRA design and OminiControl-style conditioning - a reference image pushed through attention instead of text. Here that reference is your low-res tile, bicubic-blown to 512px.

Where it sits: on the generative rung, SeedVR2 has been the incumbent since late 2025 - Apache 2.0, on a 6 GB card. ASASR wants 25 GB and its weights are non-commercial, so reach for it only if you want a FLUX-rendered 4x or already keep FLUX.1-dev resident. As of mid-2026 it has essentially no community discussion behind it - no crowd-sourced "settings that work." Trust the defaults.

How it works

Your input is padded, then cut into overlapping tile_size squares on the low-res side. Each tile is bicubic-upscaled to 512×512 as the conditioning image, denoised for steps passes with FLUX plus the two ASASR LoRAs (SR and DPO-tuned, ~885 MB and ~111 MB, auto-downloaded on first run), rendered at 4x, then feather-blended back over the overlap. A final color-fix pass - AdaIN or wavelet, borrowed from StableSR - pulls the merged result's color statistics back toward a bicubic reference of your original.

The model was trained on 128px → 512px tiles, so tile_size = 128 is its native, most faithful point. Generation always runs at 512px per tile, so going above 128 just bicubic-resizes the render: fewer tiles, faster, no extra generated detail.

The inputs that matter

Plug in model, clip, vae and image from standard loaders. One output: image, the 4x batch, ready for SaveImage or another upscaler.

• model must be a FLUX.1-dev UNet from UNETLoader, or any loader producing a FLUX model patcher. The node checks, and refuses anything else.
• clip only encodes the empty prompt. ASASR conditions on pixels, not text - don't bother writing one.
• steps (28) and guidance (3.5) are FLUX-dev defaults. Leave them. seed (0) is a base seed with per-tile offsets, so a given run is reproducible - change it if you want a different set of invented details.
• tile_size (128): leave it. tile_overlap (16): push toward 32 if you see seams.
• color_fix (adain, wavelet, none): use none if you're grading downstream.
• sr_lora_scale and dpo_lora_scale (both 1.0): leave them. condition_scale (1.0): leave that too - anything else allocates a dense attention bias, which is memory-expensive.
• auto_download (true): set to false on an offline machine, once the LoRAs are in place.

And do not load those ASASR LoRAs with LoraLoaderModelOnly. They're applied internally, gated to the condition branch, and a regular LoRA loader has no notion of branches - it would smear the deltas across the main FLUX branch, which isn't the regime the model was trained under. The auto-download drops them in models/loras/ASASR/, which is what makes the mistake tempting.

Installing it

ComfyUI Manager: search ASASR. If you use comfy-cli instead: comfy node install comfyui-asasr.

Manual:

cd ComfyUI/custom_nodes
git clone https://github.com/claussteinmassl/ComfyUI-ASASR.git
cd ComfyUI-ASASR
pip install -r requirements.txt   # huggingface_hub, and that's the whole file

Restart ComfyUI after. That pip step really is the whole install - the pack's only runtime dependency is huggingface_hub; all the weight is in model files you supply.

FLUX.1-dev is gated on Hugging Face: accept the license, then put flux1-dev.safetensors in models/diffusion_models/, ae.safetensors in models/vae/, and clip_l plus a T5-XXL file in models/text_encoders/ (DualCLIPLoader, type flux). An example workflow ships in example_workflows/.

For lower VRAM, set UNETLoader's weight_dtype to fp8_e4m3fn, or use ComfyUI-GGUF's UnetLoaderGGUF with a Q8 checkpoint. The author measures ~35 GB peak for bf16, ~25 GB for fp8 and Q8, and fp8 saves memory rather than time - weights are cast per layer during the forward, so it's slower than bf16. Per-tile cost runs 5.5–8.5 s and scales with tile count: a 512×512 input is 16+ tiles before overlap padding.

Where this bites you

• "ASASR requires a FLUX.1-dev model" / "FLUX.1-schnell is not supported." You fed it a non-FLUX transformer, or a FLUX without the guidance embedding. Schnell and Schnell-derived models trip the second check.
• Portraits of people you know. This is generative: thin wires, exact lettering and face geometry get reinvented, and the README says so outright. Give faces their own pass.
• Commercial work. The node code is MIT, but the ASASR weights are CC-BY-NC-4.0 and inherit FLUX.1-dev's non-commercial terms. The combination is non-commercial, full stop.
• Advanced graph tricks. The forward pass calls Comfy's Flux blocks directly rather than routing through transformer_options, so attention patches and ControlNet don't apply, and it keeps a ~2.1 GB fp32 LoRA delta store on the compute device alongside the FLUX model.

It's a carefully tested port of a real research model - the author ships parity tests against upstream diffusers. Just know it's a lab instrument, not a one-click upscaler.