Arthemy Z-Image Tuner (Simple)

Z-Image is 6B of single-stream diffusion transformer (S3-DiT): fast, near-Flux quality on a 12GB card, and a complete black box once the prompt disappears inside it. Arthemy Z-Image Tuner (Simple) slices its 30 layers into six "positional blocks" and hands you a slider for each one. You push a block's weights up or down and the image responds - no training, no LoRA file, no checkpoint merge. That's the whole pitch: the difference between "I like the composition but not the detail" and a full model swap, resolved with one widget.

It's from the same author who's been shipping "tuning suites" for a while (the Arthemy Comics Civitai models and the earlier Anima Tuning Suite come from the same hand). The framing is consistent: play with the weights, don't retrain.

How it works

The node walks the diffusion model's state dict, reads the layer index out of keys like layers.07.attention..., and multiplies that layer's weight and bias tensors by your slider value - in place, in memory. Because it edits the live model, you must feed it from ArthemyTunerLoader, which reloads pristine weights from disk every run. Skip that and your edits accumulate across queues.

The 30 layers are grouped into 6 blocks of 5:

• Block 1 (layers 00–04) - initial composition
• Block 2 (05–09) - early feature definition
• Block 3 (10–14) - mid-level structure
• Block 4 (15–19) - core processing
• Block 5 (20–24) - high-level details
• Block 6 (25–29) - final output resolution

Those labels are the author's educated guesses, not gospel. The README is upfront that the boundaries are experimental because a single-stream architecture is "quite chaotic" - layers bleed into each other. Treat the blocks as starting points and trust your eyes over the names.

On top of the blocks you get three cross-cutting groups: global_attention (scales attention mechanisms - how parts of the image relate), global_mlp (scales the feed-forward networks - each layer's raw processing power), and the auxiliaries embedders_strength (how hard the initial signal is injected) and refiners_strength (dedicated noise/context refinement weights). A slider on an attention block multiplies into both the block and global attention values.

The mode question

• mode - Real Value or Soft Value. Real makes your slider the literal multiplier: 2.0 doubles those weights, which is fun for about five seconds before the image disintegrates. Soft Value maps the input range through 1 + (value − 1) × 0.2, so a slider of 2.0 only nudges to 1.2 - gentle, and the safe place to start.
• base_strength (0–10) - a master gain on top of everything, but it only bites in Real Value mode.
• unsafe_tune_normalization - leave this off. By default the tuner locks normalization layers, because scaling norm math is how you get artifacts or genuinely "fried" images. Flip it on only if you want to deliberately break the model.

Wiring and workflow

ArthemyTunerLoader ──> Arthemy Z-Image Tuner (Simple) ──> KSampler ──> SaveImage

For Z-Image Turbo, add a ModelSamplingAuraFlow node - the community's most-repeated tweak is shift 7 instead of the default 3. And if you land on a tuning you like, chain the ArthemyZImage_Saver off the tuner to freeze it into a standalone file.

Common issues

• Everything's fried - you're in Real Value with aggressive values, or you toggled normalization on. Drop back to Soft Value and small deltas (0.8–1.2).
• Output changes between runs - that's either a missing ArthemyTunerLoader (edits compounding) or, on Turbo, plain seed sameness. Base (added in pack v2.2.0) has real seed diversity; Turbo is near-identical across seeds by design.
• Nothing seems to happen - some blocks genuinely have little visible effect for a given seed. That's the experiment. Crank one block hard, look, then move on.

It's not a magic bullet - the author says it best in the README: the boundaries are a guess and the single-stream architecture is chaotic. But as a way to actually play with a model instead of just prompting it, this is the node you'll reach for.