Qwen-Image-2.1 i2i: Starting From Your Own Image, and Why There Is No Strength Slider

If you searched for Qwen-Image-2.1 i2i, you already know what image-to-image (i2i) means: you hand a model an image instead of a blank latent, and you get back a picture that resembles it. What this page settles is when that is the right move on Qwen-Image-2.1 — and the part that surprises people arriving from other image models. On this one, the strength slider you are looking for does not exist. Qwen-Image-2.1's own pipeline takes no strength or denoise argument at all: your reference image goes in as context, the target image starts from pure noise, and the thing that decides how far the output drifts from your input is what you write. If what you actually need is one named thing changed with the rest left alone, that is a different job handled by a different line in the family — the Qwen-Image-Edit checkpoints — and the comparison on this page is the part worth reading first, because a reader searching "i2i" is often one search away from the wrong tool.

What the input image actually does

On Qwen-Image-2.1 a condition image enters the model through two doors, and neither of them is "a noisy starting latent you dial back". The repository and the diffusers pipeline class published for this model describe both:

• Text encoder — the text encoder is Qwen3-VL 8B, a vision-language model, and the vendor's repository states that it encodes the text instruction and the condition images into a single unified representation. Your image is, literally, part of what the model reads as its prompt.

• VAE — the same image is encoded into latent tokens and prepended to the noise, ahead of the target image's own tokens, so the transformer sees one joint sequence with your reference first and the thing being generated after it.

• Target start — the target latents are sampled from a Gaussian and denoised across the full schedule, from sigma 1.0 down. There is no partial-denoise entry point in that pipeline.

The third bullet is the whole difference from the i2i most people have used. In the classic scheme, you encode your input image, add noise to it in proportion to a strength value, and denoise from that point — so the input is genuinely present in the starting latent and the strength number decides how much of it survives. On Qwen-Image-2.1's own path your image is never the starting point. It is context. The output is not a cleaned-up version of your file; it is a new image painted with your file in the room.

One more detail is worth knowing because it is where the abbreviation the reader typed actually lives. The diffusers pipeline raises an explicit error if you try to pass pre-encoded latents as image, with the comment that "the text encoder has to see the image itself". The condition image must be pixels, not a tensor.

The strength control, and where it went

Diffusers does ship an img2img pipeline for this family, and its strength argument behaves exactly the way the field has taught you to expect. Read from the class's own docstring: the image "is used as a starting point and more noise is added the higher the strength", and "a value of 1 essentially ignores image". Its defaults are strength=0.6 and num_inference_steps=50. The two ends are therefore the two ends you already know:

• Strength near 0 — almost no noise is added, the denoise loop is short, and the output is barely distinguishable from your input. This is the setting for colour grading, a light texture pass, a near-copy.

• Strength at 1 — the noise added is maximal, the denoise runs the full schedule, and the input image is effectively discarded. It is text-to-image with an expensive no-op attached.

Here is the catch, and it is the reason this page exists. The example published with that pipeline loads the 2025 checkpoint, not this model. Qwen-Image-2.1 has its own pipeline class, QwenImage21Pipeline, and it takes no strength argument, no denoise argument, and no partial-noise entry point. Whatever value you remember setting on another model, there is nowhere on the 2.1 path to set it. The lever moved from a number to the prompt.

That is not a gap the vendor left open. It ships a model whose only job is to write that prompt: Qwen-Image-2.1-PE-I2I, a fine-tuned Qwen3.5-VL 9B checkpoint that takes a vague instruction plus one or more input images and returns a JSON object with a rewritten_prompt and one of two mutually exclusive fields — wh_ratio, when the request creates a new composition, or ratio_follow, when it should inherit the aspect ratio of a numbered input image. That JSON is the closest thing Qwen-Image-2.1 has to a strength setting. It is the model telling you whether your request keeps the input's frame or builds a new one. Note where the string "i2i" appears in the vendor's own naming: on this prompt-rewriting checkpoint, not on a separate image-to-image checkpoint. The 2.1 generation does not publish one.

i2i or editing: the rule to apply

Reach for i2i when you want a variation. Reach for editing when you want a change. Everything else follows from that one line.

• Variation — you like the image and want more like it. Another take, different light, the same character in a new scene, the same product in a new setting. You cannot name a single thing that must stay pixel-identical, because you are not preserving — you are repainting. That is an i2i job.

• Change — you can name the thing. "Keep the character and pose unchanged, put this shirt on them." The instruction is a constraint and the rest of the frame is a promise you are owed back. That is an editing job.

On Qwen-Image-2.1 both behaviours live in one checkpoint. The vendor's own release material calls it "a unified text-to-image generation and image editing model", and the local-edit path it documents is mask-shaped: circle or paint the region, or pass the original image and a separate mask as two inputs. What the 2.1 generation does not ship is a separate editing checkpoint.

The dedicated edit checkpoints are a different line and different generations. The vendor organisation's own model listing on Hugging Face, read on 13 October 2026, carries nine image models under that author, and the edit entries in it are Qwen-Image-Edit (created 17 August 2025), Qwen-Image-Edit-2509 (22 September 2025) and Qwen-Image-Edit-2511 (17 December 2025). None of them is a 2.1 model. So treat any page that says "Qwen-Image-Edit 2.1" with care: no repository under that name exists in the vendor's listing, and the spellings people type — "qwen image edit 3", "qwen image edit 2512" — do not match a published vendor repository either. Whatever a claim about the edit line tells you, check which generation it is about before you act on it, because the line spans three dated generations and the 2.1 release is not one of them.

Practically, the rule breaks down like this. If you can write the instruction as a sentence with a target in it — "make the sky sunset", "remove the watch" — you are in editing territory, and on 2.1 you reach it with a mask or painted annotation rather than by switching tools. If your sentence has no target and is really a description of the image you want next, you are in i2i territory. The reader who typed "i2i" and then found themselves writing an imperative is the reader who needs the edit path, and that is the whole reason this section sits this high on the page.

What your input image constrains

Five things you fix the moment you choose a reference, all of them documented in the pipeline's own code or in ComfyUI's published documentation for this model. Read on 13 October 2026.

• Resolution budget — the 2.1 pipeline's output_resolution defaults to 1024, and every condition image is resized to a budget of output_resolution squared at its own aspect ratio, rounded to multiples of 32. A 3000×4000 photograph is therefore reduced to roughly 896×1184 — about one megapixel — before the model sees a single pixel of it. ComfyUI's documentation makes the cost concrete: the same work at a 3008×4000 canvas against roughly 896×1184 runs at about 6 seconds per iteration versus about 0.3, measured on an RTX 5090. Lowering the canvas makes an i2i run faster by producing a smaller image, not by adding detail.

• Aspect ratio — if you omit height and width, the output canvas is derived from the aspect ratio of the last condition image you pass. Individually, each reference keeps its own shape, so a portrait and a landscape can travel in the same call without one being cropped to the other's frame.

• Multiples of 32 — the pipeline warns and silently resizes when height or width is not divisible by the VAE scale factor times two, which on this model is 32. If you are picking a canvas by hand, round it.

• Native size — Qwen-Image-2.1 is trained at 2K, and the sizes the repository recommends are all in that band: 2048×2048 for 1:1, 2752×1536 for 16:9, 1536×2752 for 9:16, and 2400×1792 for 4:3. ComfyUI's documentation states the default target is one megapixel, that you set roughly 4.0 MP for a native 2048×2048 square, and — the useful warning — that a target well above the trained size, 4K for example, loses prompt adherence instead of gaining detail.

• Alpha — if your reference carries transparency, the vision encoder is handed a copy composited over white; only the VAE copy keeps all four channels. Anything you expect the model to understand about your transparency is being read by the text side as white background.

What survives, and what gets reinvented

Be precise here, because the release material and the mechanism say different things and both are true.

• Documented to survive — the vendor claims fidelity work on two fronts: portrait identity, so a person stays recognisable across edits and generations, and product consistency, preserving text, textures and shape. Those are vendor claims illustrated with side-by-side examples rather than attached to a measurement, and no independent score for either was published in the material read for this page on 13 October 2026.

• Guaranteed at pixel level — nothing. Your reference is context tokens and a vision prefix; the target is noise. Any part of the input that your prompt neither addresses nor implies is free to change, and no setting in the pipeline holds it in place. If a detail must not move, name it in the prompt, because nothing else will.

• Marks leak into the input — in ComfyUI's documented edit workflow, paint-pen strokes land on the image's RGB layer rather than in a mask, so saving writes the marked image back into the node and the marks become part of the reference the model reads. Keep a mark inside the region you want changed, and state the colour you want in the prompt as well, because the mark's colour can otherwise surface in the output.

• A mismatched canvas shifts the result — ComfyUI's documentation advises keeping a custom canvas close to the resized size of the first reference image, "otherwise the edit can shift". An input whose shape differs from the canvas you asked for does not get letterboxed; it gets moved.

• Determinism takes two settings, not one — toggling use_kv_cache on the 2.1 pipeline changes the sample at a fixed seed, because the cache makes the decode step attend with a different sequence layout than the prefill step, so the two "give equally valid but visibly distinct samples". The pipeline's own advice is to fix the flag. In ComfyUI the equivalent control is the cache node's storage precision, where — ComfyUI's own figures, unaudited — int8 halves the cache at about bf16 accuracy and int4 quarters it while roughly doubling the per-step error.

Where i2i is the wrong tool

Five cases, each with the alternative named.

• You can name the exact thing to change. Use the instruction path on Qwen-Image-2.1 — paint or circle the region, or pass a separate mask as a second input — or a dedicated checkpoint from the Qwen-Image-Edit line. i2i will repaint the frame around your target along with the target itself.

• You need the original pixels kept. i2i produces a new image; it does not preserve any. The mask path is the one built to leave the rest of the frame alone.

• You need 4K. Above the 2K trained size the model loses prompt adherence, per the ComfyUI documentation. i2i at 4K is a slower run that follows your description less, not a sharper one.

• You need fine detail from the input reproduced. The condition image is resized to roughly a one-megapixel budget first, so a 12-megapixel reference never reaches the model at full resolution. Detail smaller than that budget is gone before denoising starts.

• You need a bit-identical repeated run. Fix the KV cache flag and the seed, and change one setting at a time — otherwise you are comparing two different samplers and calling it noise.

One cross-reference, because it will come up: the Turbo checkpoint released 9 October 2026 uses the same 7B visual generation architecture and the same image-conditioning path, and runs the schedule in 8 denoising steps instead of about 40. Nothing about how your input image is used changes between the two. If you want the i2i path at speed, that is the checkpoint to load; if you are debugging why your reference is being ignored, the step count is not the variable.

What to do next

Start from the vendor's own Quick Start on the model card rather than from a tutorial, and read the editing example's argument list: it passes image=input_image, sets num_inference_steps, and has no strength argument anywhere. That absence is this page's whole point, and seeing it in the vendor's code is faster than believing a summary.

From there, set output_resolution to the size you actually need before you judge anything about resemblance, keep your canvas on the native 2K presets where you can, and write the prompt as though the reference were a photograph lying next to the prompt rather than a latents tensor being partially denoised — because on this model that is what it is. And if, three tries in, you find yourself wanting to say "change only this, leave everything else", stop. That sentence is your signal that i2i is the wrong route, and the edit line is where it belongs.