LLaDA-Image Edit Conditioning

LLaDA-Image does image editing the way modern hybrid models do: it doesn't add ControlNet, it doesn't ask you to babysit a denoise-strength slider, and it doesn't do the old img2img noise dance. Instead, T8LLaDAImageEditConditioning encodes your source photo twice - once into the VAE's latent space and once into semantic features via SigVQ - bundles both with your instruction, and lets the diffusion model rebuild the scene to match the text. Load a picture, type "turn the sky to sunset, keep everything else," and out comes a full render of the changed image.

The pack's example (base_editing for Base, turbo_editing for Turbo) feeds it a Load Image node plus the loader's CLIP and VAE.

What goes in and what comes out

• clip - CLIP output from T8LLaDAImageCheckpointLoader; it hosts the SigVQ encoder this node needs.
• vae - the loader's VAE. In most workflows a VAE only decodes at the end; here it also does the source-image encode, which is why the edit node takes it directly.
• image - the source, from a Load Image node.
• prompt - what you want changed, in natural language.
• negative_prompt - optional, defaults to empty.

Outputs: positive and negative CONDITIONING for the CFGGuider, plus a LATENT that's a blank (zeroed) canvas at the source image's size. That last one is the neat bit - the edit node hands you the latent too, so you wire its LATENT straight into SamplerCustomAdvanced and skip EmptyFlux2LatentImage entirely. Note it's a zero latent, not the encoded source: the reconstruction is driven by the source information packed into the conditioning, and the diffusion fills in the rest.

How the editing is steered

Under the hood the node does three encode-like jobs before sampling starts. It scales the image down to half resolution and encodes those pixels with SigVQ into semantic features - the model's read on what the picture is. Simultaneously the VAE encodes the full image into source_latents. Both get stitched into the conditioning so the sampler has the scene's identity plus your text delta to work from. The image is internally aligned to multiples of 32 (with a Lanczos resize if your loaded file doesn't line up), and anything below 32×32 is rejected outright.

This is a guided reconstruction, not a pixel-preserving patch, so set expectations accordingly: the README is upfront that edit quality depends on the input and the instruction, and not every edit is guaranteed. What changes is governed by how cleanly your prompt describes the delta, so plain instructions ("make it raining", "replace the background with a city at night") beat vague ones.

Install and the practical bits

Standard pack install: ComfyUI Manager → LLaDA-Image T8, or clone T8mars/Comfyui-LLaDa-Image-T8 into custom_nodes/, pip install -r requirements.txt, restart. ComfyUI 0.34.0+ required, and you'll need the matching checkpoint - Turbo editing expects the Turbo file and runs at CFG 1 with the pack's stochastic sampler; Base editing expects Base at CFG 5 with Euler.

Two practical warnings before you hit Queue:

• Output resolution equals input resolution. The node sizes to whatever image you loaded (aligned down to 32). Feed it a 4000px scan and it will happily render a 4000px image and chew through VRAM to do it. Downscale the source first if you're testing.
• The whole pipeline is slow-ish even on Turbo, because the semantic/SigVQ stage runs before diffusion and "Turbo's 4 steps" only covers the diffusion phase. Factor that in when you're iterating on prompts.

Keep a good source image, load it small enough for your GPU, and this node is the most direct "make this specific change" tool in the pack.