Krea 2 on a single RTX 4090: quantizing a 12B image model with GGUF

Krea 2 Turbo is a 12-billion-parameter diffusion transformer that normally lives in the cloud. I quantized it to a Q6_K GGUF, wired it into ComfyUI on Pop!_OS, and ran it entirely on one 24 GB RTX 4090 — then pushed it across sixteen very different styles. The result is a model that is astonishing at art and photography, and honestly limited the moment it has to spell.

Krea 2 Turbo · Field Notes · July 2026

A 12B model that shouldn’t fit — and does

Krea 2 is a 12-billion-parameter diffusion transformer. In native bf16 the transformer alone is about 26 GB, and once you add the Qwen3-VL text encoder (~9 GB) and the VAE, a naive load needs well over 35 GB. A 24 GB RTX 4090 simply cannot hold that — the copy-paste diffusers snippet OOMs before it finishes loading.

The fix is quantization. Instead of storing every weight in 16 bits, a GGUF quant packs the diffusion transformer into a mixed 6-bit format. The community Q6_K build lands at ~10.6 GB — visually indistinguishable from the full-precision model, but small enough that the DiT, a fp8 text encoder (~5 GB) and the VAE all coexist on the card with room to spare.

Why Q6_K and not the smallest quant? LoRAs are the point of this model, and stacking a LoRA on a GGUF unet briefly de-quantizes the patched layers — so you want headroom, not the absolute floor. Q6_K (~10.6 GB) is near-lossless and still leaves ~4 GB free for LoRA patching. Q8_0 (13.7 GB) is even cleaner if you only run a single LoRA; Q4_K_M (7.5 GB) is the budget pick.

Here is the whole stack, and what each layer costs on the GPU:

• the resident stack on a 24 GB RTX 4090

• LoRA styles …………. patched onto the DiT (a few hundred MB each)
• Krea 2 · 12B DiT (Q6_K) .. ~10.6 GB ← the quantized transformer
• Qwen3-VL text encoder … ~5.0 GB (fp8)
• Image VAE …………… ~0.25 GB

• ~16 GB resident + activations → fits, with LoRA headroom

the whole stack, and what each layer costs on the GPU:

“Turbo” is the other half of the trick. Krea distilled the sampler so the model produces a finished image in 8 steps at CFG 1.0 — not the 30+ steps a base diffusion model needs. On the 4090 that is the difference between a five-second wait and a one-minute one.

Installing it on Pop!_OS + one RTX 4090

My box is Pop!_OS 22.04 (Ubuntu-based), CUDA 13, one RTX 4090. The runtime is ComfyUI with the ComfyUI-GGUF loader. There is exactly one non-obvious catch, so let me put it up front:

The gotcha that cost me an afternoon. Krea 2 shipped in June 2026 and its text encoder is Qwen3-VL with a bespoke krea2 CLIP type. Any ComfyUI older than that release does not have that type — you will get a cryptic CLIPLoader error. The fix is not to fight it: run Krea 2 from a fresh, isolated ComfyUI on latest master, and leave your main install untouched.

The five steps. First, pull the quantized weights straight into the models folder (this is the only large download — ~10.6 GB):

# 1. the Q6_K GGUF weights (DiT)
hf download vantagewithai/Krea-2-Turbo-GGUF \
    krea2_turbo-Q6_K.gguf --local-dir /d/ComfyUI/models/unet

# ...and the ComfyUI companions: fp8 Qwen3-VL encoder + VAE + official LoRAs
hf download Comfy-Org/Krea-2 \
    text_encoders/qwen3vl_4b_fp8_scaled.safetensors --local-dir /d/ComfyUI/models/text_encoders
hf download Comfy-Org/Krea-2 vae/qwen_image_vae.safetensors --local-dir /d/ComfyUI/models/vae

Second, clone a fresh ComfyUI (latest master, which knows the krea2 encoder) and its nodes:

# 2. isolated ComfyUI + the GGUF loader + the Power LoRA loader
git clone https://github.com/comfyanonymous/ComfyUI ComfyUI-krea2
cd ComfyUI-krea2/custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF
git clone https://github.com/rgthree/rgthree-comfy
cd ..

Third, symlink the shared models cache so nothing is duplicated on disk:

# 3. reuse the models you already downloaded — zero duplication
ln -s /d/ComfyUI/models  /d/ComfyUI-krea2/models

Fourth, build an isolated Python environment with the PyTorch the card actually wants. On this machine that is torch 2.9.1 for CUDA 13. (A subtle trap: uv’s --torch-backend shortcut capped at cu129, so install torch from the cu130 index URL directly — and pin torchaudio to the same version or ComfyUI fails to import with an ABI error.)

# 4. venv + matching CUDA torch (Pop!_OS, driver 580, CUDA 13)
uv venv --python 3.12 .venv && source .venv/bin/activate
uv pip install torch==2.9.1 torchvision torchaudio \
    --index-url https://download.pytorch.org/whl/cu130
uv pip install -r requirements.txt gguf

Fifth, launch it — the quantized model streams onto the GPU and you are ready to generate:

# 5. launch on its own port; main ComfyUI stays untouched
python main.py --port 8288
# -> Krea 2 Turbo (Q6_K) loads on the RTX 4090, ready on :8288

Sampler settings that matter. Krea 2 Turbo wants 8 steps, CFG 1.0, sampler er_sde, scheduler simple. Everything below was generated at exactly those settings, 1024×1024 (or the noted aspect), on the Q6_K unet with the fp8 Qwen3-VL encoder.

The five-command install, start to finish — pull weights, clone ComfyUI, symlink models, build the CUDA-13 venv, launch on :8288.

Flagship: photorealism & portraits

Start where the model is strongest. With no LoRA at all, base Krea 2 produces photography that genuinely passes for a camera. Note the visible breath in the cold air, the golden rim-light on individual strands of fur, and the natural fall-off behind the subject.

“A red fox in fresh snow at golden hour, breath visible” · no LoRA · 8 steps, er_sde · Verdict: ★★★★★ reference-grade.

Faces are the real test, and the realism-v2 LoRA at a gentle 0.7 strength delivers pore-level skin, correct catchlights, and a believable 85 mm depth of field. Push the same LoRA to 0.9 for the ramen scene and the atmosphere is superb — but look closely at the neon signs and you get the first hint of the text problem we’ll return to.

Portrait · realism-v2 @ 0.7 · ★★★★★ pore-level detail.

Tokyo ramen · realism-v2 @ 0.9 · ★★★★½ gorgeous — neon text garbled.

Stylized, with zero LoRA

Big models love to over-render; a good one knows when to stop. Purely from prompt engineering — no LoRA — Krea 2 switches cleanly between a flat-vector mascot, an inked comic panel with real halftone shading, a minimalist stick figure, and a glass-and-chrome product logo. That last one is a genuine hero asset you would normally commission from a 3D artist.

Flat-vector cartoon · no LoRA · ★★★★★

Comic panel · no LoRA · ★★★★★ authentic halftone.

xkcd-style stick figure · no LoRA · ★★★★★ perfectly restrained.

3D glass logo · no LoRA · ★★★★★ product-render quality.

Style LoRAs: instant aesthetics

This is where the model becomes an instrument. A ~200–500 MB LoRA, loaded on top of the quantized unet, redirects the entire aesthetic from one keyword. Dark expressive oil brushwork, 1990s cel anime, soft watercolour washes, a Rider-Waite tarot woodcut, a child’s crayon drawing, and a dead-on Cyanide & Happiness webcomic — each one is a different LoRA, same base model, same 8 steps.

Dark Brush LoRA · ★★★★★ moody chiaroscuro.

Retro Anime LoRA · ★★★★★ nostalgic & precise.

Soft Watercolor LoRA · ★★★★★ delicate washes.

Vintage Tarot LoRA · ★★★★½ authentic woodcut.

Kids’ Drawing LoRA · ★★★★★ charmingly naive.

Cyanide & Happiness LoRA · ★★★★★ spot-on match.

The headroom paid off. Every image above was a LoRA patched onto the Q6_K unet with no OOM and no offloading — exactly the reason to choose Q6_K over a bigger quant. The DeverStyle and RudySen community LoRAs and the official Krea style LoRAs all load through the same rgthree Power-LoRA node.

Where it breaks: text, infographics, diagrams

Now the honest part. Ask Krea 2 for anything whose value is the words and the seams show. The layouts are gorgeous — and the model even spells the title correctly — but the body text is invented.

Blueprint Wireframe LoRA · the look is a five; the callout labels are pure invented words. Style ★★★★★, readable info ★★.

A software architecture diagram pushes it further. The structure is genuinely impressive — labelled boxes, directional arrows, grouped layers, even a database icon — and some labels (users to CDN, load balancer, Redis) come out perfectly. But others degrade into near-words like Aqa Datadase.

Web-app architecture · no LoRA · ★★★½ structure yes, labels half-right.

And the clearest limit of all — the infographic. As a visual layout it is fantastic: a clean title, icons, pie and bar charts, bold percentage numbers, all beautifully arranged. Start reading the body copy and it collapses into gibberish, and every section heading just repeats the word “Hydration.”

Infographic · no LoRA · ★★★ looks right, reads wrong.

The one rule to remember. Krea 2 is a spectacular image artist, not a typesetter. For anything that depends on real words — infographics, diagrams, UI mockups — generate the design here, then set the actual text in a real editor. Do not ship the model’s lettering.

Verdict

A 12-billion-parameter image model, quantized to 10.6 GB, running fully local on one consumer GPU at eight steps, with community LoRAs snapping the style around at will — and no cloud, no API, no per-image bill. For photography, illustration, painting and stylised art it is astonishing. For anything with real text, treat it as a layout artist and finish the words yourself. Knowing which half of the model to lean on is the whole skill.

References & links

• Run on a single NVIDIA RTX 4090 (24 GB) under Pop!_OS 22.04 · Q6_K GGUF · Qwen3-VL fp8 encoder · er_sde, 8 steps, CFG 1.0 · thumbnail by Nano Banana Pro.
• Krea 2 Turbo (base model) — huggingface.co/krea/Krea-2-Turbo
• Q6_K GGUF quant — vantagewithai/Krea-2-Turbo-GGUF
• ComfyUI bundle (fp8 Qwen3-VL encoder + VAE + official style LoRAs) — Comfy-Org/Krea-2
• LoRAs used — RudySen/Krea2-realism-V2 · DeverStyle/Krea-2-Premium-Loras · krea/Krea-2-LoRA-darkbrush
• Runtime — ComfyUI · ComfyUI-GGUF (city96) · rgthree-comfy