HiFlow

You've got a FLUX render at 1024 that you love, and you want it at 2K or 4K with the composition intact and detail that's new, not the same pixels smeared bigger. That's HiFlow's reason to exist. In the ComfyUI-DyPE pack, the DyPE/SEGA/SPA nodes patch the model so your KSampler run can generate at high res from noise; HiFlow takes a different lane and refines a base latent upward - an upscale of an image you already made. Flow models only: FLUX, Qwen-Image, Krea-2, Z-Image, AuraFlow.

It's not tiled diffusion, it needs no ControlNet Tile, and it isn't a separate upscaler model like Flux-ControlNet-Upscaler - you don't download one, it runs whatever flow checkpoint is loaded. "Training-free" means no LoRA, no fine-tune, just a smarter way to sample the model you've got.

How it works

Rectified-flow models denoise along an almost-straight path from noise to image, and HiFlow exploits that. It first runs the base-resolution sampling once at native resolution and records the model's clean prediction at every step - the "reference trajectory." Each upscale stage then walks the bigger canvas from noise and keeps itself glued to that time-matched reference through three alignments: initialization (start the stage from the right point), direction (nudge low frequencies toward the reference via a Butterworth low-pass filter) and acceleration (match the reference's rhythm of when detail appears). Net effect: composition and structure carry over essentially verbatim, while high-frequency detail gets re-synthesized at the new size. It's the HiFlow paper (arXiv:2504.06232, NeurIPS 2025) in one node.

The wiring and inputs that matter

The chain is short: model loader → HiFlow → VAE Decode, with vae, positive and negative plugged in. Feed latent_image a base latent at native resolution (an EmptySD3LatentImage works). Because the node records the trajectory itself, it does its own sampling - an empty latent plus a noise_seed reproduces the whole from-noise reference run internally. No separate KSampler stage needed.

The inputs that matter:

• scale_factor - output size relative to the input latent. 2 doubles each side; upscales run in 2× doubling stages (so 1.5 still gives one 2× stage).
• steps / steps_per_stage - 30 base steps whose clean predictions form the reference; 16 guided steps per upscale stage.
• tau - the noise level where each stage enters. Lower keeps more of the base image's structure; higher re-imagines more (paper cascade: 0.6, 0.3, 0.3).
• cfg vs guidance - guidance for the base stage vs. the guided stages. FLUX-dev defaults: 3.5 and 4.5.
• denoise - only matters for a content latent (img2img style): 1.0 regenerates from pure noise, lower keeps more of your input. Ignored for an empty latent.

The output is a single High-Res Latent - decode it with your VAE. If you're pushing FLUX, chaining the pack's DyPE (ntk) before the loader adds RoPE extrapolation so attention stretches properly at the scaled size.

Install

Via ComfyUI Manager, search ComfyUI-DyPE and install; or manually:

cd ComfyUI/custom_nodes/
git clone https://github.com/wildminder/ComfyUI-DyPE.git

Then restart ComfyUI. This one's refreshingly light: the requirements are just torch and numpy, which ComfyUI already ships - no extra dependency download, and no model files to fetch. All eight pack nodes live under the WMNodes/image menu.

Gotchas worth knowing

First, the honest warning from the README: HiFlow inherits the reference's structure - including its mistakes. Generate a base you actually like, because it will faithfully upscale a bad face. Lower tau to preserve more of what's good; don't expect HiFlow to fix a bad base.

A few real failure modes, grounded in the changelog rather than folklore:

• Non-flow model wired in → a clear error points you to the pack's PixelRush node, the sibling cascade for SDXL/SD1.5-style models.
• Guidance-free models (Z-Image, Chroma) or empty negatives → leave cfg at 1.0. CFG is auto-skipped when the negative carries no tokens, so an empty negative is fine.
• 3D-latent image models (Qwen-Image, Krea-2) work as single-frame latents - earlier builds crashed on them. Actual multi-frame video input is still rejected by design.
• Burned or blurry output on an older install? Update the pack. HiFlow is the pack's newest node (v2.10+, September 2026) and took hard patches in its first week: the base stage used to sample an all-zeros latent as "noise" (the burned output), and the img2img noise mix was in the wrong space (drastic changes at any usable denoise). Fixed by v2.12.1.

Finally, the honest hardware note: every 2× stage decodes and re-encodes at 4× the pixels, and you're running diffusion at that scale - a 1K base to 4K is doable on 24 GB but slow. And when picking between pack members: generating from pure noise at high res is DyPE's job; keeping an image you already love intact at high res on a flow model is exactly why HiFlow exists.