DETAILED-README.md

metadata

base_model: krea/Krea-2-Turbo
base_model_relation: adapter
license: other
license_name: krea-2-community-license
license_link: >-
  https://huggingface.co/lvladikov/Krea2-Turbo-Distill-2step-LoRA/blob/main/LICENSE.pdf
library_name: diffusers
tags:
  - lora
  - text-to-image
  - distillation
  - step-distillation
  - distribution-matching
  - krea-2
pipeline_tag: text-to-image

Krea 2 Turbo — 2-Step Distillation LoRA

🧪 A fast-preview adapter, from a project still in training. When the subject is close and fills a good part of the frame — a portrait, a single figure, an object seen up close — two steps already hold up well, and you can rely on this adapter for those images. Small subjects are where it still falls short, people and objects alike: faces in a crowd, figures in a wide scene, the machines at the back of a gym — anything that takes up little of the frame can come out ghosted or smeared. For those, and whenever quality matters more than speed, use the 4-step LoRA. Every figure on this page measures the adapter honestly against 4-step and 8-step renders. Training continues one recipe change at a time, and a later checkpoint replaces this one only when the sweeps and I visually agree it is better. Known issues — see Known issues.

📐 The saved steps can also go into resolution. A small subject is simply one that covers few pixels, so a larger render makes the same subject bigger — and at a quarter of the teacher's steps, renders up to 2048×2048, Krea's published maximum recommended resolution and beyond the largest size this adapter was trained at (1440×1440), come within easy reach. That makes the adapter a stepping stone to high-resolution renders as well as a fast preview. Past 2048×2048, stock Krea 2 itself begins to duplicate subjects — a property of the base model, with or without this adapter.

🔀 Also compatible with Krea 2 Raw. With some prompts it works very well on Krea 2 Raw too, at 7 steps+ — see Using it on Raw and the dedicated experiment.

A LoRA for Krea 2 Turbo that takes the model from its usual 8 steps down to 2 — Turbo's own weights and its own two sigmas, guidance 0.0, a quarter of the denoising passes — aiming at the best quality two steps can give. Two steps give up more than four: this adapter is for fast previews and drafts at half the 4-step adapter's cost and a quarter of the teacher's, and the 4-step LoRA remains the recommendation for quality renders.

• 🎯 The aim — the best two-step quality this base can give, at every one of the same 12 resolutions, measured against the 8-step teacher and against the 4-step LoRA as the reference. Not a claim to reach either.
• ⚡ A quarter of the steps — 8 → 2, on Turbo's own deployment sigmas.
• ⏱️ 4.2× faster denoising — the model runs twice instead of eight times, and denoising is the part this adapter changes: 81.4 s → 19.5 s measured at 1024×1024 on the same prompts, the adapter's own cost per call within measurement noise. What a whole render costs on top of that is unchanged by the LoRA and depends on your pipeline; see Performance.
• 📊 Distribution matching, not imitation — the training objective that got the renders improving again after the 4-step project's recipe had stopped helping at two steps (see Method).
• 🗣️ Prompt-conditioned throughout — both scores in the distribution match, the teacher's and the fake adapter's, are evaluated on each prompt's own conditioning, so the student is matched to what the teacher makes for that prompt, not to a prompt-free look. There is no separate adherence term: instead a vision-language judge checks every checkpoint — each render scored alone against the prompt's objects, counts, attributes and relations, with the teacher scored the same way — and a term would only be added if that meter showed adherence slipping. The one part of training that looks at images without their prompt is the artefact critic (see Method), and it only judges whether fine structure looks like the teacher's.
• 📐 12 trained resolutions — multi-aspect from 512×512 up to 1440×1440, each with its sweep.
• 🔌 Drop-in, no exceptions — a plain LoRA sampled by stock Euler at sigmas [1.0, 0.7595] in diffusers, ComfyUI or MLX. No custom sampler, no policy head, no per-step tricks. If the quality needs a special sampler it is not this project.
• 🧬 Same shape as the 4-step adapter — rank 64 on the same 228 modules; a second adapter exists during training only and never ships.
• 🎲 The same 13,750 recorded teacher trajectories the 4-step adapter trained on, reused without a single teacher re-run.
• 🔢 17,464 training samples in the 2-step stages, on top of the 4-step LoRA's 78,000 — all of them drawn from the same recorded material: no new prompts, no new text embeddings and not one new teacher run. A training sample is one pass over a prompt that was already encoded and already traced by the teacher for the 4-step project, read again at the two sigmas this schedule uses.
• 📅 7 days from the first 2-step training launch to this checkpoint, on a single RTX 3090 — and the project continues.
• 🔁 26 recipe adjustments across two methods so far — seven of trajectory distillation before the switch, nineteen of distribution matching since — each kept only when the renders did not get worse.
• 🖥️ One RTX 3090, and a recipe shaped by its 24 GB.

All of the above were created with this LoRA at 2 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_2step_rank_64_lora.safetensors	the LoRA in diffusers key format — see Inference with diffusers; also for MLX or anything that reads safetensors
krea2_turbo_2step_rank_64_lora_comfyui.safetensors	the same weights under ComfyUI's key names — see ComfyUI
krea2_turbo_2step_lora_t2i.json	a ready ComfyUI workflow, stock nodes only
krea2_raw_7step_lora_experiment_t2i.json	the Krea 2 Raw 7-step experiment's ComfyUI workflow (Using it on Raw)
krea2_turbo_2step_rank_64_lora_checkpoint_info.md	the quick place to check which checkpoint the two weight files are based on. The pair above keeps its names and is updated in place as better checkpoints ship; this file always says what they are today. Every published checkpoint also sits in _archive/checkpoints/ under its number
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, lineage, method, the checkpoint and the inference settings. Their file names never change; when a better checkpoint ships they are replaced in place, and krea2_turbo_2step_rank_64_lora_checkpoint_info.md is the quick place to check which checkpoint the current files are based on.

Where it stands

lineage	4-step LoRA → 2-step trajectory distillation → distribution matching → a spectral match against the teacher's own images → an artefact critic and detail terms → three critics taking turns
this release	the current run's latest probed checkpoint, chosen by the 12-bucket sweep and by my own look at the renders; the run continues from it one recipe change at a time
what it gives	usable two-step renders at every trained resolution: fine detail at or just above the teacher's — from 1 megapixel up, closer to the teacher than the 4-step adapter — with the prompt's objects, counts, attributes and relations in place (a blind rubric finds 1 point missing out of 240). A judge asked which render follows the prompt better still prefers the 8-step teacher on 11 of 45, against 6 for the 4-step adapter, mostly on how a stylised prompt says things should look. What it does not give is the teacher's own picture: see Known issues and Measured against the teacher

Known issues

The usual costs of two steps, in this order of how often they show. Small subjects are the weak spot, people and objects alike: a portrait-sized face or an object seen up close holds up, while small or distant subjects — faces in a crowd, a figure in a wide scene, the machines at the back of a room — can come out ghosted, smeared or misshapen, since at that size a whole subject is only a few of the blocks the model works in. Fine structure can come out soft or a few pixels out of register — feathers, hair strands, signage, the surface of a distant object — most at 1280×1280 and above, and a faint doubled contour can show on limbs. On stylised prompts, how the prompt says the image should look is followed less faithfully than what should be in it: crisp anime linework, energetic brush strokes, the fingerprints in clay or a matte-painting finish come out closer to a generic rendering than the teacher's. On busy action or crowd scenes the composition can repeat itself — an extra hand or held object, a figure duplicated in a crowd — where the 8-step and 4-step renders commit to one. On some prompts the composition itself differs from the 8-step render at the same seed: two steps is a shorter path from the same starting noise, so the image can settle on a different framing, pose or arrangement rather than a degraded version of the teacher's. Treat the teacher's render as a reference for quality, not as the picture two steps will reproduce. Skin reads slightly smoother and less saturated than the teacher's, and colour overall runs a little under the teacher's at the largest sizes; freckles tend to gather into clusters rather than separate dots. A fine grain remains on the most textured subjects at the largest sizes, lighter than in the previous checkpoint. Every one of these is being worked on; none is hidden in the sweeps or the examples.

How I got here

The 4-step adapter closed its page with a promise: a 2-step LoRA as the next project, and a guess at the lever it would need — matching the teacher's distribution rather than its trajectory. That guess turned out to be the whole story.

The project began where the 4-step one ended, from its final weights, and ran the same recipe at two steps: progressive distillation on the recorded teacher trajectories, each student call covering four teacher steps, with the LADD-style critic as the finisher. Well into that run, every number had stopped moving and the pictures had a signature the numbers could not see: doubled contours on faces and limbs, soft fine texture, crowds averaged into translucent overlaps. Several variations followed — the critic re-weighted, judged per token, a heavier hand on the final call, the student's own first-step output fed into its second — and each traded one of those faults for another without moving past them. A capacity probe ruled out adapter rank; a learning-rate shock ruled out the optimiser.

The reason is structural, and worth stating plainly because it decides the whole design. A regression loss asks the student to land on the teacher's specific image for each prompt. When a two-step jump is wide enough that several images are plausible, the answer that minimises the squared error is their average — and the average of two sharp images is a blurred one with doubled edges. Every earlier recipe rewarded that average. Tuning its weights could not change what it rewarded.

Distribution matching asks a different question: not "does your image match this one" but "would the teacher plausibly have produced your image". The first run of that objective, on top of the trajectory-distilled weights, produced in a fraction of the old recipe's training what all of it never had — and it did so while every latent distance to the teacher rose, which is exactly what a mode-seeking objective predicts and what a mean-seeking metric punishes. The distances are reported on this page; they are not optimised for, and they are not what decides a checkpoint. Pictures are, at fixed seeds, at every resolution, with faces viewed at 1:1.

The recipe adjustments so far, each made on the measurement of the one before:

1. progressive distillation at two steps from the 4-step adapter's weights, with the LADD critic — the baseline
2. the critic made to judge the first call's endpoint against the teacher's mid-states, which removed the gross ghosting and left the doubled contours
3. the critic's weight, its per-token form and the student's own first-step output as the second call's input — tried one at a time; the objective flip that mattered was not among them
4. distribution matching (the DMD2 family) as the primary objective, trajectory regression demoted to an anchor at half weight, the critic switched off to read the new term alone
5. the running average of the weights restarted at the objective switch, after it was caught averaging two lineages into composites
6. a spectral match of the student's image against the teacher's own, on the whole latent and on decoded pixel windows — the term that finally reached the grain at large resolutions, after a critic, per-resolution weights and a filtered push had each been tried against it and retired
7. the decoded-window spectral term given a much lighter hand — capped at a quarter of its earlier strength, which kept the detail and took some grain out of flat areas
8. the fake-score adapter updated four times per student step instead of twice, so it keeps up with what the student currently makes; faint straight-line artefacts that had begun to appear on flat illustrated areas went away with it
9. an artefact critic — a small head reading the frozen base model's own mid-network features, trained to tell the teacher's finished images from the student's, with its push restricted to structure finer than 32 pixels and held well below the distribution term — aimed at what the distribution term leaves behind: melted small faces and dense detail smeared into blotches
10. four detail terms together: the anchor counting the fine-detail part of its error twice; a one-sided floor that stops the finest detail dropping below the level real photographs carry; a second-call target made by the teacher finishing the image from the student's own first-call output, so the target shares the student's layout; and a smoothness limit on the fake-score adapter, so the distribution push keeps pointing at detail rather than away from it
11. three critics taking turns — the artefact critic joined by one whose real examples are half real photographs and one weighted toward faces, one of them pushing on each step while the others keep training in between, because the three did not fit in memory side by side

Two further ideas were tried and taken back out: confining the distribution term to the second call's noise range, and a detail pyramid compared pixel by pixel against the teacher, which on inspection rewarded fading any detail it could not place exactly where the teacher had it.

chk00017464 vs chk00013663

chk00013663 (published 12 Sep 2026) was the first public checkpoint: distribution matching with the spectral match, and nothing yet aimed at the faults the distribution term leaves behind. chk00017464 (14 Sep 2026) is 3,801 training samples later, and every one of those samples went to those faults — the grain and grid pattern at large sizes, small faces, dense detail — through five recipe changes, each kept only after its own look at the renders:

1. the decoded-window spectral term brought down to a quarter of its strength
2. the fake-score adapter updated four times per student step instead of twice
3. the artefact critic, reading the frozen base model's own features
4. four detail terms: the anchor counting fine-detail error twice, the one-sided photo floor, the teacher's finish of the student's first call as the second call's target, and a smoothness limit on the fake adapter
5. three critics taking turns: the artefact critic, a photo critic and a face critic

Two ideas were tried and taken back out along the way: the distribution term confined to the second call's noise range, and a detail pyramid compared pixel by pixel against the teacher.

Detail at large sizes — the headline. Every one of the 12 sweep resolutions × 15 prompts measured against the 8-step teacher, as in Measured against the teacher. Above 1 megapixel the excess fine energy two steps used to put into images is roughly halved, and those sizes are now closer to the teacher than the 4-step adapter on fine texture and on both grid bands:

1.00 = the teacher	fine texture	16-px band	8-px band
1280×1280	1.20 → 1.09	1.16 → 1.08	1.25 → 1.13
1440×1280	1.21 → 1.08	1.19 → 1.09	1.28 → 1.14
1440×1440	1.34 → 1.17	1.25 → 1.08	1.42 → 1.21

Fine-texture energy and both grid bands come closer to the teacher at 10 of the 12 resolutions, the blur-invariant ghosting index at 10 of 12, the micro-ghost index at all 12, and the grain in flat areas — skies, walls, out-of-focus backgrounds — at 11 of 12 (1440×1440: 1.84× the teacher's → 1.57×, median of the 15 prompts). It shows where it should: hair renders as more individual strands, and the token-grid texture that read as grain on birds, food and foliage at 1440×1440 is lighter.

Faces and skin. Freckles on the test portrait gather into lighter, more dot-like clusters than before — better, not yet the teacher's separate dots — and eyes look about the same: clean irises, lashes softer than the teacher's.

What did not improve. The judge that asks which of two renders follows the prompt better prefers the 8-step teacher on 11 of 45 against 6 before, mostly on how a stylised prompt says the picture should look: crisp linework, energetic brush strokes, the texture of clay. The blind rubric that checks each render alone for the prompt's objects, counts, attributes and relations moves from 0 to 1 point missing out of 240, and on the same 15 fresh prompts the previous checkpoint was measured on, the two checkpoints come out level (1 win, 13 ties, 1 loss). Colour runs slightly lower (saturation 0.93× the teacher's across the sweep, from 0.94×; 0.86× at 1440×1440), and at 512×512 the two checkpoints are level. Both are what the next recipe changes target.

axis	chk00013663	chk00017464
fine texture vs the teacher, 1280² / 1440²	1.20 / 1.34	1.09 / 1.17
16-px grid band, 1280² / 1440²	1.16 / 1.25	1.08 / 1.08
grain in flat areas, sweep median	1.36×	1.26×
distance to the teacher, sweep mean	0.413	0.406
judge prefers the teacher (of 45)	6	11
blind adherence rubric, points missing of 240	0	1
saturation vs the teacher, sweep mean	0.94×	0.93×
training samples in the 2-step stages	13,663	17,464

Measured against the teacher

Every number here compares a render of this LoRA at 2 steps with the 8-step reference render of the same prompt at the same seed, across the 15 test prompts and the 12 trained resolutions. Two other columns are measured the same way, so the figures have a floor and a ceiling around them: stock Krea 2 Turbo at 2 steps, which is what the base model does without the adapter, and the 4-step LoRA at its own 4 steps, which is the better tool and the thing worth being compared against.

Detail, band by band. Fine-texture energy and the two grid bands, as a ratio to the teacher's own (1.00 = the teacher):

bucket	fine texture	16-px band	8-px band	4-step LoRA (same three)	stock 2-step, fine texture
512×512	1.02	1.02	1.05	1.05 · 1.05 · 1.07	0.57
768×1024	1.02	0.98	1.07	1.05 · 1.05 · 1.08	0.39
1024×1024	1.06	1.07	1.12	1.11 · 1.17 · 1.16	0.39
1280×1280	1.09	1.08	1.13	1.20 · 1.18 · 1.22	0.41
1440×1440	1.17	1.08	1.21	1.24 · 1.23 · 1.32	0.42

Two steps without the adapter carry 0.57× the teacher's fine detail at 512×512 and less than half (0.39–0.42×) at the four larger sizes. With it, the detail sits at or just above the teacher's everywhere — and from 1 megapixel up it is closer to the teacher than the 4-step adapter, which carries more excess fine energy there.

Prompt adherence, judged. A vision-language judge is shown the teacher's render and this LoRA's for the same prompt, in both orders, and asked which follows the prompt better; a loss means the teacher was preferred both times:

bucket	wins	ties	losses
512×512	1	10	4
1280×1280	1	10	4
1440×1440	0	12	3

Eleven losses out of 45, where the 4-step LoRA scores six against the same teacher. They gather on stylised prompts and on how a prompt says the picture should look — crisp linework, energetic brush strokes, the texture of clay — more than on what should be in it: a blind rubric that scores each render on its own against the prompt's objects, counts, attributes and relations, with the teacher scored identically, finds 1 point missing out of 240. On 15 prompts drawn fresh from the training prompt bank and never rendered before, the judge returned 0 wins, 10 ties, 5 losses; on another 15 fresh prompts, 1 win, 13 ties, 1 loss.

Checked for the damage this kind of training can do. Saturation sits at 0.99× the teacher's at 768×1024 and 0.89× at the larger sizes; edge detail 0.93–0.96×; skin texture inside detected faces 1.07× at 768×1024 and 0.85× at 1440×1440, with skin saturation 0.92× and 0.77–0.85× at the larger sizes. The honest reading of those last two: skin is the softest and least saturated part of this adapter's output at large sizes, and colour overall runs a little under the teacher's there. Fine detail in flat regions — skies, walls, out-of-focus backgrounds — runs 1.53–1.85× the teacher's, which is where two steps put grain that eight steps do not.

Distance to the teacher, as a plain pixel measure, is 0.39–0.44 at every size against the 4-step LoRA's 0.30–0.37. That gap is what two model calls cost instead of four: the image is a good render of the prompt, but it is not the teacher's render of it — see Known issues.

Usage

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

The 2 sampling sigmas are Turbo's own deployment grid: [1.0, 0.7595] — the first and the middle of the 4-step grid, so the model is evaluated at two points it already knows.

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.

It still does something useful there. On Turbo the adapter runs a quarter of the teacher's steps — 2 of its 8 — so on Raw the same quarter of its usual 28 steps, 7, is the natural place to start, and for most prompts it is a good one. For a quick preview, some prompts hold together at even 4–5 steps — not as good as 7 steps or more, but not broken either. Keep the guidance light: guidance_scale=1.0 in diffusers, which is cfg 2.0 in ComfyUI. Heavier guidance, such as 4.5, crushes most images into near-black frames at 7 steps, and with no guidance at all the pictures come out flat.

Krea 2 Raw + this LoRA, 7 steps, light guidance, empty negative prompt, seed 4242, 1024×768. Click for full size.

Results are mixed and subject-dependent. Some prompts come through as finished pictures; others do not — an underexposed night street, a cityscape with less detail than Turbo gives at 2 steps — and for those a few more steps may help. The full experiment, with all 15 test prompts at 1024×768, what worked and what did not, and a ComfyUI workflow, is in its dedicated README, in assets/resolution_sweeps/raw-LoRA-7steps-experiment/. The same prompts on stock Raw at the same 7 steps and light guidance, without the LoRA, are in _raw-base-NO-LoRA-7step-cfg1/.

The experiment's ComfyUI workflow, krea2_raw_7step_lora_experiment_t2i.json: Krea 2 Raw + this LoRA, 7 steps, cfg 2.0. Click for full size.

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-2step-LoRA", "krea2_turbo_2step_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="2step")

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

• num_inference_steps=2 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 and 0.7595 — exactly the two points in Usage that the LoRA was trained on. Keep guidance_scale=0.0.
• Strength: pipe.set_adapters(["2step"], 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_2step_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_2step_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	2
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

Measured on this machine (Apple Silicon, MLX, bf16) at 1024×1024, two prompts per configuration, each run on its own with the model already loaded, so the numbers are the render itself and not a model load:

configuration	denoising	per model call	GPU peak
Krea 2 Turbo — 8 steps (the reference)	81.4 s	10.2 s	25.2 GiB
Krea 2 Turbo — 2 steps, no LoRA	20.4 s	10.2 s	25.2 GiB
Krea 2 Turbo — 2 steps + this LoRA	19.5 s	9.8 s	25.2 GiB

Denoising is 4.2× faster than the 8-step reference — two model calls instead of eight. The adapter's own cost per call did not show up in this measurement: the runs with it came in marginally faster than those without, which is measurement noise, not a speed-up. A rank-64 low-rank product is small beside the transformer it is added to, and it adds no measurable memory.

Denoising is the part the step count changes. What a complete render costs on top of it — encoding the prompt, decoding the latent, writing the file — is the same whether you run two steps or eight, and it depends on your pipeline, so the end-to-end figure on your machine will sit below 4.2× and rise toward it as the render gets larger.

By resolution. The two model calls of this LoRA's own sweep renders on the same machine (median of the 15 test prompts per size; sweep renders run one at a time, not the controlled measurement above):

resolution	denoising (2 calls)	resolution	denoising (2 calls)
512×512	6.4 s	1024×1024	20.4 s
512×768 / 768×512	8.9 s / 9.0 s	1280×960 / 960×1280	23.2 s / 24.0 s
768×768	11.9 s	1280×1280	32.2 s
768×1024 / 1024×768	14.9 s / 15.1 s	1440×1280 / 1440×1440	34.8 s / 39.8 s

LoRA strength

Use 1.0. That is the value the adapter was trained at, and where the 2-step output sits closest to the 8-step reference on every measurement in this page.

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

What the dial scales is this adapter's whole job at two steps: turning a pair of coarse calls into a finished image. So it behaves differently from a 4-step adapter's strength control, where the base render is already coherent and the LoRA only adds the missing texture.

strength	what happens
below 1.0	the correction is only partly applied — softer skin and hair, less fine structure, closer to what two steps look like without the adapter. There is less reason to reach for it here than at four steps, where the base render stands on its own
1.0	the trained point, and the recommendation
1.0–1.5	extrapolation past training: texture grows denser than the subject warrants and fine structure begins to read as wiry rather than sharp. Usable if you want that look, on a prompt-by-prompt basis
above 1.5	not recommended, and not measured here

If a render is not giving you what you want, reach for steps before strength: this adapter is trained for two, and the 4-step adapter is the better tool whenever quality matters more than speed.

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 drops alpha	add the prefix and drop .alpha, as in the snippet above
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
MLX and custom loaders	nothing in particular	read the keys as they are and apply W + (alpha/rank)·(B @ A)

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

Method

Distribution matching with a trajectory anchor, Krea 2 Turbo as its own teacher, on the recorded 8-step trajectories.

The student makes two calls, at σ = 1.0 and σ = 0.7595 — the first and fifth points of the teacher's 8-step grid at mu = 1.15 — and stock Euler carries it between them. That grid is what makes the objective a drop-in: Euler's first step from pure noise lands exactly on the flow-matching interpolant at σ = 0.7595 with the same noise and the student's own clean-image prediction as the data point. So the student's first-call output is a legitimate image prediction that can be judged as an image, and the second call is fed from it during training the way it will be at inference.

The distribution term. For an image the student produces, two denoisers estimate how it should be cleaned up from a freshly noised copy: the frozen teacher, and a second small adapter on the same frozen base — the fake score — that is trained online to denoise whatever the student currently makes. Where the two disagree is the direction that makes the image more like the teacher's work and less like the student's habits, and the student is pushed that way (the DMD2 gradient, per-sample normalised). Averaging is never rewarded, so the student commits. The fake adapter is rank 32, starts as an exact copy of the teacher, updates four times per student step — often enough to keep up with a student that is still changing — and is discarded at the end.

The anchor. Plain trajectory regression on the teacher's recorded chords stays in at half weight. It keeps the student on the teacher's two-step grid so the distribution term cannot wander into a different sampler behaviour, and it is what the earlier trajectory distillation had already satisfied — which is why the first distribution-matching run moved so far so fast.

Per resolution. The distribution term's push grows with resolution: the fake adapter sees few large-bucket samples and under-fits fine structure there, and a per-pixel normaliser lands harder as pixel counts grow. A full 12-bucket sweep of the first distribution-matching checkpoint located the problem at 1 megapixel and above (fine-texture energy 1.4–1.8× the teacher's at the five largest buckets); scaling the push per bucket from that measurement was tried and did not hold, and the spectral match replaced it. The same sweep of the published checkpoint, its running-average weights, fixed seed, 15 prompts per bucket, every image measured against the teacher's render of the same prompt and seed (in brackets: the first distribution-matching checkpoint on the same prompts):

bucket	fine texture vs the teacher	16-px grid band	8-px grid band	distance to the teacher
512x512	1.02 (1.16)	1.02 (1.23)	1.05 (1.23)	0.41 (0.44)
512x768	1.01 (1.23)	1.06 (1.37)	1.06 (1.33)	0.39 (0.41)
768x512	1.02 (1.22)	1.08 (1.37)	1.04 (1.26)	0.44 (0.47)
768x768	1.09 (1.43)	1.05 (1.46)	1.14 (1.50)	0.40 (0.43)
768x1024	1.02 (1.36)	0.98 (1.38)	1.07 (1.42)	0.39 (0.43)
1024x768	1.01 (1.35)	0.98 (1.40)	1.04 (1.38)	0.43 (0.46)
1024x1024	1.06 (1.47)	1.07 (1.55)	1.12 (1.56)	0.41 (0.44)
1280x960	1.03 (1.50)	1.04 (1.59)	1.07 (1.56)	0.40 (0.42)
960x1280	1.10 (1.60)	1.05 (1.63)	1.19 (1.70)	0.40 (0.43)
1280x1280	1.09 (1.65)	1.08 (1.68)	1.13 (1.69)	0.41 (0.44)
1440x1280	1.08 (1.59)	1.08 (1.66)	1.14 (1.66)	0.40 (0.42)
1440x1440	1.17 (1.81)	1.08 (1.79)	1.21 (1.89)	0.39 (0.41)

The spectral match

Distribution matching delivers its push one latent token at a time, and a token is a 16×16-pixel block. At large resolutions the push that tells the student to add detail also, unintentionally, adds detail in the shape of that block: a faint checkerboard at the 16-pixel and 8-pixel periods that reads as grain on birds, food and foliage. It is measurable in the images' Fourier spectra — the student carried about twice the teacher's energy at exactly those two periods — and several ways of reshaping or re-weighting the push (a critic, per-region weights, a filtered push) were tried and retired: none of them could reach a pattern that lives inside the token.

What can is a term that judges the picture, not the push. For every second-call sample, the student's estimate of the finished image and the teacher's own image for the same prompt and seed are compared through their radial power spectra — how much energy each has at every spatial scale — as an L1 on the log spectrum, in two places: on the whole latent every sample, and on one random 256-pixel window decoded through the VAE so colour and decoder behaviour are judged too. The comparison is two-sided, so too much fine energy and too little are both penalised; a blurred image does not satisfy it. Its gradient is added to the distribution push and capped per sample as a fraction of it, so it refines rather than takes over. At its first strength it brought every resolution closer to the teacher's spectrum without touching adherence, layout or variety; raised, it began closing the grain on the hardest subjects too. The whole-latent comparison trains at that strength; the decoded window was later brought down to a quarter of it, which kept the detail and removed some grain.

The artefact critic

Distribution matching improves what the fake adapter can see, and the fake adapter learns from the student's own images — so where the student smears something, the fake learns the smear and the push stops correcting it. The two places that shows most are small faces, which come out melted, and dense content such as the goods on a market stall or the shelves of a shop seen through its window, which comes out as coloured blotches.

A critic breaks that loop by looking at finished images instead. It is a small head on the frozen base model's mid-network features — every adapter switched off, the forward pass stopped halfway, so no adapter can learn to fool it and nothing it learns leaks into the fake adapter. Its real examples are the teacher's own finished images for other prompts at the same resolution; its fake examples are the student's final images. Both are lightly re-noised first, in the low-noise range where fine structure lives, and the critic reads them with an empty prompt, so it judges only whether the structure looks like the teacher's. Its push on the student is filtered to periods finer than 32 pixels — below that it can rebuild a face or a shelf, above it it could move layout, colour or pose, which it must not — and capped at a quarter of the distribution term's strength per sample. Lazy gradient regularisation and spectral normalisation keep the head from overshooting. On the largest steps, where memory is tightest, the critic and the teacher's finishing pass below take turns instead of sharing a step.

Critics in turn

One critic holds one idea of what is wrong. The artefact critic was joined by two more on the same frozen mid-network features and under the same rules — lightly re-noised inputs, an empty prompt, a push that is filtered and capped — each aimed at a different fault:

• A photo critic. Half of its real examples are real photographs and half the teacher's finished images, so it learns what fine texture looks like in a photograph as well as in the teacher's rendering of one. Its push is filtered to periods finer than 24 pixels and held lower than the artefact critic's, because photographs carry grain the teacher does not.
• A face critic. Its real examples are the teacher's finished images of prompts with faces, the face regions counted at full weight and the rest at half, so its push concentrates on what small and mid-sized faces lose first.

All three on every step do not fit in 24 GB, so they take turns: on each step one critic pushes, and on alternate steps the others train so none goes stale before its turn comes back. The two new heads started from the artefact critic's weights and trained on their own before they were allowed to push.

Detail terms

Four smaller terms sit on top, each capped relative to the distribution term so none of them can take over:

• A detail-weighted anchor. The trajectory regression counts the fine-detail part of its error — everything finer than 32 pixels — twice, so the anchor stops tolerating softness it used to average away.
• A one-sided photo floor. On the decoded window, the student's energy at periods of 3–10 pixels may not fall below the teacher's plus the margin real photographs carry over it at those scales. That margin is measured once from a pool of real photographs and clamped, and the term only ever pushes upward to that floor, never past it — so it lifts detail that is missing without adding grain that is not.
• The teacher's finish as a target. Every second step, the teacher itself runs its remaining steps starting from the student's own first-call output. The result is a finished image that shares the student's layout, and the second call is pulled gently toward it — a target that lines up with what the student actually drew, where the recorded trajectory might have drawn something else.
• A smoothness limit on the fake adapter. The fake adapter's fine-detail energy is kept below the teacher's at the point where the distribution term is measured, so the difference between the two keeps pointing toward detail.

What the LoRA touches

Rank 64, alpha = rank, bf16, the same 228 modules as the 4-step adapter: the 8 attention and feed-forward linears of all 28 transformer blocks, plus the four global linears — time_embed.linear_1, time_embed.linear_2, time_mod_proj, final_layer.linear — that a step-count change needs most. Nothing about the base model changes.

Training data

The 13,750 recorded teacher trajectories of the 4-step project — Krea 2 Turbo's own 8-step run at mu = 1.15 and guidance 0.0, every latent and velocity stored — serve unchanged: a 2-step chord is two of the 4-step chords end to end. 203 held-out prompts measure the student–teacher gap on unseen prompts and never receive a gradient. The spectral match and the artefact critic read the teacher's finals for the training prompts. The 43,044 real-photo crops of the 4-step project enter in two places: as one precomputed statistic — how much fine-detail energy they carry at 3–10 pixels relative to the teacher, clamped — which sets the photo floor, and as half of the photo critic's real examples. Only that critic's head sees them; the student and the fake adapter never do, and receive only its filtered, capped push.

Resolutions

The same 12 buckets as the 4-step adapter, interleaved in proportion to their remaining samples:

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

Resolution sweeps

The Examples below are all 768×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, which is why every cut of this run is rendered across the buckets and why the per-resolution table under Method above exists.

assets/resolution_sweeps/ holds the evidence — same 15 prompts, same seed, one folder per resolution, one image per prompt, so any image can be compared 1:1 with its twin in the next tree:

• _teacher-8step/ — the official Krea 2 Turbo 8-step reference renders: the stock model, no LoRA, at its native settings (8 steps, guidance 0.0). The teacher this LoRA is distilled from and the quality bar it is measured against.
• _turbo-base-NO-LoRA-2step/ — stock Turbo at 2 steps, no LoRA: the do-nothing baseline, what two steps look like before the adapter. Every claim on this page is checked against both trees.
• 2step-LoRA/ — this LoRA at 2 steps, the same tree: the renders of the checkpoint published here, replaced whenever a better one ships. Which checkpoint that is today is in krea2_turbo_2step_rank_64_lora_checkpoint_info.md, and every published checkpoint's tree is kept under its own number in _archive/resolution_sweeps/.
• _turbo-base-NO-LoRA-1step/ and 1step-LoRA-extreme/ — the out-of-spec single-step material of the bonus section further down.

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
│   ├── 768x1024/
│   ├── 1024x1024/
│   ├── 1280x1280/
│   ├── 1440x1280/               …and the remaining buckets
│   └── 1440x1440/
├── _turbo-base-NO-LoRA-2step/   the same tree, stock Turbo at 2 steps — the floor
├── 2step-LoRA/                  the same tree, rendered with this LoRA at 2 steps — the published checkpoint
├── _turbo-base-NO-LoRA-1step/   stock Turbo at ONE step (bonus section)
└── 1step-LoRA-extreme/          this LoRA at ONE step, with side-by-side strips (bonus section)

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 and the floor — open the same <WxH>/<prompt>.jpg under _teacher-8step/ to see how close two steps with the LoRA get to the full 8-step render, and under _turbo-base-NO-LoRA-2step/ to see what those two steps looked like without it.

The resolutions are exactly the training buckets listed under Resolutions.

Hardware

One RTX 3090 (24 GB). The frozen base is weight-only int8; the student's checkpointed block inputs stage to pinned host memory above 0.3 megapixels; the student, the fake adapter, the spectral and detail terms, the critic and the teacher's finishing pass each build and free their own graph in turn, so their peaks never overlap; a hard memory ceiling sits below the driver's paging threshold so a step that does not fit fails loudly. A full step with every term live and every critic pushing reserves about 22.4 GB at 1440×1440, of 24. The price of the objective is throughput: about 107 training samples an hour measured over the recipe's complete run, against the 4-step recipe's 470 — more than four times the cost per sample, and so far a small fraction of the samples.

Where that cost comes from. Distribution matching is simply a heavier objective than trajectory distillation. The 4-step project's recipe compared the student's own output with a teacher state that had already been recorded to disk, so a training step was one student pass plus a small adversarial head. Here every step also needs the score of two models at a freshly noised point: the frozen teacher's, and a second adapter's that is being trained alongside to imitate the student — and that second adapter takes four optimiser steps of its own per student step. The spectral and detail terms decode part of the image out of the latent to compare its texture with the teacher's, each critic reads half the network twice more, and every second step the teacher finishes the image from the student's first call.

Counted in whole model runs per training sample, the difference is roughly two there against about a dozen here. None of that difference is the teacher generating anything: its renders were recorded once for the 4-step project and are read from disk by both. The extra work is the objective itself, and it bought the only thing that mattered. Run at two steps, the 4-step project's recipe reached a point where more training changed nothing: the measurements sat flat and every new checkpoint had the same faults as the one before — doubled contours on faces and limbs, soft fine texture, crowds blurred into one another. Distribution matching is the change that made each new checkpoint visibly better than the last again.

How it is judged

At regular intervals, both the live weights and their running average are pulled, merged and rendered at fixed seeds on 15 fixed prompts across four resolutions (512×512, 768×1024, 1280×1280, 1440×1440); milestone checkpoints get the same render at all 12 buckets, which is where the per-resolution table above comes from. Every image is measured against the teacher's render of the same prompt and seed: distance, fine-texture energy, the 16-pixel and 8-pixel grid bands, skin and flat-region grain, saturation, faces cut out at 1:1, fixed content windows (small faces in a crowd, shop interiors seen through their windows), straight-line artefacts, a graded judge, a pairwise preference against the teacher, and a blind rubric that scores each render on its own against the prompt's objects, counts, attributes and relations, with the teacher scored identically. Fifteen prompts drawn fresh from the prompt bank, never rendered before, are judged the same way at every checkpoint. Latent distances — the held-out chord gap and the two-step rollout error — are recorded but never used to keep or stop a run: this project's clearest lesson is that they reward blur, and a run that improved them while its pictures collapsed was stopped by its pictures. I have the last word at every gate, looking at the renders.

Examples

Every sheet below is three renders at the same seed: the base model as shipped, the base model at two steps without the LoRA, and the same two steps 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 2 steps cost 2. 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. Because two steps give up more than four, each prompt also gets a two-panel sheet against the teacher alone — the LoRA's render beside the 8-step one, nothing else in the frame — which is the comparison this project is judged on.

Krea 2 Turbo — 8 steps → 2 steps

One section per prompt: the three-panel comparison first, then the two-panel comparison against the teacher, 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

Turbo — 8 steps	Turbo — 2 steps, no LoRA	Turbo — 2 steps + this LoRA
as shipped · 8 NFE	the deficit this closes	strength 1.0 · 2 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

Against the teacher — this LoRA at 2 steps beside the 8-step render

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

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

---

Notes and limitations

• 🎯 Krea 2 Turbo only, at 2 steps, guidance 0.0 (cfg 1.0 in ComfyUI), mu = 1.15 — the two training sigmas are anchored to that grid.
• 🧪 Not a finished adapter. Usable at 2 steps for previews and drafts; not the 4-step LoRA's quality, which remains the recommendation for quality renders. Training continues, and a later checkpoint replaces this file only when the sweeps and I visually agree it is better.

Bonus: the 1-step extreme test

This is an extreme, out-of-spec experiment — not recommended for any use. This LoRA is trained for 2 steps; at 1 step it is half its trained step count and an eighth of the teacher's.

Stock Krea 2 Turbo and Turbo + this LoRA, each run at just one step — a single call — on the same 15 prompts, the same seed, at all 12 resolutions of the sweep, the LoRA at its normal strength (1.0). Stock Turbo returns a smear at one step: a colour field with a ghost of the subject in it. With the LoRA the same single call returns a coherent picture — the subject, the composition, the lighting and the colours are all there. What is missing is the fine detail the second step adds: skin is soft, hair and fur come out streaked rather than in strands, and the finest structure (feathers, falling snow, small text) is largely absent. That makes one step a rough preview of composition and colour at an eighth of the teacher's cost, and nothing more.

The full set is in assets/resolution_sweeps/1step-LoRA-extreme/, one folder per resolution: the LoRA's single-step render as <prompt>.jpg and the side-by-side strip as <prompt>_comparison.jpg (native on the left, LoRA on the right); stock Turbo's single-step renders are in _turbo-base-NO-LoRA-1step/. A few samples at 768×1024:

Still out-of-spec and still edge case preview-only — this is one step, not the 2-step regime the rest of this page measures.

🔭 A 1-step adapter is a possible follow-on project. The picture above is why: that a single call already holds together with an adapter trained for two suggests a dedicated one-step adapter is worth attempting once this one ships — as a booster on top of this LoRA rather than a replacement, trained by distribution matching alone (at one step there is no trajectory left to regress), and judged on seed variety as much as on detail, since one-step students are the ones that collapse to a favourite. Expectations set accordingly: a usable preview at an eighth of the teacher's cost, not the quality bar.

What's next

Training continues from this checkpoint, one recipe change at a time, each kept only if the pictures do not degrade at any resolution — aiming at the best quality two steps can give, not at matching the 4-step LoRA. The next step is already running, and it goes after what this checkpoint still gets wrong: a critic that judges the first call against the teacher's own intermediate state from the same noise, so a first call that blends two layouts is caught where the blend happens; a critic weighted toward wherever the teacher put fine detail; the photo critic and the photo floor limited to photographic prompts, so illustration, anime and 3D renders are no longer pulled toward photographic grain; detail held to the teacher region by region, with a ceiling as well as a floor; a focus on the eyes, nose and lips of faces so they sharpen while skin stays the teacher's; a colour floor, so colour at large sizes stops falling below the teacher's; and a more even mix of resolutions. After it comes prompt adherence — a critic that learns whether an image belongs to its own prompt, and stylised prompts drawn more often — held to the rule that none of it may cost the sharpness this checkpoint gained. A better checkpoint replaces this one when the sweeps and I visually agree, the same discipline as the 4-step adapter; until then the 4-step adapter remains the recommendation for quality renders, and this one is the fast preview.

License

The adapter is a derivative of Krea 2 Turbo and is covered by the Krea 2 Community License Agreement (LICENSE.pdf in this repository), as the 4-step adapter is. The attribution notice the license requires of a derivative ships with the files.