RALUFluxWorkflowBridge

If you're trying RALU on FLUX for the first time, this is the node you want. RALUFluxWorkflowBridge wraps the entire three-stage RALU sampling pipeline into a single node: model in, latent out. The pack's minimal example workflow is literally UNETLoader → RALUFluxWorkflowBridge → VAEDecode → SaveImage - six nodes total, and the hardest part is having the Flux model files on disk.

The name says "bridge" because it's exactly that: the node that connects a normal FLUX loading chain (UNET + text encoders + a FluxGuidance output) to the RALU runtime, without you having to wire up the model adapter, the noise source, the empty latent, and the sampler core yourself.

What it does internally

Everything RALUSamplerCore needs, done for you (it's all visible in the source):

• Patches the model with resolution-aware shift via adapt_model.
• If your conditioning has no guidance metadata, stamps it with 3.5 - so a plain CLIPTextEncodeFlux → bridge chain just works.
• Builds an empty latent at your width/height.
• Creates correlated_ralu noise from your seed.
• Runs the three-stage sampler: quarter-res coarse denoise, selective token upscale + correlated noise, full-res finish.

The inputs you'll actually set are model, conditioning, width, height, seed, and steps (default 18). The advanced ones - use_ralu_default, level (4 or 7), up_ratio, N_json, e_json, debug_save_intermediates - mirror RALUSamplerCore and you can ignore them until you're tuning.

The vae input is the interesting one

vae is optional but genuinely worth wiring. The stage-2 token selection - deciding which 30%-ish of tokens deserve full-res denoising - scores patches two ways: with a VAE it decodes the predicted image and runs Canny edge detection to find the high-detail regions; without one it falls back to a latent-space energy/gradient heuristic. Wire your VAE in and the expensive compute goes where the edges are. It's the difference between the algorithm guessing at detail and actually looking at it.

Outputs: latent (decode with your VAE), upscaled_preview_latent and noised_preview_latent (the intermediate stages, useful for understanding what the sampler is doing), and debug_info, a JSON string with the effective schedule and an implemented flag.

Installing and getting a workflow fast

cd /path/to/ComfyUI/custom_nodes
git clone https://github.com/Milkyawaway/comfyui-ralu-sampling.git
cd /path/to/ComfyUI
python -m pip install opencv-python numpy typing-extensions
python main.py

ComfyUI Manager: search "comfyui-ralu-sampling". Restart, then the fastest path is dragging examples/workflows/ralu_flux_minimal_00001_.png onto your canvas - it's a generated output image with the whole minimal workflow embedded in its metadata. Or load flux_ralu.json for the fuller version. Both expect standard ComfyUI model folders with flux1-dev.safetensors, clip_l, clip_g, t5xxl_fp16, and ae.safetensors.

Common issues

• Nothing in the node palette - this pack registers through ComfyUI's newer comfy_api.latest extension API. Old ComfyUI versions won't show any of these nodes; update ComfyUI first.
• Errors about conditioning - RALU needs a non-empty conditioning with pooled output. That means the standard FLUX CLIPTextEncodeFlux chain, not a bare SD1.5-style encode.
• "Unknown family" / "not implemented" - family should stay on flux. Only flux and sd3 actually execute in this pack.
• Odd artifacts at high res - the SD3 path is the one the author explicitly calls a "two-stage approximation" used to study grid artifacts; the FLUX path is closer to the original RALU method, so if you're seeing grid-like problems, that's part of why the research exists.

Want to see RALU working in the least fiddly way possible? This is it. One node, your Flux UNET, a prompt, and you're sampling at mixed resolution.