A fourth model: Krea 2 Turbo
- Krea 2 Turbo, by Krea, joins Z-Image Turbo,
Qwen-Image-2.1 and Anima in the app, without Developer Mode. A 12.9-billion-parameter DiT, the
largest of the four and the slowest, that reads the prompt with Qwen3-VL-4B (twelve of its layers,
merged by a learned fusion) and decodes with the Qwen-Image VAE. Aesthetic images, from
photography to painting. - Its recipe: 8 evaluations, no CFG. Text-to-image, the rectangular formats, the four solvers
in Developer Mode, each checked against diffusers on Krea's own schedule; LoRAs (ai-toolkit
layout, read as diffusers and PEFT read it; ComfyUI gives the same update), applied whole on the
Compact and the Light and judged against the reference, the time modules included;
no editing by instruction, and no Detail: on this model its bell falls where the picture is still
being decided, and redraws it instead of sharpening it. Subtle variations use 0.05 (0.1 changes
the person). - Times: on an M1 Pro with 16 GB, Standard, seed 42, 8 evaluations, queued in the app: 1024² in
145.6 s, 1024×1536 in 216.9 s with Faster Rendering (below, on by default); 221.1 s and 355.3 s
with every evaluation at full size. - Checked against the reference: at 1024², the denoiser's output is 1.44·10⁻⁴ from diffusers
in fp32. - Standard, Compact or Light: 34.4 GB (the publisher's bf16), 19.5 GB (the DiT and the text
encoder in int8 convrot, as Comfy-Org publishes them) or 12.8 GB (the DiT in GGUF Q4_K_M, as
vantagewithai publishes it, with the Compact's text encoder). The Compact and the Light are
checked to the bit against their reference dequantization. - Nothing comes from Krea's own repository: it asks for a Hugging Face account, and the app has
no sign-in. Each file comes from an open copy proven identical: the DiT and the text encoder from
Comfy-Org (the DiT the very same file, the encoder equal tensor for tensor), the VAE from
Qwen-Image (Krea's fp32 VAE is its bf16 one widened, value for value), the tokenizer from
Qwen-Image-2.1-Turbo (the same file); Krea's configuration files are embedded as published. The
license sheet says so, and links the card of every repository downloaded from. - Within the budget: its memory need is computed from the model's shapes before the first
computation, as for the other three. Peaks at 1024², the engine alone: 3.07 GB in Standard
(3.51 GB at 1024×1536), 2.20 GB in Compact, 1.35 GB in Light. - License: Krea 2 Community. Commercial use under $1M of annual revenue; a content filter is
mandatory when the model is deployed. The app shows the license in full before the first byte is
downloaded, with the attribution it asks for.
Faster Rendering, on by default
- A new setting, at the head of Settings, on by default, for all four models. From 1024 px
on each side (1024², 1024×1536, 1536×1024…), the first evaluations run on the half-size grid — 3 of 8 for Z-Image,
Qwen-Image-2.1 and Anima, 4 for Krea 2, whose shifted schedule keeps its first noise levels
higher — then the rest at full size. Still 8 evaluations; one at half size costs about a quarter
of a full one. No usual portrait or landscape format qualifies: the half of 832×1216 would fall
under 512 px on one side. - Times, on an M1 Pro with 16 GB, Standard, seed 42, queued in the app (on / off): at 1024²,
Z-Image 84.5 / 117.7 s, Qwen-Image-2.1 103.7 / 142.7 s, Anima 32.7 / 44.4 s, Krea 2 145.6 /
221.1 s; at 1024×1536, on: 131.0 s, 161.7 s, 52.5 s and 216.9 s (Krea 2 off: 355.3 s). In
Light, on, at 1024²: Z-Image 90–91 s, Qwen-Image-2.1 111.0 s, Anima 35.4 s, Krea 2 153.8 s — the
Light saves disk and memory (Krea 2's peak in the app: 1.55 GB), not time. - Why it stays clean this time. The half-size steps dropped in 0.8.2 decimated the state and
enlarged the velocity: that velocity carried no high band, so the fine noise of the state was
never taken away while they ran (sand on skin and walls), and the decimation's aliasing reached
the model as texture (cracks). Now the half grid is fed the 2×2 mean of the state plus the low
band of the starting noise — antialiased, at the right noise level —, and the velocity brought
back to full size is the one that leads the full state to the enlarged clean estimate: it takes
the fine noise away at the pace a full step would, and the state stays exactly on the recipe's
path. Each model's number of half-size evaluations was judged by eye on two prompts, a portrait and the library, at the
same seed: no sand, no cracks, freckles, hair and book
spines intact; one step more, and the freckles fade, the shelves turn to blocks. - Another image, not a degraded one. With the same seed, the picture is not the full-size
recipe's: the composition is decided in the first steps (the same scene, sometimes another
person). Not with a LoRA, Detail, an edit, another number of steps or another schedule. - Off, nothing moves: every evaluation at full size, the same bits as before, the image checked
against diffusers. The deviations from the reference published for each model are for that
image.
The engine measures your Mac before its first render
- No render without a map of this Mac. Before the very first render, and again whenever the
Mac, macOS or the app changes, the app measures the chip, in about 30 to 40 seconds and without any
model, then renders with what it found; the sidebar says so while it runs. Until 0.11, the map
was optional, and the defaults were those of an M1 Pro. - What it measures: the real matrix products of the four DiTs' blocks on the GPU, on the CPU's
matrix unit (AMX) and on both at once, at several depths and widths; attention through three
kernels; products read straight from published int8 and GGUF Q8_0 weights; bf16 products on the
GPU's tensor units (macOS 26, Metal 4). Every output is checked against the exact result, computed
in double precision. - What it decides: a kernel turns on only if it computed right and beats the default by at
least 5 %, or by the drift the measure itself saw if that is larger, at both a 512² and a 1024²
image's sizes. The GPU + AMX co-execution, which turned on by chip name until 0.11, is now off
everywhere unless measured faster, and the share each engine takes is computed for each product's
shape instead of one frozen share. On the M1 Pro (18/10/2026): co-execution on (×1.30), attention
split by heads between the GPU and the CPU on (×1.49, now also for Krea 2's grouped heads), flash
attention off (×1.05, inside the margin), the int8 product on, the Q8_0 product off (×0.43), the
bf16 tensor product off (×0.53). Another chip decides from its own measurements. - Published 8-bit weights read as they are: where the map turns them on, the int8 weights of
Compact versions (such as Krea 2's and Qwen-Image-2.1's) and the GGUF Q8_0 weights (Anima's Compact) are
multiplied as published, instead of widened to fp32 first; the activations and the sums stay
fp32. Where the GPU's tensor units multiply faster, the publisher's bf16 weights are read the same
way. Each path is checked against the reference. - The map changes the speed, not the picture beyond the arithmetic it checked; the same Mac
with the same map still gives the same bits. - « Chain », at the head of the rack, opens the measure: orange, with its chip, until this Mac is
measured, a green chip after. Measure This Mac (Help menu) shows the map and what it
decided; « Open the Issue » now copies the report and opens a short GitHub form to paste it into,
since the report no longer fits in a link; « Copy JSON » serves whoever sends it another way.
Closer to the reference, to the rounding
- The arithmetic rounds where the reference rounds: Euler steps, UniPC's corrector (solved as
LAPACK does), the integer timesteps diffusers gives the DiT under DPM++ 2M and UniPC, the schedules
of Z-Image, Anima and Krea 2, every model's rotary position tables, and the gated residuals and
modulations (a·b + c in two roundings, as torch computes it). Every picture changes by a few
units in the last place, and each model stays within the reference's own distance of an fp64
computation: an image made with 0.11 does not come out again to the bit. - Z-Image at 832×1216 and 1216×832 changes image: its image tokens are now padded to a multiple of
32 as diffusers does; those two formats were 16 tokens short. - LoRAs reach every module the reference applies them to: on Z-Image the outer modules (patch
and caption embedders, time embedder, final layer), on Krea 2 the time embedding and modulation,
which were imported and then ignored. A LoRA aiming at a module the engine does not apply is
refused before any computation, with the reason. - Qwen-Image-2.1 edits keep a reference's transparency as diffusers does: the VAE reads the
image with its alpha, only the copy the encoder sees is pasted on white.
Sturdier
- A broken render is no longer delivered. If a render comes out with non-finite values (a
black image), the app says so and keeps nothing, instead of adding it to the history as a
success; in a batch, only that image is dropped, the others are still delivered. Nothing non-finite is carried from one render to the next: the render cache neither
keeps nor reads back such a value, and a Qwen-Image-2.1 edit keeps its attention keys and values
only behind a finite first step (one bad value there used to blacken every later edit of the same
image for the session); a VAE pass the GPU refuses is reported instead of ignored.silicontrolreports it as"error"with the code
non_finite_image, and the verdict ofwait(and theendline offollow) now carries the
engine's"warnings". - Formats per model: Qwen-Image-2.1 wants sides in multiples of 32, Anima at most 2048 px; both
are refused before any computation, and the size field says the chosen model's rule. - The render cache lasts one session: emptied at launch and at quit, it no longer counts in the
Models window's used space. - Importing never downloads: a LoRA or a fine-tune whose model is not installed is refused, and
the app says which model to install first; real errors (a full disk) are no longer swallowed. - Hostile files are refused: a LoRA whose alpha pattern would make the matcher backtrack without
end, non-finite alphas or strengths, rank 0, a GGUF Q8_0 block with a non-finite scale. - The memory need counts what it missed: the scratch of rotated int8 weights (Krea 2's
Compact overran its text stage by 7 MB), Z-Image's padded tokens. A long Krea 2 prompt, past about
170 tokens, no longer stops with « arena exhausted ». - Attention without the head split is sliced by queries where it would exceed the GPU's matrix
limit (Z-Image at 1024×1536 on a Mac whose map turns the split off). - The flash attention kernel computes in safe math and lost two branches that were never used and
could misread a key; the int8 and Q8_0 products no longer write past the GPU's columns; a damaged
download registry is ignored; the queue waits for an enlargement or a grid sheet to finish;
silicontrolrequests have a deadline.
Interface
- A LoRA takes its file's name: an imported LoRA is called by its file, no longer by the name
written in its metadata, often a trainer's default (« my first lora v1 copy copy »). The
trainer's name, and the trigger words when the file states them beyond doubt, show in a tooltip on
the LoRA, in the rack and in the Models window. LoRAs imported before keep their name. - Krea 2's license sheet shows the whole license; hairlines and fills a little stronger, secondary
text where it informs, one export symbol; the Settings window opens centered; the import dialog's
sentence is shorter, so the Finder's sidebar keeps its width. - For developers: Siliconed ships an app, not a library. The library product and its API
documentation are gone;swift buildbuilds the app andsilicontrol.
Timings are measured on a MacBook Pro M1 Pro with 16 GB.