Model (TurboQuant Attention)

Here's the honest summary before you get excited: this node clones your model and installs an approximate attention implementation inspired by the TurboQuant paper - random orthogonal rotation of q/k/v plus coordinate-wise scalar quantization. It is not KV-cache compression, it is not a memory-savings hack that fell out of an LLM inference engine, and the defaults are deliberately conservative because aggressive settings can damage image quality and run slower than baseline. If that still sounds interesting, read on.

It's an experiment, and the pack is upfront about that. The idea is the same one TurboQuant used to make attention cheaper in LLM serving: rotate the key/query space with a random orthogonal matrix (which makes the values spread more evenly), then quantize to fewer bits per coordinate, trading a little accuracy for speed or memory. In ComfyUI this is done as an attention override you slot between your model loader and a normal KSampler - no core patching, no special sampler.

How it works

At runtime the node rotates q, k, and v, quantizes k (and optionally v), then passes the transformed tensors back into ComfyUI's original optimized attention kernel. That last bit matters: it deliberately avoids materializing dense logits in Python, which is what made earlier prototypes OOM on diffusion-sized layers. The QJL residual-correction stage exists in the config but is forced off in the runtime path for the same reason. Guards (min_token_product/max_token_product, memory_margin_mb, max_head_dim) decide which attention calls actually get patched - most won't, which is by design.

The inputs that matter

You're not going to touch most of these, and that's fine. The ones that matter:

• bits - bits per coordinate (1–8, default 8). Lower is more aggressive and more dangerous.
• quantize_values - keep disable. Quantizing values as well as keys is the fastest route to wrecked output.
• attention_scope - self is the usual target for diffusion latent attention.
• log_every - set to 1 (and log_fallbacks to enable) to actually see whether your attention calls are being patched at all.

Output is a MODEL you feed into a KSampler.

Installing it

Part of the Skoogeer-Noise pack. Manager → search "Skoogeer-Noise", or:

cd ComfyUI/custom_nodes
git clone https://github.com/ttulttul/Skoogeer-Noise

Restart ComfyUI. Only torch, numpy>=1.26, einops, pyyaml>=6.0.3 - no model downloads.

Common gotchas

The biggest one is expectations. People hear "TurboQuant" and expect LLM-serving-style speedups and VRAM savings; this is an attention approximation for diffusion, with quality tradeoffs baked in. If output looks subtly off and you can't tell why, the patch is probably active and degrading things. If nothing changes at all, that's also likely - the token-product thresholds skip most layers. Use the logging knobs to find out which. And treat bits <= 4 as "here there be dragons": the changelog itself warns these settings can be slower than baseline while also hurting quality. This is a tinkerer's node, not a daily-driver.