LLaDA-Image VQ Conditioning

LLaDA-Image's normal text-to-image path encodes your prompt straight into diffusion conditioning, and it's fine. The VQ path is the one that's genuinely weird in a good way: instead of only reading your words, it first runs an autoregressive language model called LLaDA2 that writes the image as a sequence of discrete tokens, like a caption turned into a picture spelled out in codebook IDs. Those tokens are then decoded into visual-semantic features and attached to the conditioning, so the diffusion stage starts with an actual plan for what the picture contains. No input image required; this is text-to-image, just with an extra "think first" stage.

The pack ships it as VQ generation workflows (base_vq and turbo_vq), and it's the workflow you'd reach for when you want the composition to be decided in language before rendering - structured scenes and specific object layouts tend to come out of it more coherently than the plain text route.

What you plug in

The node's job is producing conditioning, and its inputs are all things the T8 loader gives you:

• clip - the CLIP output from T8LLaDAImageCheckpointLoader. This is the only thing that can drive the LLaDA2 + SigVQ machinery; a stock text encoder will error out.
• prompt - your text, natural language.
• negative_prompt - defaults to empty and sits behind an "advanced" toggle. With the semantic features riding on the positive side only, the negative conditioning is just your negative text, so it earns its keep mainly on Base (CFG 5), where CFG has a real unconditional pass to work against.
• width / height - both default to 1024, step by 16, spanning 64 to 16384.

Outputs are positive and negative CONDITIONING, wired into a CFGGuider. The blank diffusion latent comes from an EmptyFlux2LatentImage at the same dimensions - this node doesn't emit a latent, so don't go looking for one.

Under the hood, so the slowness stops surprising you

The VQ stage is more than a text encode. The node tokenizes your prompt, reserves room for the image token grid, loads the text-encoder model onto the GPU with a memory estimate sized for that full context, then runs LLaDA2 autoregressively - token by token - with an internal CFG of 2.0 until it has produced exactly the number of image tokens the tokenizer reserves for that resolution. Those land in the SigVQ codebook, get embedded into semantic features, and only then does diffusion start.

That's why the README is so insistent: Turbo's "4 steps" covers only the diffusion phase. The LLaDA2 autoregressive decode before it is serial and comparatively slow. A Turbo VQ run still takes real time. It's the price of the "think first" stage, and the generation also validates as it goes - wrong token counts, out-of-codebook IDs, and non-16-divisible sizes all raise errors rather than quietly misbehaving.

Install and fit

Same pack as everything else: ComfyUI Manager → "LLaDA-Image T8", or clone T8mars/Comfyui-LLaDa-Image-T8 into custom_nodes, pip install -r requirements.txt, restart. Needs ComfyUI 0.34.0+.

Keep width and height as multiples of 16 - the node enforces it with a hard error, not a silent crop - and make them match your EmptyFlux2LatentImage. The workflow's own defaults (1024×1024) are the sensible place to start. And since the semantic stage is heavy, don't dial the resolution up and wonder why a "4-step Turbo" run crawls; it was never four seconds.