Ciru AMD Halo Qwen 2.1 Turbo

The pitch in one line

The Qwen-Image family is the heavy one. It renders text and eats LoRAs better than anything smaller, and every thread about running it locally lands on the same phrase: "absolute VRAM hog." So paying for 12 denoiser passes instead of 30 isn't a small win - it's the difference between iterating and going to make coffee.

That's this node. Wire it between your Qwen Image 2.1 loader and your sampler, leave full_evaluations at 12, and 18 of your 30 steps stop calling the model. The author's measured run on a Radeon 8060S: 74 s at 30/30 versus 34.6 s at 12/30 for the same 1024 image, and 420 s down to 173 s at 2048.

Ignore "AMD Halo" in the display name. It's not a hardware requirement and it calls no API - prediction is portable; only the attention kernel is tied to Strix Halo.

How it gets away with skipping steps

Not distillation - your weights are untouched. This is an inference-time wrapper, the same family as TeaCache, EasyCache and TaylorSeer, which the README credits by name.

The mechanism, from the source: the node patches into the sampling pass and counts steps off the sigma array, carrying a fixed schedule of steps that run the real denoiser - for 30 steps, 12 entries, weighted early while the image is still forming. On those it stashes the residual: output minus input, in float. Two of those give you a slope. In between, it extrapolates the last residual forward and adds it to the latent instead of asking the model.

First-order Taylor expansion on a denoiser trajectory. Every sampler step still executes - "skipping steps" doesn't mean your step count changes. Raise full_evaluations and the schedule refines by splitting its widest gaps, so you never lose an evaluation you already had; set it equal to your step count and prediction is off entirely, which is your clean A/B against stock.

The controls that matter

model is the wire and enabled is a bypass. full_evaluations is the real knob: default 12, minimum 6, the author's sweet spot. Lower is faster and leans harder on prediction, which can soften fine detail or change the image; higher runs the full denoiser more often. For image edits, set it equal to the sampler step count - that's the supported path.

attention has three options and the default is the right one. auto leaves ComfyUI's native attention alone and swaps in the pack's Triton kernel only for the shape it was measured on: 2048-square Qwen images on gfx1151, meaning 16,384-token queries, 32 heads, bf16, batch one. native never touches attention. strix forces the kernel and errors if you're not on gfx1151 with working Triton - the author is blunt that it can be slower at smaller sizes, so use it at 1024 only to compare. Pick native when stacking another attention extension; auto defers to an existing override rather than fighting it.

allow_edit_prediction is off by default and stays off until you've run a full-evaluation edit. There's one output, MODEL, straight into your KSampler:

UNETLoader → QwenImage21Cache → Ciru AMD Halo Qwen 2.1 Turbo → KSampler

Start with Euler, simple scheduler, CFG 1, 30 steps - Qwen is a guidance-distilled flow-matching model, so CFG 1 means guidance is baked into the weights, not switched off. Prompt with TextEncodeQwenImage21. For edits, open the 1024 edit template from Templates → Extensions and refer to your source as <image1>.

Installing it

No pip step: pyproject.toml declares zero dependencies, and nothing installs at runtime.

cd /path/to/ComfyUI/custom_nodes
git clone https://github.com/ciru-ai/ComfyUI-CiruImageAccelerator.git
# restart ComfyUI, then reload the browser

ComfyUI Manager search is "Ciru AMD Halo Qwen 2.1 Turbo"; the CLI (comfy node install ciru-image-accelerator) and a ZIP extract also work.

The node ships no weights - it drives the INT8 ConvRot denoiser and encoder plus the BF16 VAE from Comfy-Org/Qwen-Image-2.1, in models/diffusion_models, models/text_encoders and models/vae. You need a ComfyUI recent enough to have TextEncodeQwenImage21 and QwenImage21Cache; if those are missing from your dropdown, that's a stale ComfyUI, not this pack.

The pack ships tools/doctor.py. Run it with the same interpreter that launches ComfyUI to check your GPU, torch/HIP/Triton versions and the three expected model files.

/path/to/comfy-python /path/to/ComfyUI/custom_nodes/ComfyUI-CiruImageAccelerator/tools/doctor.py

Where people get burned

The node is strict and fails loudly on purpose: it refuses anything that isn't a Qwen Image 2.1 model, blocks EasyCache (both hook the same denoiser calls), allows one instance per model, only batch size one, and needs at least 20 sampler steps.

• Editing with prediction on. Feed it reference images with full_evaluations below your step count and it throws. Deliberate - pass allow_edit_prediction to try the experimental path, then judge source fidelity yourself.
• A custom sampler. The predictor expects exactly one model call per step; a sampler that calls it twice gets a "more model calls than sampler steps" error. Euler/simple is the qualified path.
• Not on gfx1151 and expecting a speedup. Prediction runs on other hardware for text-to-image, but the pack only validated speed and quality on a Radeon 8060S with ROCm. CUDA is explicitly unqualified, and strix errors outright.

Prediction changes your output. It's fast, it's deterministic, and it isn't free. Find your seed at 12, then rerun it at 30/30 if it's going anywhere.