APG: Adaptive Projected Guidance (Sadat et al. 2025)

Here's the deal every SDXL user knows in their bones: push CFG past about 9 and the prompt adherence goes up while the image goes to hell - neon colors, clipped highlights, plastic skin. That isn't superstition. It's the geometry of what CFG does. APG (Adaptive Projected Guidance, Sadat, Hilliges & Weber, ICLR 2025) is the most useful of the recent attempts to fix it, and this is the pack's implementation, with the paper's own defaults.

It's also the one node in the pack with a genuinely large Reddit footprint behind the idea, mostly via SDNext and Wan workflows rather than this pack - people adopt APG long before they know what it stands for.

How it works

Plain CFG takes the difference g = c - u and multiplies it by w - 1. APG splits that difference into two pieces at every pixel: the part that points along the conditional prediction c, and the part perpendicular to it. Then it treats them very differently.

The parallel part is the one that scales up saturation, so it gets multiplied by eta - at the paper's default of 0, it's switched off entirely. The perpendicular part carries the actual compositional change, so it's kept. On top of that, the norm of g is capped, and a reverse momentum term subtracts a fraction of the previous step's difference, which stops the push from compounding. Written out, the paper's form is c + (w - 1)(g_perp + eta · g_par).

The upshot: high scales keep obeying the prompt without the whole image running off the gamut. This is the mechanism the pack's CFG Mix: Direction Rules node exposes as one of four rules, and the pack's CFG Govern: Angle Band node is a stricter relative of the same idea.

Inputs that matter

Five inputs, and two of them you should think about:

• model, and scale - -1 means "use the KSampler's cfg", which is the sane default.
• eta (default 0) - how much of the along-c component survives. eta = 1 with no cap and no momentum is exactly plain CFG, which makes it a free baseline switch.
• norm_threshold (default 15) - the cap on the size of g, in the latent's own units. 0 is no cap. If your images look unchanged, the cap is probably biting at a level your image never reaches; if they look flat, it's biting too hard. Tune it near APG's typical g size for your model, not by copying the number to a different architecture.
• momentum (default -0.5) - the paper's SDXL value, negative because it's reverse momentum. 0 turns it off.
• formulation - paper is c + (w-1) g'; comfyui is c + w g' (one unit more guidance, so it hits differently at the same number); diffusers is u + w g'. If you're porting settings from another UI, this is why your scale doesn't match.
• space - auto uses the denoised image, which is where APG was published. Its projection is nonlinear, so changing the space changes the picture.

Output is a MODEL. Wire it between your loader and the sampler; the sampler's cfg is your scale.

Install

# ComfyUI Manager: search "CFG Megapack" -> Install -> restart
# or:
comfy node install comfy-cfg-megapack
# or by hand:
cd ComfyUI/custom_nodes && git clone https://github.com/AbstractEyes/comfy-cfg-megapack

No dependencies, no model downloads - it's pure torch and stdlib on top of ComfyUI. It needs ComfyUI 0.38 or newer.

Traps worth knowing

Only one CFG function per model. ComfyUI's model carries a single CFG-function slot. If you also loaded a RescaleCFG or Mahiro node from another pack after this one, the last one chained wins and APG quietly does nothing.

The pack always runs the unconditional pass. Its hook disables ComfyUI's CFG-1 optimization, so on a distilled checkpoint where you'd normally run at cfg 1 you lose the "second pass is skipped" speedup the moment any pack node touches the model. At cfg 1 these rules are also inert by construction - w = 1 means no guidance to project.

Compare properly. Queue once with another seed first - ComfyUI's very first sampling after a model load rounds slightly differently, so a fresh A/B pair can differ for reasons that have nothing to do with APG. The pack's example_workflows/ templates render plain CFG and the variant from one seed, which is the right way to judge it.