KSampler Cycle
Automated hi-res-fix loops in one node
- model
- positive
- negative
- latent_image
- vae
- secondary_model
- upscale_model
- processor_model
- pos_additive
- neg_additive
- latent(s)
KSampler Cycle is a sampler that does hi-res-fix passes in a loop for you. Instead of wiring up sample → upscale → sample → upscale by hand, you tell it a target upscale factor and how many steps to get there, and it cycles: sample, upscale a bit, sample again, upscale again, climbing to your target resolution over several rounds. It's the WAS answer to the multi-pass upscale that the community builds manually.
It's a niche node - a handful of corpus mentions, not a household name - but the idea behind it is exactly the mainstream one. The upscaling KB calls hi-res fix "essential for any generation above native resolution," done by generating at native size then re-sampling larger with low denoise to add coherent detail. This node just automates the repetition.
How it works
The README lays out the moving parts. You give it an upscale factor (how big you're ultimately going) and a number of steps to reach that factor - the cycles. Each cycle upscales the latent/image a fraction and runs another sampling pass, so the model adds detail as the resolution climbs rather than in one jarring jump. It accepts an upscale_model (an ESRGAN like 4x-UltraSharp for the pixel step), a 1x processor model slot, and optionally a secondary diffusion model so a different checkpoint can handle the refinement passes.
The reason gradual beats one-shot: the KB's hi-res-fix guidance is that upscale factor of 1.5–2x per pass with moderate denoise is the sweet spot, and pushing too far or denoising too hard changes the composition. Cycling in smaller increments is how you reach a large final size while keeping each step's denoise gentle.
Inputs and outputs that matter
Beyond the usual sampler inputs (model, positive/negative conditioning, latent, seed, steps, cfg, sampler/scheduler), the ones specific to this node are the upscale factor, the number of cycles/steps to reach it, the upscale_model, and the optional secondary diffusion model. The output is a LATENT you then VAE-decode to see the upscaled result.
How to install it
ComfyUI Manager: search was-node-suite-comfyui, install, restart. Manually:
cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui
then install the pack's requirements.txt in your ComfyUI venv and restart. To use the upscale-model slot you'll want an ESRGAN .pth (4x-UltraSharp is a safe default) in ComfyUI/models/upscale_models/.
Common issues & troubleshooting
The composition drifts as it climbs. Too much denoise per cycle. Hi-res fix stays faithful at 0.3–0.4 denoise; above ~0.5 the picture starts changing, and across several cycles that compounds. Keep per-pass denoise gentle.
It's slow. Of course - you're running multiple full sampling passes at increasing resolution. That's the cost of multi-pass quality. If you want speed, fewer cycles or a smaller final factor; if you want quality, this is the trade you signed up for.
Faces get worse the bigger it goes. The KB's standing rule: fix faces and hands at native resolution before upscaling, because upscaling bakes in defects, and generative passes rewrite identity. Don't count on the cycle to repair a bad face - give faces a dedicated detail pass.
Is this the best way to upscale in 2026? It's a fine automated hi-res fix, but the field moved on. For pure "more detail" the KB's current pick is SeedVR2; for tiled large prints, Ultimate SD Upscale with ControlNet Tile. KSampler Cycle is convenient if you're already living in WAS, not the state of the art.
Whole pack won't import after a ComfyUI update. The recurring WAS Node Suite issue - package downgrades vs a ComfyUI bump breaking the startup import. Re-run the pack's requirements against the activated venv, or install.bat. Maintenance-only since late 2023.
Inputs (39)
| Name | Type | Default | Description |
|---|---|---|---|
| model | MODEL | The diffusion model every cycle samples with, unless secondary_model takes over partway through. | |
| seed | INT | 00–18446744073709550000 | Seed for the noise. Every cycle uses this same seed, so the whole run is repeatable; change it for a different image. Any whole number; `0` is as good a seed as any. |
| steps | INT | 201–10000 | Sampling steps on the first cycle. More steps take longer and resolve more detail, with little to gain past about 30 for most models. Turning steps_scaling on changes this figure on later cycles. |
| cfg | FLOAT | 8.000–100 | How closely the image is held to the prompt. Around 7-8 suits most models; lower is looser and softer, much higher tends to burn contrast and flatten detail. |
| sampler_name | COMBO | The sampling algorithm. 'euler' is the plain, predictable choice; the 'ancestral' and 'sde' variants add fresh noise as they go and keep changing the image at high step counts; the 'dpmpp' family converges in fewer steps. The list is whatever this ComfyUI offers. | |
| scheduler | COMBO | How the noise level is stepped down over the run. 'normal' and 'karras' are the usual choices, karras spending more steps at low noise where fine detail is decided. The list is whatever this ComfyUI offers. | |
| positive | CONDITIONING | Encoded prompt describing what the image should contain. | |
| negative | CONDITIONING | Encoded prompt describing what to keep out of the image. | |
| latent_image | LATENT | The latent the first cycle works on: an empty one to generate from scratch, or an encoded image to work up from. Its size sets where the enlargement starts. | |
| tiled_vae | COMBO | `enable` converts between latent and pixels a tile at a time, which needs far less VRAM at large sizes and can leave faint seams. Only matters when latent_upscale is `disable`, since that is the only path that goes through pixels. | |
| latent_upscale | COMBO | How the enlargement between cycles is done. `disable` takes the slower, sharper route through pixels, using vae, upscale_model, processor_model and scale_sampling. Any other entry stays in latent space and is much faster, ignoring all four; `nearest-exact` is the blockiest, `bilinear` and `bicubic` smoother, `area` averages, and `bislerp` is a blend built for latents. | |
| upscale_factor | FLOAT | 2.00.1–8 | Total enlargement across the whole run, not per cycle: 2.0 means the result is twice the size it started at, and the cycles share that growth evenly between them. |
| upscale_cycles | INT | 22–12 | How many sample passes to run. Enlargement happens between passes, so 2 grows once and 4 grows three times in smaller jumps, which is gentler but slower. Capped at steps, since a pass needs at least one step. |
| starting_denoise | FLOAT | 1.000–1 | How much of the first pass is redrawn. 1.0 ignores latent_image's content and generates from noise; around 0.5 keeps its composition and changes the detail; 0.0 changes nothing. |
| cycle_denoise | FLOAT | 0.500–1 | How much every pass after the first redraws. This is what keeps the enlarged image recognisable: 0.5 refines it, and much above that starts inventing new content at each size. |
| scale_denoise | COMBO | `enable` halves cycle_denoise again on each pass after the second, so later passes only polish; denoise_cutoff sets how low it may go. `disable` uses cycle_denoise unchanged on every pass. | |
| scale_sampling | COMBO | Which filter resizes the decoded picture on the pixel-space route. `lanczos` and `bicubic` are the sharpest, `bilinear` softer, `nearest` blocky. Ignored unless latent_upscale is `disable`. | |
| vae | VAE | The VAE used to decode to pixels and encode back between cycles. Required even when latent_upscale keeps the work in latent space and nothing is decoded. | |
| secondary_modelopt | MODEL | A second diffusion model to hand the later cycles to, so one model lays out the image and another finishes it. Disconnected, one model does the whole run. | |
| secondary_start_cycleopt | INT | 22–16 | Which pass secondary_model takes over on, counting from 1, so 2 hands over straight after the first. That pass also uses cycle_denoise rather than any scaled-down value. |
| upscale_modelopt | UPSCALE_MODEL | An upscale model such as ESRGAN to do the enlarging, which recovers far more detail than a plain resize. Its result is fitted to the target size, rounded to a multiple of 32. Disconnected, the picture is simply resampled. Ignored unless latent_upscale is `disable`. | |
| processor_modelopt | UPSCALE_MODEL | An upscale model run before the enlargement and shrunk straight back to the size it started at, so it cleans up artefacts and restores detail without changing the size. Ignored unless latent_upscale is `disable`. | |
| pos_additiveopt | CONDITIONING | A second positive prompt mixed into the first a little more, or a little less, on every cycle, a way to steer the image somewhere new as it grows. Disconnected, the positive prompt stays as it is. | |
| neg_additiveopt | CONDITIONING | A second negative prompt mixed into the first a little more, or a little less, on every cycle. Disconnected, the negative prompt stays as it is. | |
| pos_add_modeopt | COMBO | Which way pos_add_strength moves between cycles: `increment` doubles it each pass, so pos_additive takes over gradually; `decrement` halves it, so its influence fades out. Only used when pos_add_strength_scaling is enabled. | |
| pos_add_strengthopt | FLOAT | 0.250.01–1 | How much of pos_additive is mixed in on the first cycle. 0.25 is a quarter of the way towards it, 1.0 replaces the positive prompt outright. |
| pos_add_strength_scalingopt | COMBO | `enable` lets pos_add_mode change the strength from cycle to cycle. `disable` holds pos_add_strength steady for the whole run. | |
| pos_add_strength_cutoffopt | FLOAT | 2.000.01–10 | The limit the scaled strength is held to: a ceiling while incrementing, a floor while decrementing. At the default of 2.0 in increment mode the strength is effectively unbounded, since 1.0 already means full replacement. |
| neg_add_modeopt | COMBO | Which way neg_add_strength moves between cycles: `increment` doubles it each pass, `decrement` halves it. Only used when neg_add_strength_scaling is enabled. | |
| neg_add_strengthopt | FLOAT | 0.250.01–1 | How much of neg_additive is mixed in on the first cycle. 0.25 is a quarter of the way towards it, 1.0 replaces the negative prompt outright. |
| neg_add_strength_scalingopt | COMBO | `enable` lets neg_add_mode change the strength from cycle to cycle. `disable` holds neg_add_strength steady for the whole run. | |
| neg_add_strength_cutoffopt | FLOAT | 2.000.01–10 | The limit the scaled strength is held to: a ceiling while incrementing, a floor while decrementing. |
| sharpen_strengthopt | FLOAT | 0.000–10 | How hard to sharpen the enlarged picture before it is encoded again. 0.0 skips sharpening entirely; around 1.0 counteracts the softness of a resize; far above that leaves halos. Ignored unless latent_upscale is `disable`. |
| sharpen_radiusopt | INT | 21–12 | How wide the sharpening reaches, in pixels. Small values pick out fine texture, large ones lift broad edges and coarsen the picture. Only used when sharpen_strength is above 0. |
| steps_scalingopt | COMBO | `enable` changes the step count on every pass after the first, by steps_scaling_value and in the direction steps_control names. `disable` keeps steps the same throughout. | |
| steps_controlopt | COMBO | Which way the step count moves. `decrement` spends fewer steps on each larger pass, which is the cheaper choice since low-denoise passes need fewer; `increment` spends more. | |
| steps_scaling_valueopt | INT | 101–20 | How many steps are added or taken away on each pass after the first. Only used when steps_scaling is enabled. |
| steps_cutoffopt | INT | 204–1000 | The step count the scaling is not allowed past: a ceiling while incrementing, a floor while decrementing. At the default of 20, with steps also 20 and steps_control on `decrement`, the count never moves. |
| denoise_cutoffopt | FLOAT | 0.250.01–1 | The lowest denoise the halving under scale_denoise may reach, so later passes still do some work. Ignored when scale_denoise is disabled. |
Outputs (1)
| Name | Type | Description |
|---|---|---|
| latent(s) | LATENT | The latent after the final pass, at the full enlarged size. Decode it with a VAE Decode to see the picture. |