DLN RTX Tile Refiner

Diffusion models have a hard native-resolution ceiling - push SDXL past ~1024 and you get twin torsos and repeating wallpaper. The standing fix is generate at native size, then climb. DLN RTX Tile Refiner is that second climb packaged as one drop-in node: it slices your image into a grid, runs a low-denoise KSampler pass on each tile, and stitches it all back together with actual effort put into the seams. It's the same idea as Ultimate SD Upscale or a manual hi-res fix, but everything lives inside a single node instead of a sprawling subgraph.

The "RTX" in the name is the interesting part. Before sampling, the node can upscale each tile with NVIDIA's Video Effects SDK (nvvfx) - a hardware super-resolution pass on your tensor cores - then let the KSampler work on that higher pixel density. Worth being honest about what that buys you: RTX super-resolution is a pixel/sharpening path, closer to an overclocked ESRGAN than a generative upscaler, so it gives the sampler more pixels to chew on rather than inventing pores and lashes for you. The genuinely generative detail comes from the low-denoise KSampler pass, which is where the "refiner" part earns its keep.

How it works

The mechanism, from the source: pick a grid (2x2 up to 32x32), and each tile gets VAE-encoded, run through common_ksampler at your chosen denoise, decoded, then merged back with a weighted blend mask. To stop the classic tiled-upscale look - visible seams and tiles that drift in color from each other - it layers on a surprising amount of polish:

• overlap (default 32): pixels of shared context between tiles. The node quietly enforces a smart minimum even if you set 0, so your seams are protected from yourself.
• blend_mode (Smoothstep / Gaussian / Linear): how the overlap regions fade. Default Smoothstep is much nicer than Linear, and the tooltip says so.
• color_match_strength: transfers the original tile's mean/std color stats onto the refined tile so one tile doesn't come back greener than its neighbor. Author recommends 0.7–0.9.
• context_padding (0–128, recommend 32–64): extra pixels pulled in around each tile as sampler context, discarded afterward. This is the biggest lever for tile-to-tile coherence.
• sharpening: a post-pass unsharp mask, 0.3–0.5 if you want crisp edges.
• detail_inject (0–0.5): adds a little noise to the latent before sampling to encourage micro-detail without raising denoise. 0.05–0.15 is the sane range.

There's an optional mask input so you can refine only specific regions - tiles not covered are skipped, which is handy when you want a face pass without touching the background.

The inputs you'll actually touch

The full KSampler set is there (model, positive, negative, vae, seed, steps, cfg, sampler_name, scheduler), plus:

• denoise - the single most important knob. 0.15–0.35 is the refinement zone; past ~0.5 each tile stops being a refinement and starts drifting toward whatever the prompt suggests, which is how you get a patchwork image.
• mode - "Refiner (Same Size)" bakes details back at original resolution; "Upscale (Larger Image)" grows the output, sized by rtx_upscale_factor (1.0–4.0, 1.0 = disabled) with an rtx_quality of LOW→ULTRA.

The output is one image tensor, ready to feed a SaveImage/PreviewImage or another pass.

Installing it

Via ComfyUI Manager (search "DLN RTX Tile Refiner"), or manually:

cd ComfyUI/custom_nodes
git clone https://github.com/rauldlnx10/Comfyui-DLN-RTX-Tile-Refiner

Then restart ComfyUI. There are no model files to download - it uses whatever checkpoint/UNET and VAE you already have. The one real dependency is optional: pip install nvidia-vfx, needed only for the RTX upscale path. It's NVIDIA-RTX-only (it needs tensor cores), so on AMD/Intel hardware just skip it - the node detects it's missing and falls back to pure KSampler tiling with a console warning, no crash.

Gotchas

• RTX silently not happening. If nvvfx isn't installed and you set rtx_upscale_factor above 1.0, the node warns and carries on. If your output isn't growing, check the console for the "[DLN RTX Tile Refiner] Warning" line.
• No ControlNet input. This node doesn't take a Tile-ControlNet condition the way some tiled pipelines do, so at higher denoise, tiles can drift more than a ControlNet-guided setup. Keep denoise low; that's the safety net.
• VRAM is kind. One tile at a time on GPU, blending done on CPU, so it'll do 4K-class work on modest cards.
• It's young. Single commit as of this writing, tiny user base - the features are real but this isn't the battle-tested warhorse that Ultimate SD Upscale is. For a quick, all-in-one refinement node it's a solid reach; just don't expect a decade of community knowledge behind it.