lvladikov/Krea2-Turbo-Distill-4step-LoRA

Krea 2 Turbo — 4-Step Distillation LoRA

Half the steps · ~1.6× faster · 45% of the gap to the 8-step teacher closed · texture at 1.03× the teacher's, verified clean · the teacher preferred on only 6 of 45 judged renders · 12 trained resolutions · 78,000 training samples on 13,750 teacher trajectories and 43,044 real-photo crops · 21 days on one RTX 3090.

A LoRA for Krea 2 Turbo that reduces the minimum usable step count from 8 to 4 — Turbo's own model and sigmas, half the denoising passes, and the fine texture that 4-step Turbo loses put back.

• ⚡ Half the steps — 8 → 4, on Turbo's own deployment sigmas.
• ⏱️ ~1.6× faster end to end — 54.5 s against the 8-step bar's 88.7 s at 1024×1024, and 1.8× on denoise alone.
• 🎯 Texture as good as the teacher or better — 1.03× the teacher's fine-texture energy at 1280×1280 and 1440×1440, every frequency band within 10% of the teacher's; verified clean: saturation 0.96–0.97× the teacher's, fewer clipped highlights and shadows, skin texture 0.97–0.99×.
• 📏 45% of the 4-step gap closed — the held-out velocity error to the 8-step teacher fell from 4.70e-02 (stock Turbo at 4 steps) to 2.59e-02 with the LoRA; a vision-language judge shown the teacher's and the LoRA's renders side by side preferred the teacher on only 6 of 45 (37 ties, 2 wins for the LoRA).
• 🗣️ Prompt-aware training — the critic scores images against their prompts during training, so adherence is pressured directly, not inherited.
• 📐 12 trained resolutions — multi-aspect from 512×512 up to 1440×1440, each with its sweep.
• 🔌 Drop-in — plain LoRA weights for diffusers and ComfyUI. No custom nodes, no patched sampler, no code.
• 🎲 13,750 prompts drawn at random from Lakonik's 3-million-prompt dataset, each recorded by the teacher as a full 8-step trajectory at one of the 12 resolutions — 13,750 teacher shards.
• 📷 43,044 real-photo crops — 25,560 from LSDIR and 17,484 from Flickr2K — cut at native resolution and captioned, in the critic's real set: texture anchored to reality as well as to the teacher.
• 🔢 78,000 training samples in the shipped weights.
• 📅 21 days from the first training launch to the final file, on a single RTX 3090.
• 🔁 16 recipe adjustments

Load it on top of Krea 2 Turbo, run 4 steps instead of 8, keep guidance at 0.0. Everything else about the model stays as it is.

💡 Too strong on a prompt? Turn it down. The LoRA restores fine texture, and on some subjects — stylised art, high-contrast splash pieces, very large renders — that can read as too much at strength 1.0. The effect scales smoothly with strength, so 0.75 is a good second setting, and anything from 0.6 to 0.9 is fair game; you lose nothing but the extra bite. See LoRA strength.

All of the above were created with this LoRA at 4 steps: the 15 test prompts, Krea 2 Turbo + the LoRA, seed 4242, each at one of its trained resolutions. Click for full size. The side-by-side comparisons with the 8-step teacher are in Examples.

Files

file	what it is
krea2_turbo_4step_rank_64_lora.safetensors	the LoRA in diffusers key format — see Inference with diffusers; also for MLX or anything that reads safetensors
krea2_turbo_4step_rank_64_lora_comfyui.safetensors	the same weights under ComfyUI's key names — see ComfyUI
krea2_turbo_4step_lora_t2i.json	a ready ComfyUI workflow, stock nodes only
LICENSE.pdf	the Krea 2 Community License Agreement, which covers this adapter — see License
NOTICE.txt	the attribution notice the license requires of a derivative

The two weight files are one adapter — only the key names differ. Both carry the training details in their safetensors metadata: base model, method, sample count and the inference settings.

How I got here

This was not a "train for longer and ship whatever comes out last" project. More samples do not reliably mean a better adapter — measured here, they can make it worse, and a higher sample count on its own means nothing.

The loop was train → assess → adjust the recipe → carry on → assess again — carrying on from the weights in hand when they were worth keeping, and from an earlier point when they were not. What ships is the point of the run that measurably advanced the release axes as a whole — teacher faithfulness, prompt adherence, and texture/detail, on the same held-out set and the same fixed-seed renders — with a full resolution sweep showing no regression. Stretches that came out flat or worse were kept as information about the recipe and never shipped; there were several.

The recipe therefore grew over the run rather than being fixed at the start. In broad strokes: the early stretch settled the optimiser schedule (cosine decay with weight decay) after a first attempt that got steadily worse; the next added the final-call loss weighting and the running average of the weights that the shipped adapter is, and established that a run left going past its peak measures worse — so the shipping point is chosen by measurement, not by distance run. A much larger trajectory pool then pushed the single number the project optimised at the time — the velocity gap to the teacher — to its best value, and exposed that number's limit: past a point, chasing it further trades away exactly the texture a step-distillation exists to restore. The recipe from then on judged all three axes at once and added a measured dose of real-image texture pressure and a prompt-aware critic (the discriminator saw images with their prompts and punished mismatches). The long final stretch of the run continued on that recipe, with the critic's weight tuned once texture had settled where it was wanted.

The sixteen recipe adjustments, in order — each one made on the measurement of the one before:

1. progressive distillation replaced the policy-head objective the project started with
2. cosine learning-rate decay with weight decay
3. the shipped weights became a running (EMA) average instead of the live state
4. the final chord — the call that decides fine texture — weighted 3× in the loss
5. resumable state, warmup and a plateau rule, so a run could pause and continue without a cold restart
6. the LADD-style critic on the frozen model's own block-14 features, teacher finals as its real class
7. real photographs entered the critic's real set, half the draws
8. the critic's weight rebalanced against the distillation term
9. the prompt-aware critic head with its mismatch term, on a fresh pool of teacher trajectories
10. 1440×1440 joined the training mix
11. the real photographs got captions, so they took part in the prompt-aware term too
12. a low-frequency anchor to the teacher's chord on the large buckets, restarting from the averaged weights
13. the critic's weight lowered once texture had settled
14. a paired critic: the teacher's final for the same prompt as the real
15. the paired critic plus a hard low-frequency floor on every bucket
16. back to the recipe before 14 and 15, once both were measured as unnecessary

Timeline of training process

The adapter was the product of several stages with very different costs:

1. Text-encoder embeddings. Every training prompt was encoded once and cached. This was the fast part — thousands of prompts took minutes.
2. Teacher shards. For each cached prompt, the unmodified Krea 2 Turbo ran its full 8-step schedule and the whole trajectory was recorded, each prompt at one of the supported resolutions so that every resolution was covered. This was by far the most time-consuming stage — it was the teacher doing real inference, thousands of times, and a batch of several thousand shards was measured in days of GPU time, not hours.
3. Real-photo crops. Bucket-sized crops were cut at native resolution from quality-gated real photo sources (public high-res datasets), VAE-encoded into the training latent space, and captioned per crop for the prompt-aware side of training. Cutting, encoding and captioning a pool refresh was a matter of hours.
4. Student training. The LoRA trained against the recorded trajectories (progressive distillation), with a latent-space GAN critic running alongside — real crops and teacher finals as its real class, the student's outputs as fake — plus a prompt-aware head that scored images against their prompts. Relative to the shard stage this was quick: each block of a thousand training samples was a matter of hours, not days. Of course the longer the training, the better and more diverse the results, so hours did turn into days.

Because these stages competed for the same GPU, they were interleaved rather than run to completion one after another: generate a block of embeddings, produce teacher shards for them, refresh the crop pool when measurement said it was worth it, train on what existed, assess, then go back to producing shards while the results were reviewed. A larger and more varied shard pool was what made further training worthwhile, so shard production was always the gate; the run took several such cycles.

Measured against the teacher

Everything below was measured on this LoRA against the official 8-step Krea 2 Turbo renders of the same prompts, same seed, at the three headline resolutions.

Texture and detail — at the teacher's level, tilted towards the fine end. Total fine-texture energy against the 8-step teacher (1.0 = teacher-like) came out at 1.03× at 1280×1280 and 1.03× at 1440×1440. The distribution is the more telling number: split into frequency bands, the adapter at 1280×1280 ran 0.92× / 0.98× / 1.01× low to high, and at 1440×1440 ran 0.90× / 1.00× / 1.06× — every band within about 10% of the teacher's, with the extra sitting in the finest band, where the teacher's own detail lives, rather than piled into one band as grain. Why not aim at exactly the teacher: the teacher is not ground truth — training also showed the critic real photographs, so the adapter learned detail density from reality as well as from an 8-step model that itself slightly under-renders fine texture. The teacher anchors structure; reality anchors texture.

Verified clean, not just measured. A texture pressure with no ceiling is exactly the kind of change that could show up as oversaturation, blown or crushed exposure, or damaged skin texture before it shows up as a useful gain — so the adapter was checked against the teacher on each of those, directly, at both 1280×1280 and 1440×1440: mean saturation 0.96–0.97× the teacher's (slightly less saturated, not more), blown highlights and crushed shadows both fewer than in the teacher's own frame, mean brightness within 1.5%, and skin texture inside detected face regions at 0.97–0.99× the teacher's with saturation 0.85–0.97× (less ruddy, not more). The one axis that reads above the teacher is fine-detail energy inside flat regions — skies, walls, out-of-focus backgrounds — at 1.33–1.37×: that is the texture pressure showing where the teacher renders smooth, and the resolution sweeps viewed at 1:1 are where to judge whether it reads as detail or as grain on the kind of image you make.

Prompt adherence. A pairwise vision-language judge, shown the teacher's and the LoRA's renders of the same prompt in both orders and asked which follows it better, called the LoRA's version a loss on 6 of the 45 judged renders across 512×512, 1280×1280 and 1440×1440 combined (four of the six at 512×512), a win on 2, and a tie on the remaining 37.

Teacher faithfulness. The held-out teacher-velocity metric stood at 2.59e-02 — about 45% of the 4-step deficit closed. Raw pixel distance to the teacher on the fixed-seed renders came out at 0.342 at 512×512, 0.332 at 1280×1280 and 0.328 at 1440×1440: a metric that treats the teacher's own pixels as the target will always read a model that deliberately carries more detail than the teacher as slightly "further away," even when the artefact checks above found the extra detail clean. The resolution sweeps and the Examples below are the way to judge that for yourself.

axis	this LoRA
texture energy vs teacher, 1280² / 1440²	1.03× / 1.03×
render distance to teacher, 512² / 1280² / 1440²	0.342 / 0.332 / 0.328
held-out velocity gap	2.59e-02 (45% closed)
VLM judge vs teacher, losses of 45	6 (2 wins, 37 ties)
saturation / exposure / skin vs teacher	checked — clean on all

This is not a Raw→Turbo diff

Other Krea 2 LoRAs in circulation are extractions: a low-rank projection of the weight difference between Krea 2 Raw and Krea 2 Turbo. Applied to Raw, they reproduce Turbo. They are a delivery mechanism for a model that already exists, and they stop at Turbo's 8 steps.

This one is different in both base and origin:

	Raw→Turbo extraction LoRAs	this LoRA
apply to	Krea 2 Raw	Krea 2 Turbo
produces	Turbo behaviour (8 steps)	4-step Turbo
origin	SVD of an existing weight delta	trained by distillation

It is trained, not extracted, and it assumes Turbo's weights underneath it — it shortens Turbo's own schedule rather than reproducing it.

Using it on Raw

This LoRA is trained on Krea 2 Turbo, against Turbo as its own teacher, and for Turbo. Every layer it targets also exists in Krea 2 Raw, so it will load there without complaint — but that is a side effect of the shared architecture, not a supported mode.

Results on Raw are mixed and subject-dependent. It does not give Raw a 4-step schedule: at very low step counts the adapter sharpens texture while composition is still unresolved, and subjects come out malformed — duplicated heads, fused limbs, faces that do not close. Expect to need 14 steps or more, keeping Raw's normal CFG on, before output is coherent. Even then some prompts come through well and others degrade into over-processed or blown-out images — and that degradation happens with or without the adapter, because it comes from shortening Raw's schedule rather than from the LoRA.

If you want the behaviour this was built for, run it on Turbo at 4 steps. If you are starting from Raw, move to Turbo first — with a Raw→Turbo LoRA or the Turbo weights directly — and apply this on top.

Usage

setting	value
base model	Krea 2 Turbo
LoRA scale	1.0
steps	4
guidance / CFG	0.0 (Turbo is CFG-free; do not enable it)
timestep shift	mu = 1.15, fixed (Turbo's deployment shift)

The 4 sampling sigmas are Turbo's own deployment grid: [1.0, 0.90453, 0.75951, 0.51284].

Inference with diffusers

Krea 2 Turbo has a native diffusers pipeline, Krea2Pipeline, in diffusers from source — the same setup as Krea's own model card. The LoRA loads through that pipeline's standard LoRA loader, with one line of preparation: diffusers expects a transformer. prefix on every key, and it does not read the per-module alpha entries this file carries (alpha equals the rank, so dropping them changes nothing — the scale stays 1.0). Why the file is laid out the way it is, and what each runtime expects, is in The keys, runtime by runtime.

pip install git+https://github.com/huggingface/diffusers.git

import torch
from diffusers import Krea2Pipeline
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file

pipe = Krea2Pipeline.from_pretrained("krea/Krea-2-Turbo", torch_dtype=torch.bfloat16).to("cuda")  # "mps" on Apple Silicon

lora = hf_hub_download("lvladikov/Krea2-Turbo-Distill-4step-LoRA", "krea2_turbo_4step_rank_64_lora.safetensors")
state = load_file(lora)
state = {f"transformer.{k}": v for k, v in state.items() if not k.endswith(".alpha")}
pipe.load_lora_weights(state, adapter_name="4step")

image = pipe("a fox in the snow", num_inference_steps=4, guidance_scale=0.0).images[0]
image.save("krea2_4step.png")

• num_inference_steps=4 is the whole configuration. The pipeline applies Turbo's fixed timestep shift (mu = 1.15) on its own and evaluates the model at σ = 1.0, 0.905, 0.760, 0.513 — exactly the four points in Usage that the LoRA was trained on. Keep guidance_scale=0.0.
• Strength: pipe.set_adapters(["4step"], adapter_weights=[0.75]). Stock Turbo is one call away for a side-by-side: pipe.unload_lora_weights() and num_inference_steps=8.
• Use the diffusers file, not the _comfyui one: diffusers' Krea 2 key converter reads Krea's reference-trainer naming, not ComfyUI's lora_down/lora_up.

ComfyUI

A pre-converted file (..._comfyui.safetensors) and a ready workflow sit in the repo root. No custom nodes — stock ComfyUI only.

file	put it in
krea2_turbo_4step_rank_64_lora_comfyui.safetensors	ComfyUI/models/loras/
krea2_turbo_bf16.safetensors — Comfy-Org/Krea-2	ComfyUI/models/diffusion_models/
qwen3vl_4b_bf16.safetensors — same repo	ComfyUI/models/text_encoders/
qwen_image_vae.safetensors — same repo	ComfyUI/models/vae/

Then load krea2_turbo_4step_lora_t2i.json.

The workflow is full bf16, with no quantisation anywhere. bf16 needs no backend-specific kernel, so it runs unchanged on CUDA, Apple Silicon and CPU — one workflow, no platform caveats, nothing that depends on which device a component happens to land on.

Smaller builds work too; both loaders accept any variant, just set the matching filename:

diffusion model	size	NVIDIA	Apple Silicon
krea2_turbo_bf16 (workflow default)	26.3 GB	✅	✅
krea2_turbo_int8_convrot	13.5 GB	✅	✅
krea2_turbo_fp8_scaled	13.1 GB	✅	❌

The text encoder ships as bf16 (8.9 GB) or fp8 (5.2 GB) only — there is no int8 text encoder, so a fully matched int8 pair is not possible.

The LoRA is independent of the base build. It is applied on top of the diffusion model by ComfyUI's own loader, which handles any dequantisation, so a quantised or otherwise optimised build of Krea 2 Turbo behaves just as bf16 does. Please use whichever variant suits your hardware — set it in the Load Diffusion Model node and leave the rest of the workflow untouched. The workflow ships bf16 simply because it is the one build guaranteed to run everywhere.

🍎 fp8_scaled does not work on Apple Silicon. MPS has no Float8_e4m3fn support, so the run dies at the sampler with "Trying to convert Float8_e4m3fn to the MPS backend but it does not have support for that dtype". That failure is the weight dtype, not the workflow or the LoRA — the graph executes fine right up to the sampler. The fp8 text encoder does run on MPS, but only because ComfyUI places it on CPU; the workflow does not rely on that.

📌 The _comfyui file carries the same weights as the diffusers file — only the key names differ.

Why a separate file. ComfyUI addresses the transformer by its own layer names, so the adapter needs a key remap: transformer_blocks.0.attn.to_q.lora_A becomes diffusion_model.blocks.0.attn.wq.lora_down. The tensors are bit-identical — nothing is requantised or rescaled, only renamed. The mapping was verified against Comfy-Org's own Krea 2 LoRA: all 456 tensors land on keys that file also uses, with matching shapes.

alpha keys are omitted, as in Comfy's own file. ComfyUI defaults alpha to the rank when absent, giving scale = alpha/rank = 1.0 — exactly what alpha 64 at rank 64 encodes.

Settings

steps	4
cfg	1.0
sampler / scheduler	euler / simple
LoRA strength	1.0

⚙️ cfg 1.0, not 0.0. ComfyUI expresses "no classifier-free guidance" as cfg 1.0, whereas diffusers expresses the same thing as guidance 0.0. They mean the same: one forward pass per step, no negative branch. Setting 0.0 in ComfyUI is not the same thing and will not give you Turbo's intended behaviour. That is also why the workflow's negative input is a ConditioningZeroOut — at cfg 1.0 it is never evaluated, so there is nothing to write in it.

To compare against stock Turbo, set steps back to 8 and bypass the LoRA node with Ctrl+B.

Performance — does it save time, or only steps?

It saves time. Measured at 1024×1024 on Apple Silicon (MLX, bf16), two prompts each, run strictly one at a time:

	load	denoise	total
Turbo 8 steps (the quality bar)	8.2 s	77.5 s	88.7 s
Turbo 4 steps, no LoRA	7.8 s	38.8 s	49.7 s
Turbo 4 steps + this LoRA	7.3 s	44.0 s	54.5 s

4 steps with the LoRA is ~1.6× faster than the 8-step bar — 54.5 s against 88.7 s, saving about 39% of the wall-clock. Counting denoise alone, where the step reduction actually applies, it is 1.8× (44.0 s against 77.5 s).

The adapter is not free, and its cost is in denoising rather than loading. Per step: 9.7 s without it, 11.0 s with it — about 13% slower per step, plus roughly 1.3 GB more peak memory (28.4 GB vs 27.1 GB). Loading the LoRA costs nothing measurable; the overhead scales with the number of steps you run, because the adapter's low-rank product is computed on every forward pass.

So the arithmetic is: each step costs 13% more, but you run half as many. Halving wins comfortably.

LoRA strength

Use 1.0. That is the value the adapter was trained at, and where its output sits closest to the 8-step reference.

💡 Too strong on a prompt? Turn it down. The LoRA restores fine texture, and on some subjects — stylised art, high-contrast splash pieces, very large renders — that can read as too much at strength 1.0. The effect scales smoothly with strength, so 0.75 is a good second setting, and anything from 0.6 to 0.9 is fair game; you lose nothing but the extra bite.

Strength is worth understanding rather than tuning blindly, because what it scales is specific: this LoRA's job is to restore the high-frequency detail that a 4-step schedule loses — fine texture, edge definition, surface micro-contrast. The strength dial scales exactly that correction, so it does not make the image "more" or "less" of anything semantic; it decides how hard the texture recovery is applied.

strength	what happens
below 1.0	the correction is only partly applied — output lands between an unassisted 4-step render and a full one. 0.75 is the setting to reach for when a prompt comes out too textured or too hard at 1.0; 0.6–0.9 trades recovered detail for restraint, smoothly
1.0	the trained point, and the recommended setting
1.0–1.5	extrapolation past training, but still coherent — surface detail grows denser than the subject warrants, fine structures turn wiry, micro-contrast hardens until the result reads as stylised rather than photographic. Usable if you want that look
above 1.5	not recommended. Past ~1.5 the correction stops being "heavy-handed but coherent" and breaks into a uniform speckle/noise texture over the whole image, faces included — not a style, an artifact

Up to 1.5 the failure mode is the adapter doing its one job too enthusiastically, and it arrives gradually. Past that, its correction is already strong enough that the extra push overshoots into genuine artifact territory rather than just heavier texture — which is why the strength sweep below stops at 1.5.

As a rule, reach for steps before strength: 1.0 at more steps is the dependable way to get more out of it. Strength and step count trade against each other, and 1.0–1.5 is worth experimenting with if the defaults are not giving you what you want — but treat 1.5 as the ceiling.

The three panels individually: 0.5 · 1.0 · 1.5 — 1024×1024, seed 4242, 4 steps.

File format and compatibility

A plain .safetensors file — not tied to any framework or backend. It is weights plus a naming convention, so it loads under PyTorch (CUDA, MPS or CPU), MLX on Apple Silicon, or anything else that can read safetensors and do a matrix multiply.

container	safetensors
adapter weights	bf16 (lora_A, lora_B)
alpha	fp32 scalar per module, 64.0
rank	64 → effective scale alpha / rank = 1.0

Keys are diffusers module paths with PEFT-style suffixes:

transformer_blocks.0.attn.to_gate.lora_A.weight   (64, 6144)
transformer_blocks.0.attn.to_gate.lora_B.weight   (6144, 64)
transformer_blocks.0.attn.to_gate.alpha           scalar
time_embed.linear_2.lora_A.weight                 ...

applied the standard way:

W' = W + (alpha / rank) · (B @ A)

The one thing to watch when porting is naming, not framework. Runtimes that use their own layer names — ComfyUI, for instance, calls these diffusion_model.blocks.N.attn.gate with lora_down/lora_up — need a key remap first. The tensors themselves need no conversion.

The keys, runtime by runtime

The module paths in the file are the ones diffusers' Krea2Transformer2DModel uses for its layers — transformer_blocks.N.attn.to_q, ff.up, time_embed.linear_2, and so on — so they name the right tensors in any runtime that follows the diffusers architecture. What differs between runtimes is the wrapping around those paths:

runtime	what it expects	what to do
diffusers (pipe.load_lora_weights)	every key prefixed with the pipeline component it belongs to — transformer. here — because one pipeline LoRA file may carry adapters for several components; the scale comes from the adapter config, so the loader does not read alpha keys and rejects a file that has them	add the prefix, drop the alpha keys — two lines, shown in Inference with diffusers. Nothing numeric changes: with no alpha given, diffusers assumes alpha = rank, which is exactly the 1.0 this file encodes
ComfyUI	its own layer names, diffusion_model.blocks.N.attn.wq with lora_down/lora_up, no alpha keys (absent alpha defaults to the rank)	use the _comfyui file, which is that remap of the same tensors
MLX and custom loaders	nothing in particular	read the keys as they are and apply W' = W + (alpha / rank) · (B @ A)

In every case the tensors are the same 456 bf16 matrices; only the names around them change.

Resolution sweeps

The Examples below are all 1024×1024. A single resolution is not enough to judge an adapter of this kind: the shard pool it trains on is never evenly spread across buckets, and adapters carry recency bias, so one can be strong at the size it saw most while quietly softer at the ones it barely saw. Only rendering every bucket shows that.

assets/resolution_sweeps/ holds the full evidence: this LoRA rendered at every trained resolution, for all 15 test prompts — same prompts, same seed, 4 steps, LoRA strength 1.0. Nothing is cherry-picked; the sweep is the complete set.

The same folder carries the measuring stick: _teacher-8step/ — the official Krea 2 Turbo 8-step reference renders: the stock model, no LoRA, at its native recommended settings (8 steps, guidance 0.0), for the same 15 prompts, the same seed and the same resolutions. Those images are the teacher this LoRA is distilled from and the fixed quality bar it is measured against.

Both sweeps share one layout — one folder per resolution, one image per prompt — so any image can be compared 1:1 with its twin:

assets/resolution_sweeps/
├── _teacher-8step/         the official 8-step stock-Turbo reference renders (no LoRA)
│   ├── 512x512/            one folder per resolution
│   │   ├── portrait.jpg
│   │   ├── kingfisher.jpg
│   │   ├── … 13 more, one per test prompt
│   │   └── snowleopard.jpg
│   ├── 768x512/
│   ├── 1024x1024/
│   ├── 1280x1280/
│   ├── 1440x1280/          …and the remaining buckets
│   └── 1440x1440/
├── 4step-LoRA/             the same tree, rendered with this LoRA at 4 steps
└── 2step-LoRA-extreme/     the out-of-spec 2-step strips of the bonus section further down

Two ways to read them, both useful:

• 🔍 down the sweep — does the adapter hold together across every resolution, or is it strong at one size and soft at others?
• 🎯 against the teacher — open the same <WxH>/<prompt>.jpg under _teacher-8step/ to see how close 4 steps with the LoRA gets to the full 8-step render it is distilled from

The resolutions are exactly the training buckets listed under Resolutions.

Method

Progressive distillation (PD), with Krea 2 Turbo as its own teacher.

The teacher ran its normal 8-step schedule at mu = 1.15 and guidance 0.0, and its full trajectory was recorded — the latent x and the predicted velocity v at every one of the 8 steps. The student was then trained to cover two teacher steps in one: at teacher state x_i it had to predict the chord that lands where the teacher arrives two steps later,

v_target = (x_{i+2} − x_i) / (σ_{i+2} − σ_i)

The two schedules line up exactly rather than approximately. On the mu = 1.15 grid, the even indices of the 8-step schedule are precisely the four sigmas the 4-step student deploys on, so every training target is anchored on a point the student will actually visit at inference. No interpolation, no schedule mismatch.

Teacher trajectories were precomputed into shards, so training read recorded states rather than re-running the teacher.

The critic

The trajectory match above can only ever pull the student toward the teacher — and a regression objective averages over whatever it cannot predict exactly, so fine texture is the first thing it averages away. On its own, PD lands short of the teacher's detail. So it was paired with a small adversarial term in the style of LADD (latent adversarial diffusion distillation), which graded the student's output as an image rather than as a distance to the teacher's trajectory.

• The critic read the model's own features. Its trunk was the frozen Krea 2 Turbo transformer with the adapter bypassed, tapped at block 14 (the trunk itself ran with the empty prompt); a small two-layer head sat on those features, per-token logits averaged. There was no separate discriminator network and no decode to pixels — the critic saw latents the same way the model does.
• Real vs fake, judged at the low-noise end. Fake was the student's predicted clean latent from the same training forward. Real was a teacher final for a different prompt in the same resolution bucket — unpaired, so the critic could not win by matching content — or, half of the time, a real photograph from a curated crop pool, VAE-encoded. Both sides were re-noised to a random σ in [0.02, 0.5] before the trunk saw them: low noise is where fine texture is decided, and that was the only place the critic spoke. Hinge losses on both sides; the generator-side weight was small (1.0e-3 against a PD term of order 1e-2) — a finisher, not the objective.
• Prompt-aware. The head also read a pooled text vector — the last four of the twelve Qwen3-VL tap layers, through a projection — so it could grade whether an image fit its prompt, not only whether it looked plausible. A mismatch term enforced it: a real image scored under a prompt that was not its own had to read fake. Real photographs entered with their own auto-generated short captions so they took part in that objective too, and 15% of the time an image was scored with the empty-prompt vector, so that "no caption" could never itself become a cue.

Why show it real photographs. A critic that sits on the teacher's features and only ever sees the teacher's outputs converges on the teacher — and the teacher is an 8-step model that itself slightly under-renders fine texture, so a student judged only against it inherits that ceiling. Mixing real photographs into the critic's real set moves the ceiling: the teacher anchors structure, reality anchors texture.

Three more choices shaped the weights that ship. The four student chords were not weighted equally in the PD loss — the last one, at σ = 0.512, the call that decides fine texture, carried 3× the weight of the other three. On the large buckets — 1024×1024 and above — a low-frequency anchor added a small term (weight 0.2) comparing the student's velocity with the teacher's chord after both were averaged over 64-pixel cells: structure was held to the teacher at that scale while the fine band, the one the critic pushes, stayed free. And the released adapter is a Polyak (EMA) average of the training weights (decay 0.999), not the last live state, which smooths out the step-to-step wander of a constant learning rate.

What the LoRA touches

Rank 64, alpha = rank (scale 1.0), bf16. 228 modules:

• 🧱 224 block linears — across all 28 transformer blocks: attn.to_q, attn.to_k, attn.to_v, attn.to_gate, attn.to_out.0, ff.gate, ff.up, ff.down
• 🌐 4 global (non-block) linears — time_embed.linear_1, time_embed.linear_2, time_mod_proj, final_layer.linear

Those four are included deliberately. Measuring Krea's own Raw→Turbo delta — a completed step distillation by the model's authors — showed the change is not concentrated in the blocks:

layer	relative ‖ΔW‖/‖W‖
time_embed.linear_2	0.0777 ← largest change in the whole network
time_embed.linear_1	0.0429
final_layer.linear	0.0265
typical block linear	~0.014

time_embed.linear_2 moves about 5.5× more than any block linear. Changing a model's step count is in large part a change to how it reads the timestep, so a LoRA that freezes the timestep path is withholding exactly the weights the task most needs.

Training data

Prompts were drawn from Lakonik/t2i-prompts-3m — sampled without replacement, deduplicated, and filtered for degenerate lengths. A held-out tail was reserved for validation and never received a gradient step; it measured the student→teacher velocity gap on unseen prompts.

The shipped weights trained on 13,750 of those prompts, one recorded teacher trajectory each. A further 203 were held out for validation and 641 kept for out-of-distribution evaluation; none of the 844 ever received a gradient step.

The critic's real class was fed from two sources. Half of its draws were the teacher's own finals for other prompts; the other half were 43,044 real-photo crops — 25,560 from LSDIR and 17,484 from Flickr2K — cut at native resolution to the same 12 buckets the adapter trains at, quality-gated, VAE-encoded into the training latent space, and captioned per crop so they could take part in the prompt-aware term. The photographs only ever reached the critic: they were never regression targets, so the adapter learned detail density from them, not content.

Resolutions

Training was multi-aspect across 12 buckets, so the adapter is not shaped by a single resolution or a single aspect ratio:

512×512	512×768	768×512
768×768	768×1024	1024×768
1024×1024	960×1280	1280×960
1280×1280	1440×1280	1440×1440

1440×1440 carried a deliberately small share of the mix — enough for the adapter to learn the size without spending the training budget there, since it exists for people running this on fast hardware rather than as a primary target.

Buckets were interleaved in proportion to their remaining samples rather than run as a small-to-large curriculum, so at any point in the run the adapter had recently seen all of them.

Hardware

Trained on a single RTX 3090 (24 GB VRAM), and the recipe was shaped by that ceiling.

The frozen base was quantized weight-only to int8 (blockwise-64) so the 28-block transformer, its gradients and the optimizer state fit alongside the activations. Since the frozen base sat under every gradient the adapter received, its quantization error was training noise — the trade that made a 24 GB card viable at all.

int8 was chosen on measurement: on Krea 2's own weights it introduces ~0.007 relative error, for about a 3% cost in step time. The teacher trajectories were rolled at the same precision, which mattered more than it sounds: the targets were permanent, so the teacher's error was baked into every trajectory.

Every bucket trained under full int8, up to 1440×1440. A full int8 step at 1.5 MP and above did not fit in 24 GB on its own, so the training step was made to fit:

• the inputs to each checkpointed block were staged to pinned host memory on the large buckets rather than held on the card — numerically exact, at a few percent of step time;
• the discriminator pass ran after the generator's backward rather than alongside it, so the two peaks no longer overlapped;
• the trunk stopped at the feature tap it actually read instead of running every remaining block.

Together those gave the largest bucket room to spare under a hard memory ceiling set below the driver's paging threshold — so the run would fail loudly if it ever did not fit, rather than quietly swapping to host memory and crawling.

All of this affected training only. The released LoRA is bf16 and is applied to the unquantized base.

Examples

Every sheet below is three renders at the same seed: the base model as shipped, the base model at the reduced step count without the LoRA, and the same reduced step count with it. Each panel is captioned with its own steps, CFG and NFE. Click any image for the full-size version.

NFE = number of function evaluations: how many times the model itself is run, and the honest unit of cost — steps are not, because a step with CFG runs the model twice (once conditional, once unconditional). Turbo is CFG-free, so here NFE equals steps: the 8-step reference costs 8, and this LoRA's 4 steps cost 4. Wall-clock tracks NFE.

How to read these sheets. Compare the second and third panels — they run the same step count and differ only by the adapter, so that pair isolates what the LoRA does. The first panel is the quality bar, not a pixel-level target: changing the step count moves the sampling trajectory by itself, so the full-step render often differs in pose and framing from both reduced-step panels regardless of whether the LoRA is loaded. Same seed throughout; the seed fixes the starting noise, not the destination.

Krea 2 Turbo — 8 steps → 4 steps

One section per prompt: the three-panel comparison first, then the individual renders — click any image for full size.

Portrait of a young woman with freckles and windswept auburn hair, soft window light, shallow depth of field, photograph, sharp detail

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A kingfisher bird bursting out of water with spread wings, water droplets frozen mid-air, iridescent blue and orange feathers, high-speed photography

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

Rainy night city street with glowing neon shop signs and readable text, wet asphalt reflections, pedestrians with umbrellas, cinematic

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

Busy outdoor street market crowded with many people browsing colorful fruit and vegetable stalls, awnings, midday sun, wide shot, photorealistic

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

Overhead shot of a rustic wood-fired pizza with bubbling melted cheese, basil leaves, charred crust, on a dark wooden table, food photography

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A young swordsman leaping through falling cherry blossoms, dynamic action pose, anime key visual, crisp linework, vivid colors

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A giant mecha standing in a rain-soaked city plaza, anime style, panel lining, glowing cockpit, dramatic low angle

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A fox in a red scarf reading a book under a mushroom, children's storybook illustration, watercolour texture, soft edges

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A curious young inventor girl with oversized goggles, 3D animated film style, subsurface skin, soft studio lighting, shallow depth of field

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A claymation chef holding a tiny cake, visible fingerprints in the clay, miniature set, tilt-shift

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A gleaming white colony ship in orbit above a turquoise ocean planet, smooth curved hull, glowing cyan engine rings, brilliant sunlight, clean sci-fi concept art, bold simple shapes, vivid colors

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A sleek winged drone gliding between glowing futuristic skyscrapers at night, bright lit avenue far below, deep blue sky above, digital matte painting, bold clean forms, vivid colors

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A storm sorceress channelling lightning, video-game splash art, bold rim lighting, energetic brush strokes, high contrast

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A formula 1 futuristic looking racing car beefed up with a lot of technology mid-corner on a wet track, motion blur background, photorealistic motorsport photography

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

A snow leopard walking along a rocky ridge in falling snow, telephoto wildlife photograph, natural light

3-way comparison — one image, all three renders side by side

Individual frames — click any panel to open that render full size

Turbo — 8 steps	Turbo — 4 steps, no LoRA	Turbo — 4 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 4 NFE

---

Why these prompts

The first five stress classic photographic failure modes — skin and hair, frozen motion and fine droplets, legible text and reflections, many small faces and repeated objects, and close-range texture. The ten that follow were added after community requests for broader style coverage: anime and cel animation, storybook and claymation, 3D animated film, video-game splash art and concept painting, plus photorealistic subjects (motorsport, wildlife, night cityscape) that lean on motion, weather and low light. Flat-colour styles are deliberately included: large uniform regions with hard edges expose step-reduction artifacts (banding, mushy line weight) that photographic texture hides.

The individual renders behind each sheet are in assets/ too: LoRA renders are named ..._4step_lora.jpg, and the base-model references ..._4step.jpg and ..._8step.jpg.

Notes and limitations

• 🎯 Krea 2 Turbo only. It is trained against Turbo's weights and Turbo's schedule.
• 🚫 Keep guidance at 0.0 — in ComfyUI that is cfg 1.0, not 0.0 (see ComfyUI). Turbo is CFG-free and this LoRA does not change that.
• 📐 Keep mu = 1.15. The training targets are anchored to that grid; a different shift moves the student off the sigmas it was trained on.
• 🔬 Training quantized the frozen base (see Hardware). That affected training only — the released LoRA is bf16 and is applied to the unquantized base.

Bonus: the 2-step extreme test

This is an extreme, out-of-spec experiment — not recommended for production use. Useful, however, as a fast preview: at 2 steps, the LoRA at its normal strength gives a reliable read on composition and the general look of an image at a quarter of the 8 steps.

Stock Krea 2 Turbo and Turbo + this LoRA, each run at just 2 steps — same prompts, same seed, the LoRA at its normal strength (1.0). Stock Turbo ghosts and smears at 2 steps; with the LoRA the image still comes out coherent and sharp. All 15 prompts were checked individually: the extra detail is real subject detail — hair strands, skin texture, fabric weave — plus, where the prompt calls for it, sharper atmospheric elements (the kingfisher's water droplets, the swordsman's falling petals, the snow leopard's snowfall). Nothing appears that the prompt did not ask for, and none of it intrudes on faces or main subjects. Full set of side-by-side strips in assets/resolution_sweeps/2step-LoRA-extreme/ — three samples:

Still out-of-spec and still preview-only — this is 2 steps, half the trained step count, not the trained 4-step regime the rest of this page measures. A dedicated 2-step LoRA is the natural follow-on project.

🔭 The 2-step LoRA is now its own project: lvladikov/Krea2-Turbo-Distill-2step-LoRA. Nothing usable is published there yet — the model card is a live account of the recipe and the progress, updated as the training runs, and work-in-progress renders go up regularly in that repository's Discussions. Checkpoints follow when one earns it.

Archive

Earlier checkpoints of the run and their resolution sweeps are kept under _archive/ — checkpoints/ and resolution_sweeps/ — for anyone who wants to look back. They are superseded by the files at the top of this page and not maintained.

What's next

A 2-step LoRA is the natural follow-on, and it is the next project. It will be a separate release rather than a competitor to this one: at two steps a distilled model gives up more than at four, so the goal is a usable 2-step Turbo — fast previews and drafts at half this adapter's cost, a quarter of the teacher's — not the quality bar this adapter holds. I may or may not get there. I will try anyway, and if it works it will appear as its own project alongside this one.

Most of what it needs is already in place. The recorded teacher trajectories serve it unchanged — a 2-step chord is simply two of the 4-step chords end to end, so no teacher runs are repeated. This adapter is a real starting point rather than a cold start: the two states a 2-step student sees are states this one was trained on, which is why it already holds together at two steps in the extreme test above. The critic, the real-photo pool and the prompt-aware term carry over as they are. And two steps is exactly the regime where the next lever pays off — matching the teacher's distribution rather than its trajectory, so the student is pushed away from the hedged average that plain regression settles into. Same discipline as here: measure against the honest baselines (stock Turbo at two steps, this LoRA at two steps), look at every cut, adjust, carry on.

License

This adapter is a Derivative of Krea 2 Turbo in the sense of the Krea 2 Community License Agreement — a distilled, modified version of the Krea Model — and it is released under that same agreement. Everything the agreement says about Krea 2 Turbo applies to this LoRA in the same way, no more and no less: the Acceptable Use Policy, the revenue threshold for commercial use, the content-filtering duty for deployments. A copy of the agreement ships here as LICENSE.pdf and the required attribution notice as NOTICE.txt; see krea.ai/krea-2-licensing for Krea's own page on it.

This is not an official Krea product and is not endorsed by Krea. The base model is Krea's; the adapter weights and everything else in this repository are mine.