Image Layer Editor 👻

Most ComfyUI nodes are fire-and-forget: you set the inputs, run, done. Image Layer Editor 👻 is the rare one that stops mid-run and waits for you. You feed it a stack of images, it shows them as editable layers on the canvas, and you physically drag, rotate and scale them - then hit Continue and the graph carries on with your composited result. It's the closest thing ComfyUI has to a manual Photoshop-style compositing step living inside the workflow.

It's from the ComfyUI-Minitools pack, and it's one of the few nodes there that's genuinely interactive rather than a passive utility.

How the interaction works

• The first image in the stack is the locked background. You can't grab it - it's your base canvas.
• Left-drag a layer to move it. Right-drag rotates it. There's a scale control for resizing (plus a Reset button to reload the originals).
• When you're happy, hit Continue. The node then wakes up, applies the transforms, and returns.

The graph literally blocks on this - the node is async and holds the queue open while you fiddle. That's a feature: it turns a generation run into an interactive compositing session, letting you align a subject, position a logo, or stage a multi-element shot between generations without leaving ComfyUI.

The inputs

Only three, and you mostly care about two:

• images (IMAGE) - a batch of layers, index 0 being the background. Feed it from an image batch or a list-join.
• random_seed (INT) - present in the signature but effectively inert; it's there for graph determinism/bypass semantics, not something you tune.
• filter_layer (BOOLEAN) - here's the sharp edge. Off (default): the first image is the background and everything else is editable on top. On: the second image becomes the background, image 0 gets hidden, and everything from index 2 up is editable. This exists for workflows where your real background is second in the stack - a generated composite where index 0 is something you don't want shown.

Two outputs, both IMAGE:

• ImageMerged - the flattened composite, everything composited onto the background canvas.
• ImageLayers - every input layer preserved as its own image (transformed layers rendered on transparent canvases), so you can keep editing individual layers downstream.

How it works

The node ships your layers to the frontend, saves them to ComfyUI's temp directory, and blocks on an event until you click Continue. On Continue, the transforms (x/y, scaleX/scaleY, rotation) are POSTed back to the backend, which re-renders each layer with PIL (Lanczos resize, bicubic rotation) and composites them onto an RGBA canvas. The merged result and the modified layer stack both come out as tensors.

Install

# ComfyUI Manager: search "ComfyUI-Minitools"
# or manually:
cd ComfyUI/custom_nodes
git clone https://github.com/lepiai/ComfyUI-Minitools
# restart ComfyUI

It's registered as an output node, so it shows in the Output/right-click "Show" area. Dependencies are ComfyUI-bundled (aiohttp, PIL, torch) - nothing extra to download.

Where it bites

• The background is a static canvas. If your background isn't already the right size, the composite canvas inherits its dimensions and everything else gets pasted relative to its center. Resize your stack to a common canvas first.
• It blocks your queue. Because it waits on you, a workflow with this node can't run unattended - it's interactive by design. Automating a batch run? This node will park it.
• Don't expect undo. The undo model is "Reset and start over". Fine for a couple of layers, mildly annoying at ten.
• Pack support is thin. This is an obscure pack with essentially zero community footprint; the README doesn't even document this node. If it misbehaves, you're reading the source, not a forum thread.

For the specific job - a hands-on compositing step you can't express as numbers - it's the tool. Any workflow with a manual alignment step (place a character in a scene, position a text overlay, stage a multi-layer shot) gets meaningfully easier with it. Just remember it's interactive, and budget for the click.