If your generated portraits look fine at thumbnail size and fall apart when you zoom into the eyelashes, the denoiser may not be the problem. In most Stable Diffusion-style pipelines there is a compression step that sets a hard ceiling on fine detail before generation even begins. This article explains where that ceiling comes from, what removing it changes, and how to measure it yourself in about ten minutes.
The compression step nobody talks about
Latent diffusion does not denoise pixels. It denoises a compressed representation produced by a variational autoencoder. A 1024 by 1024 RGB image is encoded down to a latent grid eight times smaller on each side — 128 by 128 — with a handful of channels instead of three. The diffusion model works entirely in that space, and a decoder turns the finished latent back into pixels at the end.
The reason is compute. Denoising a 128 by 128 grid across dozens of steps is enormously cheaper than doing it at full resolution, and that trade is what made consumer-GPU image generation practical in the first place. Latent diffusion is the reason you can run a capable model on a desktop card at all.
The cost is that the autoencoder is lossy, and the loss is not evenly distributed. It falls hardest on high-frequency content: individual eyelashes, skin pores, the weave in fabric, small text, water droplets, distant faces, fine repeating patterns. Those are exactly the things that make an image read as photographic.
Why it is a ceiling and not just a tax
Here is the part that changes how you debug. Even a hypothetically perfect diffusion model, producing the mathematically ideal latent, cannot exceed what the decoder is able to reconstruct. The autoencoder's reconstruction quality is an upper bound on the entire pipeline.
You can measure that bound directly. In ComfyUI, take a real photograph, run it through VAE Encode and then straight into VAE Decode with no sampling in between, and compare the result to the original at 100 percent zoom. Whatever detail is lost in that round trip is detail no prompt, sampler, step count, or CFG value will ever recover.
This is also why later model generations widened their latents. The move from four-channel autoencoders in the Stable Diffusion 1.x and SDXL era to sixteen-channel ones in the Stable Diffusion 3 and FLUX generation was, in large part, about raising that ceiling. More channels means less thrown away per latent pixel, which is why newer models render small text and fine texture noticeably better even at similar parameter counts.
What pixel-space models do differently
The other option is to skip the autoencoder and generate in pixel space directly. There is no compression, so there is no reconstruction ceiling — the model's output is limited only by the model.
The obvious problem is cost: full-resolution generation is far more expensive per step, which is why the approach was set aside in the first place. Designs that revive it generally attack the cost with architecture rather than brute force — multi-stage or cascaded generation, efficiency-oriented transformer blocks, and fewer effective steps.
HiDream.ai's HiDream-O1-Image, unveiled in May 2026, is an example of the pixel-native direction reaching a competitive open-weight release: roughly eight billion parameters, no VAE, and an MIT licence. It first appeared anonymously on a public image leaderboard under the codename Peanut before its origin was disclosed. Its authors published benchmark comparisons against other frontier models; as with any vendor-run benchmark, treat those as a reason to test it yourself rather than as a settled result.
The same release also folds in a reasoning step that runs before generation — the model plans the composition and expands the brief before any denoising happens, rather than treating the prompt as a single embedding. Several labs are exploring variations of this idea, and it mainly helps with prompts that contain counting, spatial relationships, or multiple interacting subjects.
A stress test for fine detail
Generic prompts will not surface the difference between these architectures. You need a prompt that demands high-frequency texture. This one, written for a reference-image workflow where you supply your own photo, is a good one:
Using this photo as reference, create a hyper-realistic, ultra-detailed
portrait showing only the left half of the face submerged underwater,
one eye in sharp focus positioned at the far left of the frame, light rays
casting caustic patterns across the skin, water droplets and bubbles adding
depth, vibrant cinematic lighting with soft shadows and crisp highlights,
photorealistic textures including skin pores, wet lips and eyelashes, subtle
subsurface scattering, surreal dreamlike atmosphere, shallow depth of field,
underwater macro perspective.
Every clause in it is a detail trap. Caustics are fine, high-contrast, non-repeating patterns. Bubbles and droplets are small specular highlights. Pores, eyelashes and subsurface scattering are precisely what a lossy autoencoder smooths away. Run it on two models and compare at full resolution, not in a grid of thumbnails.
A ten-minute evaluation protocol
- Round-trip a real photo through encode and decode on the latent model. This is your ceiling.
- Generate the same prompt on both models at their native resolution, same aspect ratio, several seeds.
- Zoom to 100 percent on one eye. Lashes should be separable strands, not a dark smear.
- Add a small text element to the prompt — a label, a sign — and check whether the glyphs are letters or texture.
- Try a fine repeating pattern: chain-link fence, knitted wool, distant crowd. This is where compression artefacts are most visible.
- Skip the upscaler during evaluation. Detail-hallucinating upscalers will mask exactly the difference you are trying to measure.
Licence, not just weights
One practical note on open releases: downloadable weights and a permissive licence are different things. A permissive licence such as MIT allows commercial use without a revenue threshold or a separate agreement. Many other open-weight image models ship under research-only or non-commercial terms, or under bespoke licences with usage conditions attached. If the output is going into client work or a product, read the licence file in the repository before the model reaches your pipeline — not after.
Takeaways
- In latent pipelines the autoencoder, not the sampler, is usually what caps fine detail.
- Measure that ceiling with an encode-decode round trip before blaming your prompt.
- Wider latents raised the ceiling; pixel-space generation removes it, at a compute cost.
- Evaluate with high-frequency prompts at full zoom, upscalers off.
- Check the licence, not just whether the weights are downloadable.
Top comments (0)