AI · Model-specific setups

Flux.1 Krea dev — Setup and Parameters

The photographic main model for RAY-L: why the aesthetic decides the choice, how to make Krea practical on tight hardware, and how to work with it iteratively.

Krea dev is architecturally identical to Flux.1 dev — the same guidance-distilled raw base, the same pipeline, the same encoders. Everything technical from 2.3.2 — memory, quantization, loaders, guidance, sampler, resolution — applies here unchanged and isn't repeated. This page treats Krea as a tool: why it's the photographic choice, how to get it small enough for weak machines, how to work with it, and what role it plays in RAY-L.

Why Krea — and why despite the effort

Of all the models I've tested locally, Krea dev is the one with the most convincing photographic feel. That's no accident, but intent: Black Forest Labs put a pure aesthetic post-training on top of the neutral Flux raw base, with the stated goal of avoiding the oversaturated "AI look" — restrained colors, controlled highlights, natural texture instead of a smooth middle. For work meant to hold up next to professional advertising photography, that's the decisive property.

On capable hardware Krea is straightforward. On the MacBook Pro with 64 GB the full weights run without fuss — one file, the standard loader, done, as described in 2.3.2. It gets interesting below that: the quantized GGUF variants bring Krea onto tight machines too, and far enough down that on adequately equipped hardware there's still room for Blender and the ControlNet alongside the model — the three parts that make up the RAY-L chain: Blender supplies the geometry, Canny the edge, Krea the image. That the RAY-L panel drives the GGUF variant directly is coming with v0.9.1.

That's exactly why Krea dev — alongside Flux.1 dev as the neutral base — is the photographic main model for RAY-L. Not because it's the fastest, but because it's the only one with this feel that fits cleanly into the ControlNet Canny regime.

The obvious counter-question: why not the much faster Flux.2 Klein 4B? Because Klein is out of the question for RAY-L — there is currently no ComfyUI-capable ControlNet Canny for Klein (the reasons are on the Klein page). Klein stays the first choice for everything without Blender and ControlNet — free generation, img2img, fast refinement. But as soon as the chain is to run over a fixed geometry, the path leads through the slower, but RAY-L-capable Krea. This page is about making that slower model practical.

Where Krea dev comes from

That the swap works so seamlessly while the aesthetic still differs is explained by its origin. Black Forest Labs provided Krea with a pre-trained, guidance-distilled 12-billion-parameter model called flux-dev-raw — the same raw base from which Flux.1 dev also derives. On top of that, Krea ran a pure aesthetic post-training, with the stated goal of producing more realistic and less oversaturated images. Flux.1 dev and Krea dev are siblings from the same raw base that only diverge in post-training. That's why the pipeline stays identical — same encoders, same node structure — and the image result is nonetheless a different one.

Black Forest Labs calls the model "opinionated" itself: a text-to-image model with a deliberately distinct aesthetic stance instead of a neutral middle, aimed at avoiding the oversaturated "AI look". In the maker's preference tests, Krea dev sits on a level with the closed solution FLUX1.1 pro. That is a vendor claim, not an independent result, and should be read as such. The reliable statement about the difference comes not from the data sheet but from the direct comparison on your own subject — and that begins with the question of how this aesthetic gets along with whatever LoRAs you give it.

A drop-in, not a new setup

The practical core in one sentence: Krea dev runs exactly where Flux.1 dev ran before, without anything else changing. The DualCLIPLoader stays on flux, the same two encoders — CLIP-L and T5XXL — stay loaded, the guidance in CLIPTextEncodeFlux stays at 3.5–4.0, the SamplerCustomAdvanced stays on euler / simple, the sampler cfg stays at 1, the one-megapixel resolution rules stay the same. None of it gets touched. Krea dev is guidance-distilled like Flux.1 dev — the same regime, the same values.

What changes is one file. The Krea weights go into the same ComfyUI unet folder that already holds your Flux.1 dev model. Then you enter their file name — including .safetensors — into the "Diffusion (UNet)" field of the RAY-L panel. That's the entire intervention: one field.

One detail that quietly trips people up: the "Diffusion (UNet)" field is not empty. It's pre-filled with the dev file name from the setup guide — the convenient zero-config for Flux.1 dev, but a trap when switching. Anyone who doesn't replace the pre-filled name with the Krea file name keeps rendering with dev unnoticed and never sees the differences this article is about. Before the first Krea run, check that the field actually holds the Krea file.

The ControlNet stays untouched too. The InstantX Flux Canny (flux-canny-instantx.safetensors) works with Krea dev just as with dev, because Krea is Flux.1-dev-compatible and uses the same ControlNet regime. ControlNet strength, Canny thresholds, seed logic — all stays as in 2.3.2.

Iteration and finalization

Two modes, and why the seed doesn't carry between them. Computing Krea at target resolution with the full step count costs minutes per image on tight hardware — too much to search for a composition with. Hence two modes: a fast iteration mode at smaller resolution with around 16 steps, to check composition, light, material and color, and a finalization mode at target resolution with 28–35 steps for the deliverable image. 28–35 is the range that proved out in my tests: below about 24 steps, quality is visibly left on the table; above 35 to 40, nothing more is added. Krea is guidance-distilled, but — unlike the step-distilled Klein — not trained for a few steps, and so it needs these real steps.

What's counterintuitive here, and often misunderstood: the seed that found a nice composition in fast mode does not carry over to the final run. A seed is not the image, only the starting noise. Which image emerges from it depends on the path the sampler takes through that noise — and both mode parameters change that path: a different step count means a different path, a different resolution a differently shaped latent grid. The same seed therefore yields two different images in iteration and in final settings, not the same image at two sharpness levels. What carries over is not the specific composition, but the prompt effect: light character, material feel, color mood, genre. Those you check reliably in fast mode — the exact image arrangement you don't.

A practical consequence follows: anyone who actually wants to hold a particular composition must either iterate in target settings from the start — slow — or nail it down via the deterministic side, the ControlNet. But the boundary has to be drawn precisely here: ControlNet decouples the image geometry from seed, resolution and steps — the edge from Blender stays fixed no matter how you turn the sampler. What it does not fix is everything inside that edge: material, surface, how light sits in the surfaces, fine texture. This latitude still varies with step count and resolution, even in the RAY-L workflow. So the controlled path takes composition away from chance — not the entire image result. That's still the decisive gain, because composition is what free prompting fundamentally can't hold reliably.

Hands lie in the preview. A concrete pitfall of fast mode: hands and fine structures regularly fall apart there — fused fingers, deformed edges. That's no reason to discard the seed. Two causes, both mode-related: at small resolution a hand simply has too little latent area to resolve cleanly, and at 16 steps the hand geometry hasn't converged yet — it only forms in the late steps. In the final run at 30 steps at target resolution, the same hand stands clean. So judge fine structure only in the final run, never in the preview.

And because ControlNet holds the geometry but not material and texture, the same discipline applies in the RAY-L workflow: even when the edge secures the composition, the deliverable image must be produced in the final run at target resolution and full step count — the material judgment from fast mode doesn't carry over one-to-one.

What each compromise costs

The practical question on tight hardware is not "does it run", but "what does each compromise cost in time". Unlike the model-comparison table on the Klein page, which measures at a fixed 1024² which model runs how fast on which machine, this matrix measures the inside of a single model: how quantization, resolution and step count shift the render time against each other — each on the 16 GB Air and the 64 GB Pro, warm (models in memory).

Level Models1 Air · 768 Air · 1024 Pro · 768 Pro · 1024
Q3 ~7.7 GB 16:27 25:39 5:42 8:25
Q4 ~9.9 GB 16:51 25:34 5:08 7:35
Q6 ~13.7 GB 20:09 ⚠ 41:22 ⚠ 5:40 8:12
Q8 ~17.6 GB ✕ ✕ 3:30 5:57
fp16 ~33 GB ✕ ✕ 3:04 5:29

Minutes:seconds, 30 steps, warm (model resident). ⚠ memory pressure yellow — the time rises as paging begins. ✕ not practical: Q8 over 60 minutes (the weights exceed 16 GB), fp16 not loadable on 16 GB. 1 Transformer + T5 resident, measured: transformer Q3 5,019 MB · Q4 6,647 MB · Q6 9,518 MB · Q8 12,251 MB; T5 Q3 2,676 MB · Q4 3,249 MB · Q6 4,214 MB · Q8 5,314 MB.

Three things can be read from the table, and the first is the most important: on the Air, memory is the divider, not the quant level. Q3 and Q4 take practically the same time (a good 16 minutes at 768, a good 25 at 1024) — as long as memory stays green, it's not model size that decides the time, but the compute load per step, and that's nearly equal between Q3 and Q4. Only Q6 breaks out (41 minutes at 1024), exactly where memory tips to yellow and the system starts to swap. Q8 exceeds it entirely. It's not the level that costs the time, but the moment it outgrows the memory.

Hence the recommendation for 16 GB: Q4, not Q3. Both run at the same speed and both in the green — but Q4 holds noticeably more detail, and with Q3 the fingers fall apart first. Q4 is the highest level that still runs fully green on the Air: the sweet spot of quality and runnability. You reach for Q3 only when download size matters. (This finger break-down is a different one from the preview section above — here the strong quantization throws precision away, there resolution and steps were missing.)

On the Pro, fp16 wins — and more RAM doesn't replace compute cores. Where memory is plentiful, the time even falls with rising level (Q8 faster than Q3, because computationally simpler to unpack), and fp16 is the fastest of all, because it doesn't have to be unpacked at all — on Apple Silicon GGUF is dequantized to bf16 at every step, fp16 is already in the compute format. The gap between Air and Pro on green memory is roughly threefold — that's simply the GPU core difference (10 versus 32 cores). At Q6/1024, where the Air swaps, it widens to about fivefold; that surcharge is the swap. The lesson for the hardware choice: more working memory shifts the line at which a level runs at all — never the one at which it's fast. An Air with more RAM would bring the large quants to life, but with its few cores would never reach the Pro times. On Apple Silicon, memory doesn't compensate for missing compute cores.

The pure compute time scales linearly with the steps, because each step costs the same — at Q4/1024 roughly 50 seconds per step on the Air, roughly 15 on the Pro. Any other step count you work out from that. And the fp16 value on the Pro (5:29 at 1024², 30 steps) is at the same time the bridge to the Klein page: it's in the same ballpark as the roughly 6 minutes listed there for Flux.1 dev — Krea is, after all, the same model in a different paint job.

LoRAs and the Krea aesthetic

Because the architecture is identical, the same holds for LoRAs as for the ControlNet: a LoRA trained for Flux.1 dev loads and works on Krea dev too — and vice versa. Technically the two models are interchangeable. More interesting than whether a LoRA loads is how well it gets along with Krea's aesthetic.

Krea's aesthetic is not a setting you dial away, but trained into the weights — a force in whose direction the image is pulled. A LoRA works either with that force or against it. A character or identity LoRA teaches content — facial structure, who the person is — and thus lies across the base's aesthetic; it rides along on both models and stays robust, because it takes nothing away from the Krea feel. A style LoRA, by contrast, teaches exactly what Krea already brings: feel. Here two aesthetics overlap, and the same style LoRA can land differently on dev and on Krea — on one base it paints into an empty space, on the other against an already present signature.

This can be checked directly with a character LoRA. Train the identity of a synthetic person and render it with identical seed and prompt once on dev and once on Krea, and the person should stay the same — the identity comes from the LoRA — while the feel differs, because it comes from the base: the same person, two aesthetics. At the same time this is the cleanest method for isolating Krea's aesthetic at all: with the subject held constant by the LoRA, any visible difference between dev and Krea is attributable to the base aesthetic alone and nothing else.

Getting Krea dev

The drop-in character shows already at download: exactly one file is new to download — the Krea diffusion model. CLIP-L, T5XXL and the VAE (ae.safetensors) are the same as in the Flux.1 dev setup from 2.3.2 and are already in place. The new file goes into the same folder as your dev model; you enter its name into the "Diffusion (UNet)" field of the RAY-L panel.

Which variant is right is decided by the hardware — by exactly the ladder from 2.3.2. The short version, because it's often told backwards: fp8_scaled is the choice on Nvidia with little VRAM — not generally "on weak hardware". On Apple Silicon fp8 doesn't compute; there it's fp16 while memory lasts, and GGUF otherwise.

Format File Size Source Platform
fp16 (full) flux1-krea-dev.safetensors ~23.8 GB black-forest-labs/FLUX.1-Krea-dev all
fp8_scaled flux1-krea-dev_fp8_scaled.safetensors ~11.9 GB Comfy-Org/FLUX.1-Krea-dev_ComfyUI Nvidia only
GGUF flux1-krea-dev-Q*.gguf 4.02–12.7 GB QuantStack/FLUX.1-Krea-dev-GGUF all

Transformer file → ComfyUI/models/unet/ (in newer ComfyUI versions also diffusion_models/). For GGUF, pick the level by memory: anchor points Q3_K_S ~5.23 GB, Q4_K_M ~6.93 GB, Q6_K ~9.85 GB, Q8_0 ~12.7 GB. For the matching T5XXL variants (fp16, fp8_scaled, GGUF), the encoder table from 2.3.2 applies unchanged.

For a direct quality comparison between dev and Krea at an identical quant level, pair the _K_S levels: city96's dev GGUF carries only _K_S at Q3/Q4/Q5, QuantStack's Krea GGUF carries both. Only equal levels are cleanly comparable — otherwise the model difference mixes with a compression difference.

Full weights (fp16) — flux1-krea-dev.safetensors, from the official Black Forest Labs repository. Highest quality, for 24 GB VRAM and up, or the fp16 path on a Mac with enough unified memory. The download requires agreeing to the license — exactly the non-commercial license from the License section.
huggingface.co/black-forest-labs/FLUX.1-Krea-dev

fp8_scaled — for Nvidia — flux1-krea-dev_fp8_scaled.safetensors, ~11.9 GB, repackaged by Comfy-Org. Halved VRAM at native fp8 compute — the practical choice on Nvidia cards with little VRAM. On Apple Silicon of no use, because fp8 isn't computed there. Same non-commercial license as the full weights.
huggingface.co/Comfy-Org/FLUX.1-Krea-dev_ComfyUI

GGUF — the path on tight Mac memory — flux1-krea-dev-Q*.gguf from QuantStack, in levels from Q2 (~4 GB) to Q8 (~12.7 GB). Runs natively on Apple Silicon through the Unet Loader (GGUF) — not the standard loader. Setting that node up in full — the custom node (ComfyUI-GGUF) and the required Python package — is covered in the setup part of the following Klein page. Pick the level by available memory; the smaller it is, the more likely everything stays in RAM and the render time falls, but the more visible the quality loss. Same non-commercial license.
huggingface.co/QuantStack/FLUX.1-Krea-dev-GGUF

License

Krea dev is under the same license instrument as Flux.1 dev — the FLUX Non-Commercial License from Black Forest Labs (version 2.0). This is not the Apache 2.0 license of Flux.2 Klein 4B.

Two things must be kept apart. The generated images belong to the user — Black Forest Labs claims no ownership of the outputs; they may be used and sold for any purpose, with the single exception that they may not serve to train a competing model. Running the model is the separate question: the weights are licensed for non-commercial, non-production use; commercial or production operation requires a separate license from Black Forest Labs. That the images belong to the user does not settle this second question.

Independent of the license, AI-generated images are to be labeled as such where applicable by law.

The license text has changed across versions; what governs is the current version on bfl.ai. More on this in 2.1.4 — Understanding license models. Guidance, not legal advice.

When Krea, when dev, when SDXL

Krea dev costs nothing extra over Flux.1 dev. It's the same 12-billion-parameter model with the same memory footprint and the same speed — the memory, encoder and sampler requirements from 2.3.2 apply unchanged. The decision between dev and Krea is therefore not a hardware question but an aesthetic one.

Krea dev — when the photographic feel matters: restrained saturation, controlled highlights, natural texture. For RAY-L the photographic main model, and on capable hardware the default, because the aesthetic gain comes at the price of zero extra effort.

Flux.1 dev — when the neutral dev base is wanted as a starting point, or when a workflow is already tuned and verified against dev and you want to keep its exactly known behavior. LoRAs are no reason for this choice: they run on both models.

SDXL — for fast iteration, resource-light hardware, or a LoRA ecosystem that doesn't yet exist for Flux.

The switch between dev and Krea costs nothing and is reversible: one field reset, and the next run is dev again. It's exactly this frictionlessness that is the reason to place Krea dev at the same spot where dev stood before — not as a new model with its own setup, but as the more photographic preset of the same path.