Drag images so they overlap and they form a Stack — a dashed outline labelled “Stack (N)” that keeps a set of images together. You can also place an Empty Stack first and fill it later. A stack’s main job is compositing: combine the best parts of several renders into one image, much like stacking and flattening layers in Photoshop.

When to use

You want to composite — take the sky from one render, the facade from another, and a foreground from a third, and merge them into a single image.
You’ve generated several variations of the same view and want to compare or tidy them.
You want to feed several references into one render — see below.

Stacks as a bundle of references

A stack also acts as a single bundle when it feeds another image. Attach a paperclip to any image in a stack and every image in that stack becomes a reference for the target — one connection line, not one per image.

This is why uploading several reference files at once through the prompt bar’s paperclip drops them on the canvas as a stack: they arrive already bundled behind a single connection. Drag an image out of the stack and it stops feeding the render; drop another one in and it joins.

Empty stacks — a stack before it has images

An ordinary stack only exists while images overlap: drag the second-to-last image out and it dissolves. An Empty Stack is the same thing made permanent. Add one from the Add element button and you get a dashed box that holds its place whether or not anything is in it.

Filling it. Drop images inside, or drag existing ones in. A stack claims an image when the image’s centre lands within the box — so an image can be much larger than the stack that holds it, and the outline grows to wrap what it holds. You can also drop image files straight onto it from your computer.

It survives being emptied. Drag every image out and the box stays, ready to be filled again. That is the whole point: because it exists before its contents do, you can wire a pipeline around a slot that is still empty. A prompt widget or a paperclip connected to an Empty Stack keeps that connection through fill, empty and refill — which is what makes a pipeline shareable as a template, with the recipient supplying the images.

Once filled, it is just a stack. Merge, Compare, Reorder and Expand all work exactly as below, and the outline hugs its contents with the same margin as a stack you made by piling images up.

Its headline tells you its role. An unwired one reads “Empty Stack”. Wire it into a pipeline and it names the job instead — “Reference Stack”, “Render Stack” or “Result Stack” — so you can read a template’s plan before any image exists.

Its size is fixed when you create it. There is no resize handle: a filled stack takes the size of what it contains, so the box only ever describes the catch area for images you drop in.

Result Stacks — showing where a render will land

By default you find out where a render’s images went by looking for them afterwards. A Result Stack lets you say it in advance.

Draw an ordinary connection line — not a paperclip — from your Render Stack to an empty box. That box reads “Result Stack” and “Results will appear here”, and the next render’s images appear inside it, spinner and all, before the first pixel arrives.

  prompt widget ──▶ Render Stack ──▶ Result Stack
                    (your images)     (empty)

It is a marker, and it is used up. The moment a render lands in it the box disappears, leaving the images behind as an ordinary stack. Nothing is lost — stacks form on their own, so the box has done its whole job once it has told you where to look. This also means a Result Stack is spent after one render: draw a new line if you want another.

Anything wired past it follows the image. Connect a Result Stack onward to an Upscaler, a 3D Asset widget or a paperclip and that connection moves onto the render’s image as the box goes — so the chain keeps working and you can upscale the result straight away, with nothing to redraw.

  prompt ──▶ Render Stack ──▶ Result Stack ──▶ Upscaler
                                  ↓ render
  prompt ──▶ Render Stack ──▶ (your image) ──▶ Upscaler

This needs the render to produce one image. Ask for several at once and there is no telling which of them you meant, so a batch takes the connection down with the box — reconnect from whichever image you pick.

Several boxes queue up. Connect the Render Stack to two or more empty boxes and they fill top to bottom, one per change:

Render again with nothing changed — the new images join the pile the last render made. No box is used up.
Change the prompt, the model, a setting or a reference — the next box down is used instead, so each variation gets its own place.
Render a batch — every image of that batch lands in the same box; they share a prompt, so they belong in one pile.
Run out of boxes — results continue below the lowest one, as they would have without any boxes at all.

A box you filled by hand is skipped: it holds your images, not a render’s.

Promoting a stage. Click the paperclip on the line into your Render Stack and every role shifts one step down the chain — the Render Stack becomes a Reference Stack, and what it feeds becomes the new Render Stack. Any box connected to that wakes up as its Result Stack. Boxes left behind by the shift grey out; they still accept images you drag in, and they light up again if you remove the paperclip.

  prompt ──▶ Reference Stack ──📎──▶ Render Stack ──▶ Result Stack

Composite by masking, then merge

Stack the images — drag them so they overlap; they snap into a stack.
Order them so the pieces you want on top sit above the others.
Mask the top image — paint a mask on the upper layer to hide the parts you don’t want, so the image beneath shows through. Repeat down the stack until the composite looks right.
Merge — click the Merge button on the stack’s controls (top of the stack) to flatten every image in the stack into a single new image. This is the same idea as flattening layers in Photoshop, and it’s how you lock in a composite you’ve built up from several images.

Guided tutorial: for a hands-on walkthrough, open Render Facade Reference and Masking from the ? Help menu — it renders with a reference image, then masks and merges to clean up the result. See Guided tutorials.

The stack controls

On a stack you’ll find:

Merge — flatten all the stacked images into one new image (your composite).
Compare — a slider to view two versions side by side.
Reorder — change which image sits on top.
Expand — spread the stack into a masonry layout to see every image at once.

Tips

Mask a little loosely, then refine. Soft mask edges blend two images more naturally than a hard cut — see Layer masks.
Merge is non-reversible on the flattened image — keep the source layers (or duplicate them) until you’re happy with the composite.
Stacks are also handy just for comparing generated variations before you pick a winner.

Layer masks — mask the top image to composite the stack.
Mask & inpaint — regenerate a region instead of compositing.
Images & layers — the layers a stack groups.
Prompt widgets & routers — wire an Empty Stack into a pipeline before it holds anything.
Guided tutorials — the Render Facade Reference and Masking walkthrough.