CCSR Upscale (TRT)

Let's get the awkward bit out of the way: CCSR is old. It's the 2023 diffusion upscaler that spent 2024 being compared to SUPIR on r/StableDiffusion, and by 2026 it has basically vanished from the conversation - the current defaults for "add detail" are SeedVR2, and for "just make it bigger" it's a plain ESRGAN pass. So why would you reach for a TensorRT build of it in 2026? Because CCSR does one thing those newer tools don't: it adds diffusion-grade detail while staying weirdly faithful to the source. In the portrait shoot-outs from 2024, the consistent read was that CCSR kept facial fidelity where SUPIR happily invented a more attractive stranger. And this node makes that older model actually pleasant to run on an RTX card.

The pack it ships in (ussoewwin/ComfyUI-NunchakuFluxLoraStacker) is a grab-bag - the name is about Nunchaku FLUX LoRA stacking, but CCSR lives in its own category. Don't let that put you off; the CCSR code traces to kijai's ComfyUI-CCSR wrapper of the Apache-2.0 csslc/CCSR, and the interesting part is that the author exported the whole ControlNet+UNet apply-model to a prebuilt TensorRT engine. That's the "TRT" in the name, and it's roughly 1.4x faster than the fp16 PyTorch path it replaced.

Mechanically this is the second half of a two-node pipeline. The Load CCSR Model (TensorRT) node hands you a ccsr_model; you feed that plus your image into this node. It scales your image by scale_by using resize_method, snaps it to a multiple of 64, then runs diffusion per tile. Each 512 px tile (the tile_size, locked to 512 because that's the static shape the engine was built for - not a bug, a constraint) is denoised through a steps-step schedule, with the ControlNet condition fed the low-res input so the result never drifts away from your source structure. CCSR is promptless - no text encoder, no CLIP, empty conditioning at CFG 1.0 - which is exactly why it doesn't rewrite what it sees. Colors get realigned afterwards via color_fix_type (adain by default) because diffusion tends to shift them.

The inputs a beginner actually touches, honestly:

• scale_by - your real multiplier. Default 1; the node also has resize_method for the pixel upscale it does first.
• steps / t_max / t_min - the denoise band. Defaults of 15 / 0.64 / 0.35 are a sane start; fewer steps is faster but mushier, and widening the band toward t_max 0.9 makes it more restorative.
• tile_stride - how much tiles overlap when they're stitched. 256 (half of 512) is a good default for seam-free results.
• seed - diffusion is stochastic; fix it for reproducible runs.
• keep_model_loaded - leave it off and the engine is released after each run, freeing VRAM; flip it on when you're upscaling a batch and want to skip the reload.

The output is a single upscaled_image (IMAGE), resized back to your original aspect ratio, so it wires straight into a Save Image node. Output is a straightforward IMAGE, input is a standard IMAGE - you don't need anything exotic on the front end.

Installation is where the pack earns a warning. Manager search "NunchakuFluxLoraStacker" and install, or:

cd ComfyUI/custom_nodes
git clone https://github.com/ussoewwin/ComfyUI-NunchakuFluxLoraStacker.git

Then two things that are easy to miss. First, this is NVIDIA-only: the .rtxplan engine needs the TensorRT-RTX runtime, which the pack's install.py installs (Manager runs it for you; the pinned stack is tensorrt-rtx 1.6.1.120 plus the Windows triton wheel). Second, the engine itself is not built at install time - you download it. Grab ccsr_apply_f16io.rtxplan and ccsr_trt_aux.safetensors from the pack's Hugging Face repo (ussoewwin/CCSR-ConvRot-INT8-and-TensorRT-Engine) and drop both into nodes/CCSR/trt_engines/ inside the pack folder, then restart ComfyUI.

Where people get burned: the loader's engine dropdown will literally show "(no engine in trt_engines)" if you skipped the download, and the upscale node then dies on a missing file. And because the whole pack loads CCSR's dependencies at import time (pytorch-lightning, omegaconf, einops, open-clip), a botched install can take down the entire pack - if ComfyUI refuses to load it at all, run python install.py inside the pack folder rather than blaming your workflow.

Set expectations before you run it: this is a diffusion upscaler, so it's seconds-per-image, not instant like ESRGAN, and it's a dated model. Use it when you want structure-preserving, detail-adding upscale on a source that matters - faces especially - on an RTX card. For "more pixels, please," grab a Lanczos or ESRGAN node instead; CCSR is for when you want the faithful kind of enhancement.