Image generation

The core image nodes. All of them take a prompt (and, where relevant, images) and produce an image on a provider of your choice.

#Text → Image

Generate an image from a prompt. Pick a provider and model, set the aspect ratio and (on Gemini) the resolution, wire a prompt in, run. This is the starting point of most graphs — see Your first image.

Providers: Gemini (Nano Banana family) and OpenAI (GPT Image 2).

#Image → Image

Edit or transform an existing image with a prompt. Wire an Image In (or any upstream image) into the image inlet and a prompt into prompt. Good for variations, retouching, and style changes.

Gemini gotcha: an image edit that returns finishReason: OTHER is a silent content refusal, usually triggered by an input image — a real person's name in facade lettering, a face, a logo — not the prompt. It's deterministic, so Brut never auto-retries it. Fix by removing or cropping the offending image.

#Inpaint

Change only a painted region of an image, leaving the rest pixel-faithful.

1. Wire an image into the Inpaint node and run upstream once so it has an output.
2. Click 🖌 Paint mask to open the mask editor. Brush over what should change (red overlay), at the image's native resolution. Erase to correct.
3. Type a prompt describing the change and run.

The mask convention is white-on-transparent = editable. Brut converts it per provider: OpenAI applies it natively (a true masked edit); Gemini gets it as strong guidance (a confine-the-edit preamble plus the mask image) — strong, not a hard guarantee. The same approximate convention rides the fal.ai / Replicate routes for the Nano Banana models (verified live), so a fal-only or Replicate-only seat can still inpaint — the node says "approximate" whenever that's what you're getting. GPT Image 2 masks never route: exact masking is an OpenAI-key feature, and the node tells you so instead of guessing. The mask remembers which image it was painted on; changing the input fails the run loudly ("repaint") rather than applying a stale region.

#Annotate & Correct

Point at things on the image and say what changes — Inpaint's smarter sibling, and the way clients already brief: markup on a picture.

1. Wire an image into the Annotate node and run upstream once so it has an output.

2. Click ✏ Annotate to open the editor. Draw arrows (point at the exact object), boxes / circles (hold Alt to draw from the center), a freehand lasso or a click-placed polygon (click corners; close on the first corner or double-click — Backspace undoes a corner, Esc cancels), or drop a numbered point marker. Give each mark a note ("change this chair to a deep red", "remove this lamp") and, optionally:

   • a color chip — pick on the color wheel, browse the RAL Classic swatch grid (216 colors with search — the archviz-native vocabulary clients actually speak; approximate sRGB, since RAL is a physical standard), or use the eyedropper to sample a color straight from the image ("make it THIS color");
   • a reference image — drop or browse an image onto the mark's card: "replace THIS with the object shown". References are lettered (A, B, …) and sent to the model alongside the original. Exotic formats (AVIF from a Google Images drag, for instance) are converted automatically.

   Wheel zooms, middle-drag pans — for detailed work at native resolution. In Select, a selected lasso or polygon shows a handle on every corner, so the outline can be refined point by point.

3. Run. No prompt needed — the marks are the prompt. A wired prompt is optional and rides along as a global instruction ("keep the late-afternoon light").

Under the hood the node is a compiler: your marks are burned into a copy of the image (numbered red markers, arrows, outlines, color swatches) and the model receives both images — the untouched original and the annotated copy — plus a numbered instruction per mark. Drawn-on-image pointing is spatially unambiguous in a way prose never is, and Nano Banana follows it remarkably well. The output is a clean edited image, no markers.

Notes:

• Nano Banana 2 & Pro and GPT Image 2 — all live-verified drawn-instruction performers (reference images verified too). The original Nano Banana (gemini-2.5-flash-image) failed the same live test (it applied only some edits and left markup in the output), so it's deliberately not on this node's menu. In the field, Nano Banana Pro is the strongest multi-mark performer; GPT Image 2 is best with a handful of marks at a time.
• Aspect auto pins the input image's measured ratio explicitly on Gemini — reference images would otherwise be allowed to sway the output's aspect.
• Reference images go through the same content filters as everything else — a photo of a real person (children especially) can trigger Gemini's IMAGE_SAFETY refusal. The node surfaces it loudly; swap the reference.
• Marks are strong guidance, not a hard mask. When you need pixel-exact confinement, use Inpaint.
• Annotations remember which image they were drawn on. If the input changes, the run fails loudly ("re-anchor") instead of applying stale geometry — reopen the editor and mark the new image.
• Marks stay fully editable: reopen the editor and use Select — drag a mark's number to move it (for arrows the number moves just the tail, the tip has its own handle to re-aim, and dragging the shaft moves the whole arrow), edit notes/colors, or delete (✕ or the Delete key). Any edit is an honest cache miss — the next run re-bills.
• Annotations never travel in library recipes — they're anchored to a specific image.
• Correcting a result you mostly like: don't re-roll the same node — every mark would regenerate and the parts you approved come back similar, not identical. Click ↳ Correct result instead: it spawns a new Annotate node wired to this result, so the approved image becomes the frozen input and only the correction re-bills. And when the fix is "put the original back here" — an added object you don't want, a region that drifted — click 🗇 Reconcile with input: it spawns a Layers node with the result as base and your input image as a masked layer. Paint where the original should return. Local, free, pixel-exact.

#Layers

Photoshop-style compositing, local and free — the node never calls a provider.

Wire two or more images in (the bottom wire is the base), then open 🗇 Edit layers & masks. The layer tray speaks Photoshop:

• A layer has no mask until you add one — ＋ mask on its row (click = white, reveal-all; Alt+click = black, hide-all). The brush paints the mask: white reveals, black hides — the dual swatch shows both colors (active one outlined), X swaps. Ctrl+Backspace fills the mask black, Alt+Backspace white.
• Brush opacity is per-stroke (1–100%): overlapping segments inside one stroke never build up. Set it with the slider or digit keys — 5 = 50%, 1 then 2 quickly = 12%, 0 = 100%.
• Alt + right-drag adjusts the brush — horizontal = size, vertical = softness — with the cursor pinned in place while you drag (pointer-locked, like Photoshop). Size, softness and opacity all have sliders too, and the live brush cursor shows the soft edge as a dashed ring.
• Each row: eye toggle (Alt+click = solo — hides the others; again restores), layer thumbnail, B&W mask chip — Shift+click (or Tab+click / right-click) the chip to disable the mask (red ✕, layer shows fully), Alt+click to view the mask full-frame — and the layer name (double-click to rename). Below: feather, invert, remove mask. Drag rows to reorder; the tray under the stack duplicates (Ctrl+J), deletes (duplicates) and moves the selected layer.
• Pen pressure (Wacom & co) scales the stroke width automatically.
• Wheel zooms (past ~1.5× the preview switches to full native resolution), middle-drag pans.

Why it matters beyond convenience: generative edits keep "everything else unchanged" only approximately — the whole frame regenerates and untouched regions drift subtly. Layers clamps every unpainted region back to the source pixels. Stack the original under a generation, mask in just the part you wanted changed, and the deliverable is pixel-faithful everywhere else.

Notes:

• The base defines the canvas. A layer of another size auto-fits: scaled to cover and center-cropped — never distorted (the editor labels it "auto-fit"). This is the common case: a 4K generation never exactly matches its source's dimensions. Masks stay strict — a stale mask fails loudly, never applies misaligned.
• Masks remember which image they belong to. If an upstream node re-generates (new output), the run fails loudly instead of silently applying or dropping a stale mask — reopen the editor to repaint.
• The composite is cached like any node output, and re-runs are free anyway.

#Compose

Blend a scene with one or more reference images. Wire the base image into scene, the sources you want to pull from into reference, and a prompt describing the blend. Compose is handy for dropping entourage, materials or mood from references into a render.

#Choosing a model

Every model and its default parameters come from Brut's catalog, so the menu is always current. Cheapest-to-richest on Gemini: gemini-3.1-flash-lite-image (Nano Banana 2 Lite, ~$0.03, text-to-image only — it can't edit) → gemini-3.1-flash-image (Nano Banana 2) → gemini-3-pro-image (Nano Banana Pro, up to 4K). For edits, the legacy gemini-2.5-flash-image (Nano Banana, ~$0.04) is still the cheapest and stays on the edit menus. See Providers for the full list and billing notes.

#Next

→ Multi-Shot & boards — explore many viewpoints at once.