Image to image (img2img) is one of the most useful things you can do in ComfyUI. Instead of starting from random noise, you give the model a picture and a prompt, and it makes a new version.
You can turn a photo into a painting, a rough sketch into a finished render, or give an old image a fresh style while keeping its layout.
The whole technique comes down to one setting: denoise. Get that right and img2img becomes predictable. Get it wrong and you either get a copy of your input or something that ignores it completely.
This guide shows how to build the basic img2img workflow, how denoise and steps really work (including a detail most guides get wrong), the best settings for common jobs, how to do img2img with SDXL and Flux, and how to fix the usual problems. It follows the official ComfyUI documentation as of November 2026.
- Workflow:
Load Image>VAE Encode>KSampler(latent input) >VAE Decode. It replaces theEmpty Latent Imagefrom text to image. - The key setting is denoise in KSampler. It must be below 1.0.
- Low denoise (0.2 to 0.4): small touch-ups. Medium (0.5 to 0.65): restyle but keep the layout. High (0.7 to 0.85): big changes, loose layout.
- Steps do not drop with low denoise. 20 steps at 0.5 still runs 20 steps, just over the low-noise part of the schedule.
- Resize your input to the model’s native size (512 for SD 1.5, about 1024 for SDXL and Flux).
- Need the exact pose or edges? Add ControlNet instead of pushing denoise lower.
What Image to Image Does
In text to image, ComfyUI starts with an empty latent full of random noise and gradually removes the noise to match your prompt. In image to image, it starts with your picture instead:
- Your image is encoded into latent space by the VAE.
- Some noise is added to it. How much depends on denoise.
- The model removes that noise, guided by your prompt.
- The result is decoded back to a normal image.
Because the model never sees pure noise (unless denoise is 1.0), the colours, shapes and composition of your input survive into the output. Typical uses:
- Turning photos into art styles (watercolour, anime, oil painting, 3D render).
- Turning line art or sketches into finished images.
- Restoring or colourising old photos.
- Making variations of an image you already like.
- Adding detail to a low-quality image (often paired with an upscale).
New to ComfyUI itself? Start with our ComfyUI beginner’s guide first.
Build the Basic img2img Workflow
Option A: Load the official example
- Download
v1-5-pruned-emaonly-fp16.safetensorsfrom the Comfy-Org stable-diffusion-v1-5-archive page on Hugging Face. - Put it in
ComfyUI/models/checkpoints/. - Download the image-to-image workflow image from the ComfyUI docs and drag it onto the canvas.
- Select the checkpoint in
Load Checkpoint. - Upload your picture in
Load Image. - Press Run, or
Ctrl + Enter.
Option B: Convert a text-to-image workflow yourself
Any text-to-image workflow becomes img2img with four changes:
- Delete the
Empty Latent Imagenode. - Add a
Load Imagenode and upload your picture. - Add a
VAE Encodenode. ConnectLoad ImageIMAGE to itspixelsinput and the checkpoint’s VAE to itsvaeinput. - Connect the VAE Encode LATENT output to the KSampler
latent_imageinput, then set KSamplerdenoiseto about 0.6.
| Node | Text to image | Image to image |
|---|---|---|
| Latent source | Empty Latent Image | Load Image + VAE Encode |
| Output size | Set in Empty Latent | Same as the input image |
| KSampler denoise | 1.0 | Below 1.0 (usually 0.3 to 0.8) |
| Prompt | Describes everything | Describes the result you want, including what to keep |
How Denoise Works
Denoise controls how much noise is added to your encoded image before sampling. The official docs put it simply: the smaller the denoise, the closer the result stays to the reference. At 1.0, the latent becomes completely random noise, exactly like an empty latent, and your image is lost.
| Denoise | What you get |
|---|---|
| 0.0 | No sampling at all. The output is your input. |
| 0.1 to 0.3 | Subtle cleanup, sharper detail, small colour shifts |
| 0.35 to 0.5 | Light restyle. Faces, layout and colours mostly kept. |
| 0.5 to 0.65 | Clear restyle. Layout kept, textures and details redrawn. |
| 0.7 to 0.85 | Strong change. Rough composition and colour palette survive. |
| 0.9 to 0.99 | Mostly new image. Only faint hints of the original. |
| 1.0 | Same as text to image. The input is ignored. |
A good habit: run the same seed at 0.4, 0.55 and 0.7 side by side, then fine-tune from the closest one.
Steps and Denoise: The Detail Most Guides Miss
Many tutorials say low denoise “runs fewer steps”. In current ComfyUI, that is not how it works. According to the official docs, a low denoise does not lower the number of steps a run performs. ComfyUI builds a longer schedule of steps / denoise steps and keeps only its last steps + 1 noise levels.
In practice:
- 20 steps at denoise 0.5 runs 20 real sampling steps over the low-noise half of a 40-step schedule. That is a finer, denser pass than a normal 20-step run.
- Want the same speed as before? Multiply your steps by denoise. For 0.5, use 10 steps to match the step density of a full 20-step run.
- Only denoise 0 skips sampling entirely.
So if img2img feels slow, you can safely lower steps when using low denoise. If results look under-cooked at high denoise, raise steps.
Settings for Common Jobs
| Job | Denoise | CFG | Prompt tip |
|---|---|---|---|
| Sharpen or clean up an AI image | 0.2 to 0.35 | Normal | Repeat the original prompt, add “sharp focus, detailed” |
| Photo to painting or anime | 0.5 to 0.65 | Normal to slightly high | Name the style clearly, for example “watercolour illustration” |
| Sketch to finished render | 0.65 to 0.8 | Normal | Describe materials, lighting and colours the sketch lacks |
| Colourise a black and white photo | 0.4 to 0.55 | Normal | Describe colours of clothes, sky and skin |
| Variations of an image | 0.45 to 0.6 | Normal | Same prompt, change the seed |
| Second pass after an upscale | 0.25 to 0.4 | Normal | Same prompt as the original |
The last row is the classic “hires fix”: upscale the image, then run img2img at low denoise to add real detail. Our ComfyUI upscale guide shows the full chain.
img2img With SDXL and Flux
The node chain is the same for every model. Only the loaders change.
| Model | Loaders | Native size | Notes |
|---|---|---|---|
| SD 1.5 | Load Checkpoint | 512 x 512 | Fast on any GPU. Huge LoRA library. |
| SDXL | Load Checkpoint | About 1024 x 1024 | Better detail. Keep the input near 1 megapixel. |
| Flux.1 dev / schnell | Load Diffusion Model, DualCLIPLoader, Load VAE | About 1024 x 1024 | Encode with the Flux VAE (ae.safetensors). Flux needs higher denoise for visible changes. |
For Flux, wire Load VAE into VAE Encode as well as VAE Decode. Using a different VAE for encode and decode gives strange colours. See how to use Flux for the loader setup.
For instruction-style editing (“make it night time”, “change the jacket to red”), dedicated edit models such as Flux.1 Kontext do a better job than plain img2img because they keep the rest of the image untouched. Our Flux.1 Kontext dev guide covers that.
Resolution and Aspect Ratio
img2img outputs the same size as your input. Feeding a 4000-pixel phone photo straight in is the number one cause of slow runs, out-of-memory errors and duplicated subjects.
- Add an
Upscale Imagenode (orImageScaleToTotalPixels) betweenLoad ImageandVAE Encode. - Scale to the model’s native size: about 0.25 megapixels for SD 1.5, about 1 megapixel for SDXL and Flux.
- Keep the width and height divisible by 8.
- Upscale the finished result afterwards if you need a bigger file.
When img2img Is Not Enough
| You want | Use instead |
|---|---|
| Keep the exact pose, edges or depth while changing style a lot | ControlNet with denoise 1.0 or high img2img |
| Copy the style or subject of a reference image into a new prompt | IPAdapter |
| Change only one area | Inpainting |
| Make the canvas bigger | Outpainting |
| Edit with plain-English instructions | Flux.1 Kontext or Qwen Image Edit |
You can combine these. A common pro setup is img2img at 0.6 plus a ControlNet for structure, which lets you restyle heavily without losing the layout.
Troubleshooting
| Problem | Likely cause | Fix |
|---|---|---|
| Output looks identical to the input | Denoise too low | Raise denoise in steps of 0.1 |
| Output ignores the input | Denoise at or near 1.0, or Empty Latent still connected | Lower denoise and check VAE Encode feeds the KSampler |
| Duplicated people or objects | Input far bigger than the model’s native size | Resize the input before VAE Encode |
| Washed out or wrong colours | Mismatched VAE between encode and decode | Use the same VAE for both |
| Faces get distorted | Denoise too high for the job | Lower denoise or add a face detailer pass |
| CUDA out of memory | Large input image | Resize, or see our CUDA out of memory fix |
| Run is slow at low denoise | Steps stay the same with low denoise | Lower steps to about steps x denoise |
| Error about channels or alpha | PNG with transparency | Flatten the image or use the IMAGE output only, not the MASK |
FAQ
What is a good default denoise for img2img?
Start at 0.55 to 0.6. It restyles noticeably while keeping the layout. Adjust up or down from there.
Does the prompt still matter in img2img?
Yes, a lot. The prompt guides everything that changes. Describe the result you want, including parts you want kept.
Can I use LoRAs with img2img?
Yes. Add Load LoRA after the checkpoint exactly as you would for text to image. Style LoRAs work very well with medium denoise.
Why does img2img keep the old colours even at 0.7?
Colour is one of the last things to be overwritten. Raise denoise, or describe the new colours strongly in the prompt.
Can I batch img2img over a folder of images?
Yes. Custom node packs offer folder loaders, or you can queue several runs with different input images. Keep denoise and seed the same for a consistent look.
Is img2img the same as “image variation”?
Close. Variations are just img2img with the same prompt, medium denoise and a different seed.




