Explore small, finish big

The obvious move is to skip all of this and just ask for 2048×2048 up front. It doesn't work, and Chapter 2 already told you why: every model has a native resolution it was trained at. Render close to it and the model knows how a whole scene fits together. Render 2× past it and the model does the only thing it can — it tiles what it knows. You get twinned subjects (two heads, four arms), stretched anatomy, a horizon repeated halfway up the sky. It's not a bug you can prompt away; it's the model running out of things it has ever seen at that size.

And it's expensive in a way that stings. Compute grows roughly with pixel count, so 2048 costs about 16× what 512 does — you're paying quadruple-digit percentages for the privilege of a worse image.

So professionals invert the whole thing. Explore at native: cheap, fast, correct composition, many candidates. Pick the winners. Then upscale only those. The rest of this chapter is that second half — three ways to get bigger, one workflow that combines them, and the exact failure modes to watch for.

"Upscale" is three genuinely different operations wearing one word. Plain English first:

• Classical resize (bicubic, Lanczos) — the same information spread over more pixels. Bigger and blurrier. It invents nothing, which makes it honest and dumb: a 512 image resized to 1024 has exactly one 512's worth of detail, just softer. Every image editor since 1995 does this.
• An AI upscaler (the ESRGAN family and its cousins) — a network trained to hallucinate plausible texture as it enlarges. Crisp edges, invented detail, no prompt needed, and fast. The catch: it invents generic detail — the same learned idea of "skin pore" or "leaf" everywhere, because it's only looking at the pixels, not at what your image means.
• A diffusion pass — Chapter 5's img2img at low strength, run over the enlarged image. The model re-denoises at the new size, steered by your prompt and your LoRAs, so it invents detail that belongs to this picture: fabric weave on the fabric, strands in the hair, bark on the tree. Best quality, slowest, and — because it's still a repaint — it can drift.

The rule of thumb: classical resize is a step inside other workflows, an AI upscaler is your everyday finisher, and a diffusion pass is the premium finisher. Drag the same source through all three and watch what "detail" means in each:

Here's the single best-practice pattern, the one every UI eventually grows a button for (often labelled "hires fix"): don't pick one of the three — chain them.

1. Generate at native, where the model is sane.
2. Enlarge ~1.5–2× — classical or AI, either works as the scaffold.
3. Run a low-strength diffusion pass (~0.2–0.35) at the new size.

Why it works is the whole point of the chapter in one sentence: composition gets decided at the size where the model won't twin subjects, and detail gets added at the size where detail counts. The first render owns the layout; the second pass owns the texture.

And the discipline that makes or breaks it is strength — the exact same dial from Chapter 5. At 0.2–0.35 the pass refines: it sharpens edges and paints in believable micro-detail while leaving the picture recognisably itself. Push past 0.45–0.5 and it stops refining and starts re-imagining — faces change, and your Chapter 7 character quietly drifts off-model into someone else. On comic pages, keep it ≤ 0.3 and keep the character LoRA loaded during the pass, so the detail it invents is your character's detail. Pick a factor, then find the sweet spot:

Notice the cost bar climbing with the square of the factor — that second pass at 4× is doing real work on a lot of pixels. Which is exactly why you explored at native first: you're only paying it on a keeper.

Past roughly 2K on a side, a single diffusion pass runs your Mac out of memory — there's only so much the model can hold at once. The trick is embarrassingly simple: cut the enlarged image into overlapping tiles, run the diffusion pass on each tile separately, then blend the overlaps back together. Nine small passes instead of one impossible big one.

Two tile sins produce every ugly tiled upscale you've ever seen:

• No overlap → grid seams. Tiles processed edge-to-edge don't know about each other, so their brightness and texture don't line up at the boundary. You get faint vertical and horizontal lines carving your sky into a tic-tac-toe board.
• Too much strength per tile → disagreement. Crank the per-tile strength and each tile re-imagines its own patch independently. One cloud becomes six different clouds; a smooth sky turns patchy, tile by tile.

The fix for the second sin is the same discipline as before — keep per-tile strength gentle. And one prompt rule: describe the whole image to every tile, not the scrap of it that tile contains, or the top-left tile will decide it's a close-up of grass. Paint a mask, run the sweep, and provoke both sins:

Node-based tools (ComfyUI and friends) automate all of this — "tiled upscale" nodes, plus a ControlNet-tile model (Chapter 5) that shows each tile the low-res original so it stays on-story. On the DiffusionBee side, this is where you soft-pedal: keep single-pass upscales to modest sizes, lean on an AI upscaler for the really big jumps, and treat the exact buttons as a moving target across versions. The concept — overlap and blend, gentle per-tile strength — carries over to any tool you graduate to.

Some regions deserve special treatment, and the face is always the first — human eyes forgive a blurry tree and never forgive a melted eye. Two targeted tools:

• Face restorers (GFPGAN, CodeFormer, and the like) — networks trained on nothing but faces. Point one at a botched face and it un-melts the eyes, rebuilds the teeth, straightens the features. The failure mode is over-smoothing: crank it and skin goes plastic, poreless and mannequin-like. Use it at partial strength when the tool lets you, so it fixes the structure without ironing out the humanity.
• Inpainting as a detail injector — Chapter 5's inpainting, pointed at quality instead of content. Mask the face (or the hands) at the upscaled size and inpaint it. Because the model renders the masked region at its full native resolution, you're effectively super-sampling just that patch — a face rendered as if it were the whole 512 image, dropped back into your 4K frame.

And the order matters. For portraits: upscale first, then fix faces at the big size. Restore or inpaint a face while the image is still small and you've only enlarged the fix's own limits along with everything else — do it after the enlargement and the repair lands at full resolution where it counts.

There's no universal "upscale" setting, because different media break in different ways. The finisher that rescues a photo will smear a watercolour; the one that keeps ink crisp will look wrong on skin. Match the tool to the job:

One caveat that trips everyone up eventually: sharpening is not detail. A sharpen filter boosts contrast at edges the image already has — it cannot add information that isn't there. Push it and you get halos: bright and dark rims hugging every edge, the unmistakable sign you asked contrast to do a detail generator's job. When an image looks soft, the answer is a diffusion pass that invents real detail, not a sharpen slider that just shouts about the detail already present.

Strip away the models and the whole chapter is one shape you already know: composition. Each finisher is a function Image => Image; the two-pass workflow is just two of them composed; and tiling is nothing but map over the tiles and a careful reduce to blend them back. Flip between the languages — the shape is identical.

Here's the whole book firing in sequence — the end-to-end recipe for taking a comic page, a portrait, or a landscape from idea to something you can print. Every step is a dial you now know by name:

1. Explore at native, knobs frozen. Lock your steps, sampler, and CFG (Chapter 2) and your recipe/LoRAs (Chapters 3–4). Generate many candidates cheaply.
2. Pick winners by seed. Note the seeds of the frames you love (Chapter 2) — those are your keepers, reproducible pixel-for-pixel.
3. Two-pass upscale, LoRAs still loaded. Enlarge 1.5–2× and run the low-strength diffusion pass with your style and character LoRAs active (Chapters 3, 7) so the invented detail is your look and your character.
4. Inpaint faces and hands at size. Mask the precious regions and repair them at the upscaled resolution (Chapter 5), super-sampling exactly where it matters.
5. Apply the per-medium finisher. Photo, illustration, lineart, or print — the table above (this chapter). Tile up to 4K if you're going to the wall.
6. Letter & composite outside the model. Speech balloons, borders, page assembly — done in an image editor, never in the model (Chapter 7).

Eight chapters ago, an image was a slot machine: type words, pull the handle, take whatever falls out. Now it isn't. You start from static and a seed, shape it with knobs, bend it with patches, steer it with pictures and words, hold a character steady across a cast, and finish it at the size your work deserves. Every stage from pure noise to a printed page has a dial — and you know every one of them by name. Go make the big version.