CCP6/fluxsr-comfyui-nodes

ComfyUI-FluxSR (v1.1.1)

Native ComfyUI nodes for FluxSR - one-step x4 real-world image super-resolution (Li et al., One Diffusion Step to Real-World Super-Resolution via Flow Trajectory Distillation, ICML 2025, arXiv:2502.01993). Weights: https://huggingface.co/mon3tr/FluxSR-private

No diffusers / peft needed. It runs on your normal ComfyUI FLUX.1-dev UNET + VAE; FluxSR is just a rank-64 LoRA plus two fixed text-embedding files.

Install

1. Copy ComfyUI-FluxSR into ComfyUI/custom_nodes/ and restart.
2. Download the package: hf download mon3tr/FluxSR-private --local-dir fluxsr
3. Put the files here:
   • pytorch_lora_weights.safetensors -> ComfyUI/models/loras/fluxsr_lora.safetensors (any name)
   • t5_embedding.pth and clip_embedding.pth -> ComfyUI/models/fluxsr/
4. You also need the usual flux1-dev.safetensors (models/diffusion_models or models/unet) and ae.safetensors (models/vae). fp8 Flux works too but the paper used bf16.

Workflow (example in workflows/fluxsr_example.json)

UNETLoader (flux1-dev) -> LoraLoaderModelOnly (fluxsr lora, 1.0) ---> MODEL
VAELoader (ae)                                                    ---> VAE
LoadImage                                                         ---> IMAGE
FluxSR Load Conditioning (t5 / clip .pth)                         ---> FLUXSR_COND
                                   all four -> FluxSR Upscale (x4, one step) -> SaveImage

Defaults match the paper: timestep 350, guidance 4.0, seed 114, whole image in one call.

Video (example in workflows/fluxsr_video_example.json)

Load Video -> Get Video Components -> frames -> FluxSR Video (frame by frame) -> Create Video (fps + audio
from Get Video Components) -> Save Video

(VHS Load Video / Video Combine work the same way.)

FluxSR Video runs the one-step model on every frame. deterministic_encode is on by default: the VAE encodes with its mean instead of a random sample, so nothing random changes between frames - still parts of the picture stay still. Use max_frames / start_frame to test a few seconds of a long clip first. Frames are held in RAM as 16-bit until the end (about 20 MB per 1792x1792 frame), so a 10 s 30 fps clip at that size needs ~6 GB of RAM; drop output_scale to 2 for long clips.

Controls

• deterministic_encode - encode with the VAE mean instead of a random sample. Same input always gives the same output. Off on the image node (paper behaviour), on for video.

• output_scale - the model always works at x4. 2.0 shrinks the input by half first (net 2x); 1.0 gives a same-size clean-up (pure restoration).

• tile_size - 0 = whole image in one transformer call (paper behaviour). For big inputs set e.g. 128 (= 1024 px output tiles) with overlap 16; tiles are feather-blended. Remember the output is 4x: a 1024 px input makes a 4096 px image = 512x512 latent, which is a lot of tokens for one Flux call, so tile or shrink there.

• vae_tiling - tiled VAE encode/decode, lower VRAM.

• grid_shift_passes - Flux works on a 16 px token grid, and one-step output can show it as a faint 16 px checker in dark flat areas (the paper's ADL loss reduces it, not removes it). Passes above 1 re-run the frame shifted by half a token and average the results, which cancels the grid. Default 2 (two model calls per frame); 1 = the paper's single pass.

• seed only changes the VAE encode sampling; results are nearly deterministic.

What it is for

Real-world super-resolution / restoration of degraded photos: blur, noise, JPEG blocking, downscaling - the Real-ESRGAN style degradation set. It is generative: it invents plausible texture (skin, hair, foliage, text edges), so it is for making things look good, not for forensic recovery. One step, so it is fast for a Flux-sized model.

License

Node code: MIT. The LoRA and embeddings are FLUX.1-dev Non-Commercial License (BFL); the FluxSR code is Apache-2.0. See the NOTICE in the weights package.