Krea 2 on a single RTX 4090 — quantizing a 12B image model with GGUF (Pop!

KERA2 title with a stacked model-layer diagram (LoRA, 12B DiT, Qwen3-VL encoder, VAE), an RTX 4090 badge, and the author's portrait — The stack in one picture: LoRA styles on top of a 12 B diffusion transformer, a Qwen3-VL text encoder and an image VAE — all fitting inside a single 24 GB card.

TL;DR

Krea 2 Turbo is a spectacular image artist that is not a typesetter. A 12 B diffusion transformer — ~26 GB in bf16 — does not fit a 24 GB 4090. Quantized to a Q6_K GGUF (~10.6 GB) it not only fits, it leaves headroom to stack LoRAs, and it renders a 1024×1024 image in 11–18 seconds at just 8 steps.

Across sixteen styles the photographic and painterly results are reference-grade — photoreal wildlife, pore-level portraits, oil-brush knights, 90s cel anime, a glass-and-chrome logo. The one hard wall is text: infographics and technical diagrams look beautiful but the words collapse into convincing gibberish. Generate the design here; add the words in an editor.

Everything below ran locally on a single RTX 4090 under Pop!_OS 22.04 — the quantization reasoning, the exact install path (including the one ComfyUI gotcha that cost me an afternoon), a full quality gallery with honest per-image verdicts, and a companion video.

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

“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.

Animated terminal showing the five install commands typing out in sequence, ending with the model loaded on the RTX 4090 — 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.

Close-up studio portrait of a weathered old fisherman — Portrait · realism-v2 @ 0.7 · **★★★★★ pore-level detail.**

A bowl of steaming ramen on a rainy Tokyo night with neon reflections — 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.

A cheerful flat-vector robot holding a potted plant — Flat-vector cartoon · no LoRA · **★★★★★**

A masked superhero cat leaping between rooftops, comic book style — Comic panel · no LoRA · **★★★★★ authentic halftone.**

A minimalist stick figure celebrating on a hill — 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.

A lone knight before a ruined cathedral, dark oil painting — Dark Brush LoRA · **★★★★★ moody chiaroscuro.**

A girl in a school uniform gazing out a train window, 90s anime — Retro Anime LoRA · **★★★★★ nostalgic & precise.**

A mountain village with cherry blossoms, soft watercolor — Soft Watercolor LoRA · **★★★★★ delicate washes.**

The Moon tarot card with a wolf howling between two towers — Vintage Tarot LoRA · **★★★★½ authentic woodcut.**

A child's crayon drawing of a family, house, sun and dog — Kids’ Drawing LoRA · **★★★★★ charmingly naive.**

Two simple cartoon characters at a bus stop, Cyanide and Happiness style — 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.

A glowing wireframe blueprint of a vintage motorcycle with callout labels — 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.

A flat software architecture diagram with labelled boxes and arrows, some labels garbled — 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.”

An infographic titled The Benefits of Drinking Water, with charts and gibberish body text — 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.

Watch it run. I put the full 16-style tour, the synced install animation, and honest per-image commentary into a short video: Run a 12B AI Image Model 100% local on one RTX 4090.

References & links

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
Companion video — youtu.be/ei97_pgrfYo
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.