Kroma-v0.2-INT8-ConvRot

Kroma v0.2 — INT8 ConvRot Quantizations

INT8 ConvRot quantized weights for lodestones/Kroma v0.2, ready for fast, low-VRAM inference in ComfyUI. Two variants:

Both files are produced from the BF16 originals using silveroxides/convert_to_quant with the --scaling_mode row flag enabled (mandatory for ConvRot compatibility — see Conversion below).

What's inside

• 224 weight tensors quantized to INT8 (1 byte / weight) with per-row scaling
• 40 tensors kept in BF16 via the --krea2 architecture profile (sensitive layers: first, last, tmlp, txtfusion, last.modulation, tpro)
• 878 final tensors in the safetensors file

Per-layer quantization metadata is embedded in the .comfy_quant JSON tensor:

{"format": "int8_tensorwise", "orig_dtype": "torch.bfloat16",
 "convrot": true, "convrot_groupsize": 256, "per_row": true}

weight_scale tensors have shape (N, 1) (per output channel), not () (scalar) — this is what makes LoRAs work correctly when applied at runtime.

Requirements

• ComfyUI ≥ 0.27.0 (native INT8 ConvRot support)
• NVIDIA GPU with INT8 tensor cores:
  • RTX 30-series, RTX 40-series, RTX 50-series (Ampere, Ada, Blackwell)
  • Tested on RTX 3090 (24 GB VRAM)
• Optional: ComfyUI-INT8-Fast (Bob Johnson) for explicit LoRA-mode control
• Companion files (not in this repo, download separately):
  • Text encoder: qwen3vl_4b_fp8_scaled.safetensors → ComfyUI/models/text_encoders/ (from Comfy-Org/Qwen3-VL)
  • VAE: qwen_image_vae.safetensors → ComfyUI/models/vae/ (from Comfy-Org/Qwen-Image_ComfyUI)

Usage in ComfyUI

Drop the .safetensors files into ComfyUI/models/diffusion_models/ and use the standard Load Diffusion Model node (or OTUNetLoaderW8A8 from ComfyUI-INT8-Fast for explicit LoRA-mode control):

# Standard native loader (ComfyUI ≥ 0.27.0) — just select the file
# No special nodes, no extra modes

Recommended sampler settings:

• Turbo: 8 steps, CFG 1.0, euler / simple, shift 1.15 (model default)
• Base: ~52 steps, CFG ~3.5, euler / simple

With LoRAs: set the Load LoRA INT8 lora_mode to Stochastic (not None) for the best quality. The None mode uses normal round-to-nearest which loses ~10-20% of the LoRA effect.

Compatibility with the standard Krea2 Turbo LoRA

The official Krea 2 Turbo distillation LoRA (krea2_turbo_lora_rank_64_bf16.safetensors) is bundled in this repo at loras/krea2_turbo_lora_rank_64_bf16.safetensors (447.7 MB, rank 64, BF16). Matches 535/535 Kroma layer targets after stripping the diffusion_model. prefix — works directly on the quantized models in this repo.

Upstream source: Comfy-Org/Krea-2/loras/ (uploaded by Kijai, verified commit 67751d8). Bundled here for convenience so the whole pipeline (Base + INT8 + LoRA) loads from one source.

How to use:

1. Drop the LoRA from loras/ into ComfyUI/models/loras/
2. Load krea2_kroma-v0.2-base-int8_convrot.safetensors (or the BF16 original)
3. Apply the LoRA via Load LoRA (native ComfyUI) or Load LoRA INT8 with lora_mode: Stochastic (recommended for INT8 ConvRot)
4. Generate with turbo settings: 8 steps, CFG 1.0, shift 1.15, euler/simple

Conversion

The files were produced with silveroxides/convert_to_quant (ctq CLI). The crucial flag is --scaling_mode row — without it, the resulting file has tensorwise (scalar) scales and missing convrot/per_row metadata, which makes LoRAs fail at runtime.

Working full command:

ctq -i krea2_kroma-v0.2-base.safetensors \
    -o krea2_kroma-v0.2-base-int8_convrot.safetensors \
    --int8 --convrot --convrot-group-size 256 \
    --scaling_mode row \
    --comfy_quant --save-quant-metadata --krea2 \
    --simple --low-memory --device cuda

(Same command for the turbo variant, just swap the filenames.)

Setup

python -m venv venv-ctq
venv-ctq\Scripts\python.exe -m pip install -U pip wheel
venv-ctq\Scripts\python.exe -m pip install \
    torch==2.11.0+cu128 \
    --index-url https://download.pytorch.org/whl/cu128
venv-ctq\Scripts\python.exe -m pip install \
    triton-windows convert-to-quant safetensors tqdm click rich pyyaml scipy

Requirements:

• Python 3.12+ (tested on 3.13.7)
• PyTorch 2.11+ with CUDA 12.8 or 13.0 wheels
• triton-windows on Windows, triton on Linux
• ~64 GB free RAM for the 47 GB base model
• GPU with ~3 GB free VRAM (the quantization itself is memory-bandwidth-bound, not compute-bound)

Conversion takes ~5 minutes for the turbo (24 GB source) and ~8 minutes for the base (48 GB source) on a stock RTX 3090.

Verifying your output

from safetensors import safe_open
import json

with safe_open("krea2_kroma-v0.2-base-int8_convrot.safetensors", framework="pt") as f:
    k = [k for k in f.keys() if "blocks.0.attn.gate.comfy_quant" in k][0]
    raw = f.get_tensor(k).tolist()
    parsed = json.loads(bytes(raw))
    print(parsed)
    # Expected: {"format": "int8_tensorwise", "orig_dtype": "torch.bfloat16",
    #            "convrot": True, "convrot_groupsize": 256, "per_row": True}

If you get {"format": "int8_tensorwise", "orig_dtype": "torch.bfloat16"} without the three ConvRot keys, you forgot --scaling_mode row — the file will load but LoRAs will not work as expected.

License

These quantized weights are derivative works of lodestones/Kroma, which is governed by the krea-2-community-license (see the upstream repo). This license does not grant rights to the underlying Krea 2 base weights. By downloading these files you agree to abide by the upstream license terms.

Provenance

• Upstream base model: lodestones/Kroma (Kroma 0.2 — a Krea 2 style fine-tune)
• Quantization tool: silveroxides/convert_to_quant
• Quantization date: 2026-08-09