Krea2 SVDQuant LoRA Loader

The short version

If you've got a Krea 2 SVDQuant checkpoint and a LoRA you want on top of it, don't use the stock LoraLoaderModelOnly. It patches the weight as weight += down @ up - and on these models .weight is a QuantizedTensor. So the stock loader has to dequantize the 4-bit weight, add the LoRA delta, then requantize the whole thing back to 4 bits. The low-rank branch's entire point - keeping the 4-bit weight untouched - is gone, and your carefully-trained LoRA just got quantized to 4 bits along with the weight.

This node instead attaches the LoRA as a parallel low-rank branch, using (W + BA)x == Wx + B(Ax). Mathematically identical for a linear layer, but the quantized weight is never dequantized and the LoRA delta stays at full precision. That's the whole pitch: same output, no requantization damage.

The inputs that matter

• model - output of the Krea2 SVDQuant W4A4 Loader, or any Krea 2 checkpoint with convrot_w4a4 quantized blocks.
• lora_name - a Krea 2 LoRA from models/loras/. It'll accept keys under either the diffusion_model.blocks.N.attn... prefix or the diffusers-style transformer.blocks.N... prefix, and anything it carries outside the quantized blocks (like txtfusion) goes through ComfyUI's normal path.
• strength - default 1.0, range -10 to 10. Zero passes the model through untouched; negatives invert the LoRA. Chain multiple of these nodes to stack LoRAs - the whole stack is rebuilt each time, so changing one strength doesn't corrupt the others.
• adapters - bypass (exact, slower) | svd delta (fast...) | bake into the weight (fast, requantizes the delta). This only affects LoRAs that can't fold into the low-rank branch - LoKr, LoHa, OFT - because a plain up/down LoRA is free in every mode. bypass computes the adapter every forward without touching the 4-bit weight (exact, costs ~0.5s/step for a LoKr). svd delta decomposes it into low-rank factors for zero per-step overhead. bake rewrites the weight once - fast, but the delta gets 4-bit quantized. Occasional LoKr, quality first: bypass. Swapping LoKrs constantly: bake.

Output: a single model output with the LoRA attached as a parallel branch. Wire it to your KSampler.

How to install

Same pack as the rest of the set:

cd ComfyUI/custom_nodes && git clone https://github.com/alperktt/Krea-2-SVDQuant-ComfyUI krea-2-svdquant

No Python dependencies; it leans on ComfyUI's own LoRA parsing (comfy.lora.load_lora), which already knows every format and naming convention ComfyUI supports. Restart and you're done.

Gotchas worth knowing

• A LoRA that matches no quantized layer is an error on purpose. This loader hard-fails where the stock loader silently applies nothing - which is how a badly-prefixed LoRA can look like it "works" on the stock path when it's actually a silent no-op. Both prefixes are accepted now, so a normal Krea 2 LoRA just loads.
• The branch is an object patch. Two LoRA loader nodes on the same checkpoint loader don't contaminate each other, and nothing survives past the sampling run.
• Rank matters more with LoRAs. The pack's own benchmarks found branch rank is basically a coin-flip with no LoRA loaded, but with a LoRA on top, rank 256 clearly beats rank 64. If you know you'll be stacking LoRAs, reach for the rank-256 checkpoint.
• The cu130 requirement applies here too. The fast kernel only lives on CUDA-13+ torch builds; below that everything falls back to a slower path. Check torch.version.cuda before blaming your LoRA.