Scumble manual

Scumble is a normal desktop app. On Windows the simplest way to get it is the Microsoft Store: search for Scumble there, or open apps.microsoft.com/detail/9NDBTNNMXF2R in a browser, press Get, and it is in your start menu. In a terminal, winget install 9NDBTNNMXF2R installs the same Store copy. The other way is the installer from the latest release on GitHub: download it, run it, and it is in your start menu too. Scumble itself has no account, no sign-up and no server of mine in between: the app talks to your own ComfyUI, or to the API provider whose key you gave it, and, unless it came from the Store, to GitHub when it looks for an update.

Microsoft signs the Store copy, so it installs without a warning. The installer from GitHub is not code-signed yet, so Windows shows "Windows protected your PC" the first time. That is the warning Windows gives every unsigned program, not a verdict about this one. Click More info, then Run anyway. Updates after that are downloaded by the app itself and do not go through SmartScreen again. Proper signing is planned through the SignPath Foundation, which is free for open-source projects but wants a project with a public release and some use behind it first.

There is also a portable copy for Windows, Scumble-<version>-portable-win-x64.zip in the same release. Unpack it into a plain folder you can write to, such as C:\Tools (not Program Files, and not a folder OneDrive syncs): the zip holds one folder, Scumble, and you start the Scumble.exe in it. The file portable.txt beside it makes Scumble keep everything it stores — settings, keys, autosave, the local files, plugins, recipes, helper models, logs — in a data folder next to it, so nothing lands in %APPDATA%\Scumble and it runs beside an installed Scumble. The Store copy and the installer stay the recommended ways.

On Linux the same release carries an AppImage and a .deb. Fair warning: they are built by CI and have not been run by me, because I have no Linux machine here. If you try one, tell me what breaks. macOS is planned, but not started yet.

The app alone can do a great deal — open, paint, select, layer, filter, save, export — but it generates nothing until it has somewhere to render. That is the next chapter.

Scumble does not generate anything itself. It sends your selection somewhere and puts the answer back as a layer. That somewhere is either your own ComfyUI, or a model provider you have an API key for. You can have both and switch per run; the recipe picker in the top bar decides which one a run uses.

Your own ComfyUI is free to run, keeps every pixel on your machine, and gives you the models you already downloaded. It needs the node pack ComfyUI-InpaintCanvas installed there, and the models the recipe asks for. Type the server's address into the top bar — http://127.0.0.1:8188 for a local one, or the address of a rented box, RunPod included — and press Connect. Scumble checks for the node pack when it connects and says so in the status line when it is missing (Test in Settings › ComfyUI lists it too); it does not install the pack for you. Install it with git: in a terminal, cd ComfyUI/custom_nodes, then git clone https://github.com/DenRakEiw/ComfyUI-InpaintCanvas, and restart ComfyUI. The pack needs no extra Python packages. The ComfyUI Manager does not list it at the moment; once it does, you can install it from there too. When no ComfyUI runs at the address (the connection is refused), the top bar shows a grey dot instead of the red one and says "No ComfyUI running"; its tooltip says that ComfyUI recipes and selection by text need one, and that the API recipes and the rest of the editor work without it.

An API provider needs no server at all. Put a key into Settings › API providers and the models behind it appear in the recipe picker: Google's Nano Banana, OpenAI's GPT Image (2.6 Sunburst and Flare have a Complexity row: how much the model plans before it draws; low is faster for simple edits, high, the default, suits busy scenes and lettering), Black Forest Labs' FLUX.2 and FLUX 3 Image, ByteDance's Seedream, Qwen Image Edit, and the same models through aggregators like fal.ai, Replicate, WaveSpeedAI, ToAPIs, Comfy Cloud, Comfy Router, OpenRouter and Oxen.ai. You pay that provider directly; Scumble takes no cut and sees no invoice. Comfy Router has no key row of its own: it runs on the Comfy Cloud key, with credits and without a paid Comfy plan. The same key runs HY Image 3.5 through Comfy's Partner API.

Keys are stored in the operating system's own credential store through Electron's safeStorage, never in a settings file you might share by accident. On Linux that is the desktop keyring; if the system has none, the settings say so in plain words rather than pretending the key is encrypted when it is only obfuscated.

The same key rows also feed two other things: the assistant, and prompt upsampling. If you already have an OpenRouter or an Oxen.ai key, one key covers a lot of ground at once.

The loop is always the same, whatever the model behind it: select an area, write what should be in it, press Generate. What comes back is a layer sitting over the selection, not a new picture — which is the point of the whole app. If you do not like it, you delete the layer and the original is untouched underneath.

Open a picture with Ctrl+O, by dropping it on the window, or by pasting from the clipboard. PNG, JPEG, WebP and TIFF, and since 0.1.25 also PSD and ORA files with their layers intact; a .scumble document you saved earlier opens the same way. Then paint over the thing you want changed with the selection brush — the default tool, size with the bracket keys, Alt to erase what you painted too much of.

The prompt goes into the Generate tab on the right. Describe what should be in the selected area, not what is there now: "a red leather handbag" and not "change the bag to red leather". Then Generate, or Ctrl+Enter. A run on a local ComfyUI takes as long as your card needs; an API run is usually ten to thirty seconds. While it runs you can keep working, even in another tab.

The result arrives as a layer over the selection, and the layer row has a Match slider. That slider is the small feature that saves most results: it matches the colours of the generated patch to what surrounds it, so the piece stops looking pasted in. Start at 100 %, pull it back when the model's own tone is worth keeping.

Happy with it? Ctrl+Shift+E exports the visible picture, and Ctrl+S keeps the whole document, every layer still editable, as a .scumble file. Not happy? Press Generate again — a new seed, a new layer, and you can compare the two by toggling their eyes.

The selection is the most important thing in an inpainting editor, so Scumble gives it seven routes. The brush is the honest one: paint, Alt to subtract, done. Rectangle, ellipse and lasso are there for the shapes that painting gets wrong. The magic wand takes everything of a similar colour from where you clicked, which is what you want for skies and flat backgrounds.

Object hover is the one people like: move the pointer over the picture and Scumble outlines the object under it, click to select it. Dragging a box with the Object tool selects the object inside it through a box prompt, with a blue dashed rubber band showing the area. Shift adds, Alt subtracts, and Shift+Alt intersects with the existing selection (a plain drag adds like the click). The click on an empty spot and the box drag evaluate logits bilinearly at image resolution without building a full-sized mask in memory, saving hundreds of megabytes on large pictures. That is SAM2 running inside the app through ONNX Runtime, on your GPU on Windows and on the processor on Linux. Nothing leaves your machine, and the model file is downloaded once or read from a ComfyUI models folder you point at.

Selection by text is the other one: type "the handbag" or "her sunglasses" into the Selection panel and press Go. That route runs on your connected ComfyUI, so it needs a server and segmentation nodes there, unlike object hover. Three sets of nodes work, and the menu at the end of that block, below Threshold, HQ and Source, lists the ones your server has (the first unless you pick another): SAM3 runs comfyui-rmbg's SAM3 node ("SAM3 Segmentation (RMBG)" in ComfyUI; the pack fetches its weights into models/sam3 on the first run, and on Windows it also needs the Python package triton-windows in ComfyUI's own Python, which the pack does not install by itself), GroundingDINO + SAM runs comfyui_segment_anything, and SAM3 (core, experimental) runs ComfyUI's own SAM3 nodes with a sam3 checkpoint in models/checkpoints. With none of them the menu says "no segmentation nodes installed"; the object tool needs none of this.

Selection by range is the photographic one: select what lies between two depths, two brightness levels or near a colour, softened at each end as far as you set it. The Selection panel's Select by range block gives you the range bar with its histogram, a live preview tint on the canvas as you adjust the handles or hover the bar, and an eyedropper button to pick a depth, luma or colour directly from the picture. When a depth map is present, Show map overlays the map directly on the canvas. Press Enter while focused in the range bar to commit the selection immediately. The four mode buttons — Replace, Add, Subtract and Intersect — combine the range with your current selection.

Once you have a selection, the Selection panel does the rest: grow and shrink it by a pixel count, feather its edge, invert it, take it from a layer's transparency, or save it under a name to come back to later. Selections survive a restart with the document, and the selection and the saved ones travel in its .scumble file.

In Settings › Recipes the recipes sit in three groups you open and close: ComfyUI, Comfy Cloud and API models, the last by model family. Each group's line says how many recipes it holds, how many are ready to run (a key or a model in place) and which one is in use; the group of the recipe in use opens by itself, and the dialog remembers which you opened. Remove shows only on your own recipes. The key rows of Settings › API providers are one such group too, open while no key is stored.

A recipe is Scumble's answer to the node graph. It names a model — "FLUX.2 [max]", "Nano Banana 2", "Upscale model (ComfyUI)" — and, for models that several services host, the provider it should go to. Picking one from the top bar is the whole configuration; the settings the model actually has (steps, guidance, seed, resolution) appear in the Settings panel of the Generate tab, with sensible defaults.

Local recipes are ComfyUI workflows in API format with an Inpaint Canvas node in them. The shipped ones cover FLUX.2 Klein, FLUX 3 Image Klein, Qwen Image Edit 2.1, MOSS-Image (new pictures only, below), MOSS-Image Edit (below), P-H3-Image (below) and an upscale-model chain, plus the Realism Pass (Windows only, RTX only), which has a chapter of its own. You can import your own: Settings › Recipes, Import, pick your exported workflow. If it holds an Inpaint Canvas node, Scumble fills that node with your canvas and queues the rest exactly as you built it.

Provider recipes go out over HTTPS with your key. Scumble crops the selection with context, sends it at a size the provider really accepts — the Highres fix setting picks the tier — and stitches the answer back at full resolution with the surrounding pixels preserved. Models that take a mask get one; models that do not get an instruction edit and Scumble's own composite mask does the blending afterwards. Reference layers are sent along for the models that take references; the next chapter shows how to name them in the prompt.

FLUX 3 Image, on your Black Forest Labs key, or through OpenRouter, Comfy Router, fal.ai, Oxen.ai or WaveSpeedAI on their keys, edits the crop by instruction with up to nine more pictures (the Original and your reference layers), and in Generate new it takes up to ten reference images. It takes no pixel size: Scumble widens the crop to one of the model's fifteen shapes and picks a size class from it, 1k or 2k for an edit and up to 4k for a new picture (the larger class costs more); it has no seed, so two runs of the same prompt differ. The recipe's Settings have a Grounding switch, on by default, that lets the model search the web and images for what the prompt names before it renders; turn it off to keep your prompt away from search. On OpenRouter the switch is missing: grounding stays at Black Forest Labs' default, on. On fal.ai it is missing too, each picture may have at most 4 megapixels (Scumble scales a larger reference layer down) and there are fourteen shapes, without the tallest; a Prompt expansion switch there, on by default, lets the model rewrite your prompt before it renders, as Black Forest Labs' own API always does. On Oxen.ai the Grounding switch is there and on by default, as on Black Forest Labs' own API (Oxen's own default is off), and Oxen keeps every picture it makes in your Oxen account. WaveSpeedAI takes the same 4 megapixels and fourteen shapes as fal.ai and has the same Prompt expansion switch, but neither Grounding nor Safety tolerance. The model also takes boxes in the prompt that say where things go, your selection among them: the Boxes switch under the prompt field turns them on, as Boxes in the prompt below explains.

Ideogram 4.5, on your Replicate token, your WaveSpeed key or Comfy Router (the Comfy Cloud key), repaints only what you selected: the selection goes as the model's mask, the answer comes back at the crop's own size, and what the edit leaves alone stays as it was. It is strong at lettering. Up to three more pictures go along (the Original and your reference layers); the model takes them without a number, so the prompt cannot name them with @img1, and a run whose prompt names one stops before anything is sent. It takes no picture steeper than 6:1, so a very narrow selection goes with more of its surroundings. Quality in the recipe's Settings (very_low, low, medium, high; medium by default) also sets the price per picture. On WaveSpeed, Edit precision high, the default, keeps the unchanged pixels, and no seed goes there, so two runs of the same prompt differ; Replicate and Comfy Router take the seed. Generate new makes a picture from the prompt alone, at the closest of the model's shapes and sizes. The recipe was written from the three providers' documentation and has not run against them yet.

P-H3-Image, Pruna AI's 8-step image model on MiniMax H3, runs on your own ComfyUI (ComfyUI 0.44 or newer, which runs it on its own nodes), on Comfy Cloud and on your WaveSpeedAI key. It edits the crop by instruction with more pictures (the Original and your reference layers: up to seven on your ComfyUI, eight on WaveSpeedAI; Comfy Cloud's template edits the crop alone), which the prompt names as <Picture 2>, <Picture 3> and so on (@img1 is written so), and Generate new makes a new picture from the prompt alone. It has no mask: it renders the whole crop again and Scumble keeps your selection. On your ComfyUI the recipe runs it the way Comfy's own templates do: MiniMax H3's FL2VA model (minimax_h3_fl2va_pruned_int8_convrot, from Comfy-Org/MiniMax-H3 on Hugging Face) with Pruna AI's P-H3-Image LoRA, P-H3-Image's own text encoder and VAE (from PrunaAI/P-H3-Image-Comfy); a file your ComfyUI lacks stops the run with its download link. Your own rows in the LoRAs section go after the P-H3-Image LoRA. The crop goes at 4 megapixels by default, as Pruna AI advises for edits (the Megapixels row; 8 is its best size and needs more graphics memory), in 8 fixed steps without CFG or a negative prompt. Pruna AI's prompt upsampler (the Prompt upsampler row, on by default; p-h3-image_prompt_upsampler_w4a8 under models/text_encoders) writes your prompt out first, looking at the pictures; without it, short edit requests often redraw the whole scene. On WaveSpeedAI the Resolution row (1k to 4k, 2k by default) sets the size and the price per picture. Comfy Cloud runs Comfy's own P-H3-Image templates unchanged; its Generate new goes up to 2912 px a side, the model's own size for a new picture. The ComfyUI route has run from Scumble: on a 32 GB card an edit at 4 megapixels took about 25 seconds with the upsampler (about 17 without), one with a reference layer about 36, a new picture about 20, an edit at 8 megapixels about 52; with the upsampler off, a short request such as "make the sky a warm sunset" came back as a new picture, so keep the row on for edits. The Comfy Cloud and WaveSpeedAI routes have not run yet. Powered by MiniMax H3. P-H3-Image is under the MiniMax H3 Community License, which does not cover use in the EU, the UK, South Korea or the US without a separate licence from MiniMax (platform.minimax.io/h3-license).

MOSS-Image Edit runs on your own ComfyUI (ComfyUI 0.43 or newer, which brought its Text Encode MOSS-Image Edit node; on an older one the recipe says the node is missing and does not run). It edits the crop by instruction with up to three more pictures (the Original and your reference layers), which the prompt can name as image 2, image 3 and image 4 (@img1 is written so); say what each picture is for: "Image 1 is the scene to edit. @img1 is a picture of the bag to place. Place that bag on the ground. Keep everything else unchanged." put the bag of the reference into the scene and kept the rest, while a bare "put the bag from @img1 on the ground" redrew the scene around a different bag. The phrasing the edit was trained on works best: "Change only the X to Y. Keep the character, face, hair, pose, background and composition unchanged." It has no mask: it renders the whole crop again and Scumble keeps your selection. The recipe runs Comfy's own template: MOSS-Image with an edit LoRA (moss_image_edit_lora_rank_64_bf16, 297 MB, from Comfy-Org/MOSS-Image on Hugging Face, under models/loras; the Edit LoRA row, its strength the next row), 30 steps at CFG 4; a ComfyUI without the LoRA file stops the run with its download link. The Megapixels row (1 by default) sets the size of the picture being edited and of the result; much smaller, about a quarter of a megapixel, and the model starts to re-frame the picture instead of editing it. Your own rows in the LoRAs section go after the edit LoRA. Edit LoRAs trained with ai-toolkit (MOSS-Image-Edit-HQ and MOSS-Image-CharRef on Hugging Face, for example) need the encoders' edit_format set to ai-toolkit on both Text Encode MOSS-Image Edit nodes, which a recipe row cannot do: open the recipe with Edit in ComfyUI, set both nodes and pick that LoRA in the LoRA node, then Save as new recipe. Generate new here edits the white canvas into a picture from the prompt; MOSS-Image is made for new pictures. An edit takes about half a minute on a fast card. The same template runs on Comfy Cloud as MOSS-Image Edit (Comfy Cloud), on your Comfy Cloud key: an edit of the crop alone, and Generate new on MOSS-Image's own text-to-image template, whose prompt enhancer writes your prompt out first; the edit ran on Comfy Cloud in about half a minute (a sunset sky over a building, the building, the tree and the car kept), Generate new there has not run yet. The edit LoRA is chinoll's Moss-Image-Edit, rehosted by Comfy-Org, whose repository card says Apache-2.0; chinoll's own repository names no licence for the weights (its code is GPL-3.0). MOSS-Image's weights are Apache-2.0.

The recipe LaMa remove (in-app) does what the Remove tool does, for a selection: select what should go, pick the recipe and press Generate. It runs the same model inside the app, offline and without a prompt, and its answer is stitched back like a provider's. It fills from the surroundings and never invents anything new; for that, use a model recipe.

Generate new makes a new base picture from the prompt, locally or through a provider, when you want to start from nothing rather than from a photo; Mystic, Magnific's own model, lives only there. The reference layers stay: the answer replaces the picture and every other layer, and the shown references go along to a model that takes reference images for a new image (FLUX.2, FLUX 3 Image, GPT Image, Nano Banana, Seedream and more). There is no crop before them, so @img1 goes out as image 1; references the prompt does not name go along too, and a hidden one stays in the tab without being sent. A model that makes pictures from the prompt alone sends none, keeps them in the tab, and stops the run when the prompt names one. On a local recipe they follow the white canvas the recipe renders on, so there @img1 is the second picture (the third when the Original goes too), as the dialog's chips show, and a token that cannot go, or a ComfyUI that is not connected, stops the run before the picture is replaced. Through a provider, the status line says which name each token went as and how many other layers were replaced. In an empty tab, a reference added through the prompt field (its +, the @ list, or a picture pasted or dropped on it) first gets a white 1024 × 1024 canvas, which Generate new then replaces. The dialog's prompt field works like the Generate tab's and starts with its prompt, with chips, the @ list and the bar above it: the card over each chip says what its reference goes out as for the model and provider picked in the dialog, and the + adds a reference to the tab.

The New button in the top bar makes a white canvas, of a width and height you type, or for a model: pick one under Model (API models, Comfy Cloud and ComfyUI recipes; Any size keeps width and height by hand), its provider, one of that model's own aspect ratios and a size class. FLUX 3 Image offers its fifteen shapes and 1k, 2k and 4k; a model that lists no shapes of its own offers the usual ones, and its sizes by their long side. The canvas is made in that aspect at the class's long side, but never larger than 2048 pixels: what you draw on it, the boxes above all, is kept as fractions of the picture, so 7:5 at 4k draws on a 2048 × 1456 canvas and asks the model for 4096 × 2928 later. Create also selects the model, for every tab as the recipe picker does, and the document keeps the choice, saved with it. Generate new then opens on that model, provider, aspect and size class; after a Generate new the document keeps what was asked, so the dialog opens on it again, until a crop or a resize changes the picture's size, or another picture comes into the tab (opened, dragged in, pasted or loaded by an agent, whatever its size). New itself opens on the document's own choice while it holds; in an empty tab on the last model you made a canvas for in this session; in a tab with a picture and no choice of its own on Any size, with the picture's width and height. Without such a choice the dialog opens on the last aspect you picked, from the list of the model shown in it (FLUX 3 Image's own shapes, 7:5 among them), and its size classes carry the model's names where it has them ("4k (4096 px)"). Where a provider counts its sizes by area (megapixels), a class's name follows the aspect: the same long side can be a smaller tier in a wider shape, so the names change when you pick another aspect. A Settings row of the recipe that is not on auto (Gemini's Size 2K, say) still decides the size the model makes. While boxes go with the run (the Boxes switch on, boxes in the document, a model that takes them), the dialog opens on the model's aspect nearest the document, and a line under the aspect warns when another shape would stretch them, "The boxes were drawn on 7:5; at 1:1 they go stretched.", since the boxes are fractions of the picture they were drawn on; the status line of the run says the same.

Prompt upsampling turns a short prompt into a long one through a language model — your own key, an OpenRouter, Oxen.ai or ToAPIs key, or a local Ollama or LM Studio that needs no key at all. Your own prompt-writing rules can be stored as Markdown templates, so upsampling follows your house style and not a generic one. Upsampling keeps the @img tokens: the language model is told which reference each one names and that it has to leave them as they are, and a token that names no shown reference (a hidden or deleted layer, one that is no longer a reference, or a number no reference holds) stops the upsampling until you show or restore the layer or take the token out. When a rewrite drops a token, adds one or names a picture by number ("image 3") instead, the status line says so, and Revert brings your prompt back. Upsample in the Generate new dialog does the same, and there the note under the prompt says so, next to its own Revert. A template of your own gets the names too; {references} puts them where you want them. With an API model or a local endpoint, upsampling also shows the language model the reference images the prompt names (up to six), as small pictures of at most 512 pixels, so the rewrite knows what each token is; they then go to that model's provider as well. Settings › Prompt templates has the switch to keep them back. A model that takes one picture at a time is asked again with the picture being edited alone, and the status line says "crop only".

The ComfyUI button in the top bar (Ctrl+Shift+K, also View › ComfyUI) opens your ComfyUI's own page in a window of its own, from the address and auth under Settings › ComfyUI: a local install, a box in your network or a RunPod pod. ComfyUI's own shortcuts work there; Scumble's do not reach it. With no ComfyUI to show, the window says why and leads to the setting. Scumble needs no ComfyUI for anything else. While a ComfyUI recipe is selected, Edit in ComfyUI beside the recipe picker (also View › Edit Recipe in ComfyUI, and Settings › Recipes) opens that recipe's graph there, with the result and the Settings rows wired to the Inpaint Canvas node. Change the graph in ComfyUI, then Save to recipe in the window's bar writes it back (a shipped recipe becomes your own copy, which Settings › Recipes can remove again), or Save as new recipe keeps it under a new name; the editor selects the saved recipe, and it opens next time laid out as you left it. The window's Show picker switches to Comfy Cloud, where you sign in on its own page (email or GitHub; Google may refuse an app window); Comfy Cloud runs no custom nodes, so a recipe built on the Inpaint Canvas node opens on your own ComfyUI only. To run one there anyway, Cloud copy under Settings › Recipes makes a copy without the node, which runs on your Comfy Cloud key while Scumble crops and stitches; a workflow you built or opened on Comfy Cloud, one of Comfy's templates for one, becomes a recipe by Save as new recipe in the window (or by importing its exported file): Scumble reads which picture is the crop and where the prompt and the seed go, and the bar says what it read. If it reads one wrong, title the nodes for it ("Scumble crop", "Scumble prompt", "Scumble seed" and a few more). Comfy Cloud recipes have a mode of their own: pick comfy cloud in the mode picker next to Generate (beside local and api), and the recipe picker lists them alone; they run on Comfy Cloud with your Comfy Cloud key. Eight come with Scumble, from Comfy's own image-edit templates: Boogu Image 0.1 Edit, Flux.2 Klein 9B base (one picture, or two: the crop and the Original or your first reference layer), Mage Flow Edit Turbo, MOSS-Image Edit, P-H3-Image, Qwen Image 2.1 Edit and Qwen Image Edit 2509. Leave the negative prompt empty and the template's own negative stays. Comfy Cloud runs go through Comfy's own TypeScript SDK on Comfy's newer API: a picture Comfy already holds is not uploaded again, and a job is sent once, so a dropped connection never starts it twice. Before anything goes up, Scumble checks that Comfy Cloud has every node of the recipe's graph; when Comfy Cloud's node list cannot be read, the run goes anyway, and if a node is missing there, Comfy's refusal of the workflow ends the run with Comfy's own message. When a run fails, the message also names any model file the graph uses that Comfy Cloud's list does not show, with a close name it does show where there is one (your own models on Comfy Cloud are not in that list, so they never stop a run). Generate new has a Comfy Cloud choice too, with Comfy's text-to-image templates: Anima base and preview, Flux.2 Klein 9B, Ideogram 4, Krea 2 Turbo, Mage Flow, MOSS-Image, P-H3-Image, Qwen Image 2.1 and Z-Image Turbo. Flux.2 dev comes as an edit recipe: it works from the selection.

A reference layer is a picture that goes to the model beside the one it edits and is not part of your image: add one with the button of the References list, a Shift+drop on the canvas or the + above the prompt, or set a layer's role to reference. The reference list and the canvas label each shown reference img1, img2 and so on from the top of the list; a new reference goes below the others and takes the next number, hiding one renumbers the rest, and the list's arrows or Ctrl+[ and Ctrl+] move a reference past the next one. A row of the reference list can also be dragged onto another: dropped on that row's upper half it goes above it, on its lower half below, in one undo step, and the labels renumber. Write @img1 in the prompt to name that picture: the prompt keeps following it when the list changes, and the request names it the way the chosen model counts its pictures (image 3, say, when the crop and the Original go first); the status line says which name each token went as. A token whose reference is hidden, deleted or no longer a reference waits for it and stops the run until you show the layer again, undo the delete, make the layer a reference again or take the token out. An upscale sends no reference pictures, so there a token goes as the layer's name; what Generate new does with them is in the chapter before. On a local ComfyUI recipe a token is written as the name that recipe's model reads for its picture (<image3> on Qwen Image Edit 2.1, image 3 on FLUX.2 Klein); the card over the chip and the References line at the foot of the Crop panel show it. A local recipe reads a limited number of pictures, the crop and the Original included (4 for Klein, 10 for Qwen Image Edit 2.1): a reference past that is left out with a note in the status line, and a token that names one stops the run and says why. A workflow of your own whose graph Scumble cannot follow gets the names by the pictures' place in the batch, and the status line says the wording is guessed.

In the prompt field each token shows as a chip: a small round picture of the reference and its label. A token whose reference is hidden shows struck through with the layer's name, one whose reference was deleted or is no longer a reference, or a number no reference holds, shows struck through in red; the card over the chip says why. A chip counts as one character: the caret steps over it, and Backspace or Delete takes it whole. A token becomes a chip once you type the space after it, so @img12 can be typed without a chip for @img1 on the way. A word typed right against a chip gets a space between the two, since @img1 only counts with one; type the space yourself and it steps over the one already there, and Backspace or Delete on such a space steps over it too. A click on a chip puts the caret beside it. The prompt field keeps its own undo: Ctrl+Z there takes back typing, a paste, Upsample, Revert or a prompt an agent set, and never an edit of the picture.

Type @ at the start of a word and a list of the shown references opens under the caret: a small picture, the label, the layer's name and the name the model gets the picture by. What you type after the @ narrows the list by label or name; the arrow keys move in it, Enter or Tab puts the chosen reference into the prompt, and Escape closes the list (a second Escape leaves the field). "+ Add reference" at the end of the list adds pictures as new reference layers and names them where the @ was. A picture pasted into the prompt, or dropped on it, becomes a reference layer the same way and is named where it came in; text still pastes as text.

Above the field a bar shows every reference as a chip, a hidden one dimmed with a crossed-out eye, then a + that adds pictures, and on the right how many reference images the chosen recipe takes, not counting the crop and the Original ("2 of 3 for this recipe" on FLUX.2 Klein on ComfyUI). A click on a chip in the bar names that reference at the caret; a hidden one cannot be named. A chip past what the recipe takes gets a yellow edge and the count turns yellow: through a provider such a run stops before anything is sent and says how many pictures the model takes, and on a local recipe that reference is left out. When the recipe sends no reference pictures at all (an upscale, say), the chips in the prompt are struck through, the bar's are dimmed, and the bar says "This recipe sends no reference images". Rest the mouse on a chip for a moment, in the text or in the bar, and a card shows a larger picture, the layer's name and what the token goes out as ("img2 · sent as image 3"), or why it does not go. The small arrow on a chip in the text opens a menu that swaps the token for another reference, shows a hidden reference again, or takes the token out of the prompt. A chip can be dragged to another place in the text, and a selection dragged inside the field moves there (hold Ctrl to copy it).

Some models take, with the instruction, a table of boxes that says where things go: in Scumble FLUX 3 Image (on every provider it runs on), FLUX 3 Image Klein and MOSS-Image on your own ComfyUI (with a current Inpaint Canvas node, below) and Ideogram 4 on fal. The Boxes section of the Generate pane keeps such boxes with the document. Each row is one box: its name (lowercase words and a number joined by underscores, the way the model refers to it), what it does, a description, and its position in image pixels. New adds what the description says inside the box. Keep holds an element where it is. Move takes an element from its source box (From) to the new one (To). Remove takes an element out and fills the background. From reference places a reference layer, or a part of it, in the box. Text renders the words you give, the description saying how. A description may name a reference layer with @img1, as the prompt does. A new box is called box_1, box_2 and so on until you describe it; then it takes its name from the description: the last two words of its first phrase, so "a red scarf" makes red_scarf_1 and "a small black cat sitting in the grass" makes black_cat_1, and the model reads a name that means something. A name of your own (not box_1, edit_2 and the like), or one already made from a description, stays when the description changes, and so does a box_1 your prompt names as <box_1>.

With the boxes, a run writes a sentence for each box into the prompt, after your own words, that says what happens to it and where: "Place a red scarf <red_scarf_1> at the top left.", "Move the lamp <old_lamp_1> up and to the left, larger.", "Remove the cat <cat_1> at the bottom right.", "Keep the log <log_1> as it is." A description written as an instruction ("make the tiger pink") goes in as it is. A box your prompt already names as <red_scarf_1> gets no sentence, since you said it yourself. Your prompt always goes first, word for word; when it is the description of a box (as with the selection's box), that box's sentence only says where: "The change goes in <red_door_1> at the top left." When the prompt is empty or one box's description, the sentences end with "Leave the rest of the picture as it is."; a prompt of your own keeps the last word on the rest of the picture. Copy rows writes the same sentences. This is how FLUX 3 Image gets the boxes.

Ideogram 4 on fal gets them as its own structured caption instead: the whole prompt becomes a description of the picture, with your words as its summary and each box as an element in its place. A New box is an object, a Text box the words it renders (its description says how they look), a Keep box an element that stays where it is (on an edit). Ideogram's caption describes a picture rather than a change, so it has no Move, Remove or From reference: those boxes stay out of an Ideogram run, the Boxes section says so under an Ideogram recipe, and the status line names them after the run. While the boxes go, Prompt expansion goes as None whatever its row says, since an expansion would rewrite the caption; the status line says so. On a new image your prompt also describes the background, so write one: without it, the model tends to paint a transparency checkerboard around the boxes. Tried live: a red apple box and a Text box "SAUNA" in a meadow put the apple and the carved sign where the boxes were; a box placed somewhere a thing could not be (an apple floating in the sky of a meadow) was ignored for a more natural picture.

FLUX 3 Image Klein on your own ComfyUI takes them as well. There the Inpaint Canvas node writes the same sentences and rows from the boxes Scumble hands it, so the recipe needs the node at 0.4.1 or newer (on the Comfy Registry since 2026-10-23; 0.3.4 and older have no boxes): a node installed from the Comfy Registry is updated there, a git clone of https://github.com/DenRakEiw/ComfyUI-InpaintCanvas with git pull in its folder under custom_nodes; then restart ComfyUI. With an older node and the Boxes switch on, Generate and Generate new stop before anything is sent (Generate new before the picture is replaced) and say to update the node or to switch the boxes off. A description's @img1 goes as the name the recipe gives that picture in the prompt (<ref_image_1>). Generate new on it sends the document's New, Text and From reference boxes, scaled to the new picture as on an API model; a Keep, Move or Remove box has nothing to act on in a picture that does not exist yet and stays out with a note, while a From reference box goes along, since its reference goes with the run (an API model's new image leaves it out). Boxes the node has to leave out (outside the crop, or naming a reference that did not load) are named in the status line once the result has landed, and in ComfyUI's console.

FLUX 3 Image Klein on your own ComfyUI works best with Black Forest Labs' prompt upsampler in front of it, as Black Forest Labs' own pipeline runs it: a language model on your ComfyUI looks at the crop and the pictures after it and writes your few words out as the detailed instruction the model was trained on (on Generate new without reference pictures, a caption for the canvas's shape). Put its file, qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors (6.7 GB, from Black Forest Labs' flux-3-image-klein-comfy repository on Hugging Face, which asks you to log in and accept the licence), into models/text_encoders; the Prompt upsampler row in the Settings panel switches it (on by default), Upsampler model picks the file. After the run the status line shows the start of what the upsampler wrote, and the log (Help › Console (log), Ctrl+Shift+L) the whole of it; the history keeps your own prompt, so a second run writes it out again. Without the file, or while boxes go (its instructions take no boxes), the prompt goes as you typed it, with a note.

MOSS-Image on your own ComfyUI (ComfyUI 0.42 or newer, which runs it on its own nodes; the files from Comfy-Org/MOSS-Image on Hugging Face, Apache-2.0) makes new pictures only: use Generate new, since it takes no picture to edit, and Generate on a selection says so. With the Boxes switch on, your New and Text boxes go as its layout: the prompt describes the whole picture, each box's description says what is in it, and a Text box's words are rendered there. ComfyUI's own MOSS-Image Layout Prompt node places each box in the picture's pixels, from the Inpaint Canvas node's box list, so the same current node version is needed (an older one stops the run before anything is sent). Keep, Move, Remove and From reference boxes have nothing to act on in a new picture: the section names them and they stay out. 1 to 2 megapixels suit it best (the Megapixels row); the Preset row has Comfy's quicker settings (the default) and the model's own 50 steps.

Whether boxes go with a run is one switch: Boxes, in a row of its own under the prompt field. It shows while the selected recipe takes boxes, and its label counts the document's boxes ("Boxes · 3"). On, Generate and Generate new send the document's boxes. With no boxes, Generate sends your selection as one box, and the row says "the selection goes as one box": the model is told where in the crop the change goes and what to put there (the prompt), or, when the prompt names a reference with @img1, that this reference goes into the box. Off, no box goes and the boxes stay with the document; the row says "not sent", and a run says in the status line how many boxes did not go. The switch is off in a new document and is saved with it. The first box a document gets, drawn with the tool, made with Selection → box or added by an agent, turns it on, and the status line says so; switching it off never deletes a box. Undo takes that first box back but leaves the switch on, so the next run sends the selection as one box; switch it off when you want neither. The status line says how many boxes went ("Sent with 1 box."), the log keeps the prompt as it went out, rows included (on your ComfyUI the Inpaint Canvas node adds the rows itself, so they are not in the log; the node's notes on the boxes are), and a box under 48 pixels a side at the size the crop is sent at gets a note, the selection's and every other box that places something, since the model often leaves a box under about 40 pixels empty. A New box sent without a description gets a note too.

The Boxes tool (X, under Plugins in the tool column) draws them on the picture: drag on an empty place for a New box, click a box to select it (its row in the section lights up; a click on a row selects its box; where boxes lie on top of each other, the click takes the smallest), drag it to move it, drag one of its eight handles to resize it, and double-click it to type its description right on the picture (Enter keeps it, Shift+Enter starts a new line, Escape cancels; on a Text box it is the words; it goes into the prompt as words, never into the picture). Delete removes the selected box, D duplicates it, the arrow keys nudge it by a pixel (with Shift by ten), Escape lets go of it, and Alt+click picks a box that lies under another. A Move box's source and a From box's part get handles of their own once the box is selected; a box you turn into Move keeps its place as the source, and its target steps aside by a fifth of the picture, so you can drag it where the element should go. Each gesture is one undo step. While the tool is active or the section is open, the boxes show on the picture, each in a colour of its own that it keeps (its row in the section has the same colour at its edge), with their name and the first words of the description; the kind shows in the shape and the tag: a Move box has a dashed source and an arrow from it, a Remove box is hatched, a From reference box names its reference, a Text box carries a T, and Keep, Move and Remove say their kind when the name does not. While the Boxes switch is off they are drawn dashed and paler: they stay with the document but go with no run.

Selection → box takes the selection's bounds as a New box with the prompt as its description; when the prompt names a reference with @img1, the box places that reference into the selection instead. Clear removes every box, Copy rows puts the model's rows on the clipboard for use in another tool (measured against the whole picture). Every change is one undo step, the boxes are saved in the .scumble file, and they follow a crop, a turn or a resize of the picture.

A recipe that takes no boxes leaves them where they are, and the section says which is the case; under one that does, it says whether the switch sends them. A run measures the boxes in the crop it sends, so a box outside the crop is left out with a note in the status line (it still counts as the document's, so the selection does not go in its place). A box sets place and size, not a hard edge: the model may reach a little past it. It takes the size seriously: asked for "a small black cat" with the selection as the box, FLUX 3 painted a cat that fills the box, so draw a box as large as the thing should be. While the Boxes tool is active and something is selected, the picture outside the crop Generate would send is dimmed, with the crop's size under its edge, so you see which boxes it cuts. While the switch is on, the section warns of a New box without a description (the model would have to guess what goes there), and, while something is selected, when a box is too small to place anything in at the size the crop is sent at, lies outside that crop (it is left out), reaches past its edge (only the part inside goes), or changes the picture outside the selection: with Paste on selection (the Crop settings), the stitch keeps the result inside the selection only, so a box moved, removed or drawn outside it would be cut. Paste the whole crop in the warning switches Paste to the whole crop for this document. Agents and scripts have the same through boxes_add, boxes_set, boxes_remove, boxes_list, boxes_from_selection and boxes_clear, the section's warnings before a run through boxes_check, and the switch through set_generation (boxes).

A LoRA is a small add-on file for a model, trained to give it a style, a subject or a skill. The LoRAs section of the Generate tab, right after Settings, holds the LoRAs of the selected recipe. It shows while the recipe runs on your own ComfyUI (on this machine or a remote one, a RunPod pod for one) and its graph has one model loader: FLUX 3 Image Klein, Flux.2 Klein, Qwen Image Edit 2.1 and its Turbo, MOSS-Image, MOSS-Image Edit, P-H3-Image, and a workflow of your own imported as a recipe. It shows under the Comfy Cloud recipes too (below). Under an API recipe, an upscaler, the Realism Pass and relight it is not shown: LoRAs go to your ComfyUI and to Comfy Cloud, never to an API provider. The section is closed until you open it, and its title says how many rows are switched on.

Each row is one LoRA: a tick that switches it on or off, its name (the file's name without its folder; the tooltip has the whole path), its strength and × to remove it. + adds a row and opens the list of your ComfyUI's LoRA files, the ones in its models/loras folder. A recipe takes five rows at most; the + then greys out. The strength goes from −2 to 2 in steps of 0.05 on the arrows: 1.0 is the LoRA as trained, 0 leaves it out, below 0 pushes the other way; a typed value may go further, up to ComfyUI's own limit. A switched-off row stays in the section and is not sent.

The list has a search field: type part of a name or a folder, move with the arrow keys, Enter or a click picks the file, Escape or a click outside closes the list. The files are grouped by subfolder, each with its count. When Scumble knows which model the recipe runs, the folders that look made for it come first and the rest wait behind Show all; Only the ... folders goes back. The list is read from your ComfyUI every time it opens, so a file you just copied into models/loras shows up (ComfyUI itself may need a refresh to see it). Without a connected ComfyUI the list says so, and the row keeps the name it has.

Under a picked LoRA a grey line says which model it looks made for. "looks like FLUX 3" is read from the names of the tensors inside the file, which Scumble can do when your ComfyUI runs on this machine and Settings › Helpers (in-app models) points at its models folder (Change folder ... there); the file is only read, never changed. Otherwise the line says what the file's own metadata claims ("metadata says SDXL"), which is often wrong, since many training tools write a default there, or which folder the file sits in ("in folder klein"). Where two models have the same shape, the line names both ("looks like FLUX.1 or FLUX.2 Klein 4B"). The line's tooltip says where it comes from.

When the tensor names say the LoRA was made for another model than the recipe runs, the line turns amber: "This LoRA looks made for FLUX.1; this recipe runs FLUX.2 Klein. ComfyUI loads it without an error and the picture may come back unchanged." Scumble does not refuse the run on it. ComfyUI loads a LoRA it cannot use without an error and leaves out every part that does not fit; only its own console says so, with a "lora key not loaded" line for each part, and Scumble cannot read that console. A FLUX.1 LoRA on FLUX.2 Klein and a Qwen Image Edit 2509 LoRA on Qwen Image 2.1 both gave back the picture they gave without it. Only the tensor names make the line amber; a guess from the metadata or the folder stays grey.

Words a LoRA was trained with show as chips under its row, when the file names them; a click on one adds it to the end of the prompt.

The rows belong to the recipe, not to the document: every tab with that recipe shows them, a change in one tab shows in the others, and they are there again when you pick the recipe again. A LoRA fits only the model it was trained for, so each recipe keeps rows of its own. Save as new recipe in the ComfyUI window gives the new recipe the rows of the one it came from.

A run loads the switched-on rows in their order and at their strengths, between the recipe's model loader and whatever reads the model, in the copy of the graph that goes to your ComfyUI; the recipe file never changes. (A workflow of your own whose model loader also loads the text encoder, a checkpoint loader, gets each LoRA on both at the same strength.) The status line names them ("LoRAs: Flux3_Targa 0.8, nyc_style 1.0."), so does the result's line in the history ("FLUX 3 Image Klein (ComfyUI) via your ComfyUI + 2 LoRAs: Flux3_Targa 0.8, nyc_style 1.0, 14 s"), and a PNG export with Prompt and recipe in the PNG on lists them. A row naming a file your ComfyUI does not have is marked "(not on the server)" in red, and a run with that row switched on stops before anything is uploaded: "Your ComfyUI lacks a LoRA file this recipe's rows name: ... Put the file in models/loras (and refresh ComfyUI), pick one of the server's files in the LoRAs section, or switch the row off, then try again." While Scumble has not read your ComfyUI's list, nothing is refused and ComfyUI answers for itself.

MOSS-Image Edit and P-H3-Image carry a LoRA of their own inside the recipe: MOSS-Image Edit its edit LoRA, P-H3-Image Pruna AI's P-H3-Image LoRA. That one is a row of the Settings section (Edit LoRA and its LoRA strength; P-H3-Image LoRA), not of the LoRAs section, and a ComfyUI without its file stops the run with the download link. Your own rows go after it. MOSS-Image Edit's edit LoRAs trained with ai-toolkit replace the recipe's own and need its encoders set for them (the Recipes chapter says how).

Comfy Cloud recipes take LoRA rows too, the same way, from Comfy Cloud's own lists: the list's title is LoRAs on Comfy Cloud, the LoRAs Comfy Cloud lists as your own models (the ones you imported on its site, Creator plan or higher, from Civitai or Hugging Face) come first under Your imports, then Comfy Cloud's catalog. That an import shows under Your imports has not been checked yet (the account it was tried with had none). A file name typed into the search and taken with Enter (Use "..." as typed) goes as written, for an import the list does not show; a row Comfy Cloud's lists do not name is marked "(not in Comfy Cloud's lists)" in amber, and the run is not refused on it (Comfy Cloud answers for itself). There is no grey line under a Comfy Cloud row: Scumble cannot read those files. Generate and Generate new both load the rows, and the status line and the history name them as on your ComfyUI; a Qwen Image Edit 2509 run on Comfy Cloud with one of its catalog LoRAs took the row and named it in the history line. When a run fails, its message names a LoRA only when neither of Comfy Cloud's lists has it. Comfy Cloud's Ideogram 4 takes none (its graph has two model loaders); the section's tooltip says so. A LoRA can also go into a recipe's graph by hand: Edit in ComfyUI, a Load LoRA node, Save to recipe.

Scumble is a layered editor that happens to generate, not a generator with an undo button. Every result, every paint stroke, every piece of text and every filter is a layer with an opacity, a blend mode, a mask and a name. You can reorder them, duplicate them, merge them down, hide them, erase into them and copy them between tabs. Flatten is a command you give, not something that happens to you.

Colour match is the feature I would keep if I had to throw the rest away. A generated patch almost always comes back a little off: a shade cooler, a touch brighter, a different contrast to its surroundings. The Match slider in the layer row corrects that by matching the layer's statistics to what lies around it — or to what lies below it, your choice in the same row — and it is non-destructive, so you can move it any time.

Masks do the rest of the fitting. Every layer can have one, painted with the normal brush, and what a mask hides comes back when you paint the mask again. The eraser removes a layer's pixels themselves; an over-eager erase is one Ctrl+Z away. The paint brush and the eraser also have Flow: below 100 % each dab lays down only part of the paint, so a stroke builds up where it overlaps itself (Opacity still caps the stroke as a whole). For a pen, Pressure picks how pressure sizes the brush (linear, soft or hard), and Stabiliser makes the brush follow the cursor on a string of that many screen pixels, which calms a trembling hand; letting go draws the rest of the line to the cursor. For photographic repairs there are clone, heal and smudge tools that work like the ones you know. Their Sample option says what they pick up: the active layer alone, or the whole visible picture (the smudge also offers the layers up to the active one, below); the smudge on the base paints into a new layer from the picture, since the base itself is never changed. The smudge carries the paint it picks up: Strength is how much of it goes down at each step, Length how far it goes on (0 leaves it where it lands, towards 100 it is dragged to the end of the stroke), and Finger starts each stroke with the paint colour on the brush. It drags transparency as well as colour, so a stroke that starts outside a layer's edge thins what it crosses; alpha lock keeps the layer's alpha. An imported brush tip shapes the smudge too. The smudge tool's Mode turns it into a blur or a sharpen brush: each dab moves what it passes over towards a softer or crisper version of the picture as it was when you pressed, by the strength; the dabs overlap, so at the default strength one stroke goes nearly all the way (a single click goes as far as the strength says), and for a gentle touch you set the strength low. Going over a place again in the same stroke does not overdo it; a new stroke adds more. Dodge / burn (Shift+O, in the same group) lightens or darkens what you paint over: Range picks the shadows, midtones or highlights, Exposure how far one stroke goes, and Protect tones moves the three colour channels together so colours keep their hue (off, each channel is curved on its own); a strong highlights dodge can still blow out what is already bright, and a shadows burn can crush the darkest parts to black. Hold Alt while you press to burn with the dodge and the other way round. Its Mode also has the sponge: saturate (with Vibrance, dull colours gain more than vivid ones, and nothing clips) and desaturate. Like blur and sharpen, a stroke works from the picture as it was when you pressed, so it does not pile up over itself; paint again to go further. Sample and the base work as for the smudge. Clone and heal can turn, scale and mirror their source (Angle, Scale, Flip H, Flip V), and with Overlay on you see what the brush would copy, half transparent under it, before you press; imported tips shape them as well. Heal copies the source's texture and blends it into the colour and light around the stroke: while you paint you see a quick version, and when you let go the stroke is blended so that it meets the picture without a rim (a large stroke takes a moment; the brush and the shortcuts wait for it, and Ctrl+Z takes it back once it has landed). With a selection, the blend stops at the selection's edge and meets the picture there too. The quick version stays on a scaled layer, for a stroke larger than about 8 megapixels of box, and where the source's transparency splits the stroke into thin strands. Clone and heal paint pixels, so they refuse while quick mask is on or a mask is being edited.

Remove (Shift+J, in the same group) takes things out of the picture: brush over an object, a person in the background, a wire or a blemish, generously, and let go. While you paint the stroke shows as a pink mark; when you let go, LaMa, a model that runs inside Scumble, fills it from what surrounds it, and the fill lands in the active layer as one undo step (on the base, in a new layer, so the original stays underneath). It needs no prompt, no key and no ComfyUI, but the model has to be downloaded once in Settings › Helpers (in-app models) (198 MB). Scumble loads it as soon as you pick the tool, which takes about ten seconds the first time; after that a stroke takes one to two seconds on the processor, and the brush and the shortcuts wait for it. Sample says what it fills from: the visible image or the active layer alone. The model looks at a square around the stroke twice as wide as the stroke, at 512 × 512 pixels: a small spot is filled at the picture's full resolution, a large stroke comes back softer than the picture around it, and a stroke wider than 2,048 pixels is refused (select the area and use Generate with a model recipe instead). With a selection only the selected part of the stroke is filled. Like clone and heal, Remove refuses while quick mask is on or a mask is being edited, and on a layer that is scaled.

Patch (Shift+J again, in the same group) repairs a whole area at once. Lasso the spot with the tool itself (or select it any other way), then press inside the selection and drag: the selection's outline follows the pointer, and the spot shows what lies under the outline. Let go where the picture is right, and that texture is laid into the spot and takes on the colour and light around it, right up to its edge, the healing brush's blend for a whole area. Mode Destination turns it round: what is selected is copied to where you let go and blends in there. Blend below 100 % keeps more of the copied texture's own colour, and 0 % copies it as it is. The patch lands in the active layer as one undo step (on the base in a new layer) and the selection stays where it was, so you can drag again: a second drag patches over the first (with a feathered selection the first try still shows faintly in the soft edge), so press Ctrl+Z first to try another source from scratch. Esc during the drag cancels it. A soft (feathered) selection gives a soft edge. Patch works on a layer at its own size, not on text or filter layers, and blends up to 8 megapixels of selection at a time.

Content-aware move (Shift+J a third time, in the same group) moves something to another place in the picture. Lasso the object with a little of its surroundings, press inside the selection and drag it; let go where it should be. The object lands there as it was, and a band inside the selection's edge takes on the colour and light of its new place, so the bit of old background you selected with it blends in; LaMa fills where it was, from what surrounds that place, as Remove does. Mode Extend leaves the original and places a copy (no model needed). Blend All lets the whole piece take on the new place's colour and light, not only its edge: better when the object moves into shade or sun, worse when its own colour matters. It needs the LaMa model for Move (Settings › Helpers (in-app models)), lands in the active layer as one undo step (on the base in a new layer), and the selection stays where the object was. A feathered selection moves as far as its outline (the marching ants) reaches; the blend does the soft edge. A selection much larger than the object keeps more of the old background around it, and where the old and the new surroundings differ a lot a faint halo can remain with Blend Edge: select the object more closely, or use Blend All. The old place is filled at the model's 512 × 512, so a large object leaves a softer fill; with Move the selection can be up to 2,048 pixels across (the old place LaMa has to fill), while Extend has no such limit.

Liquify (Shift+W, or Ctrl+Shift+X; in the same group) bends the picture like wet paint. Mode push drags what is under the brush along with the cursor; grow swells it and shrink pinches it, swirl turns it clockwise or counter-clockwise, and restore brings back the layer as it was. Grow, shrink, swirl and restore keep working while you hold the button still; Alt while pressing swaps grow and shrink and the swirl's direction. Strength is how far one dab moves the picture (with push at 100 % the picture under the brush's centre follows the cursor all the way), the brush's size and hardness shape it, and a pen's pressure scales the strength. While you drag you see the result; when you let go it lands in the active layer as one undo step. Every stroke is taken from the layer as it was when you started liquifying it, so a hundred strokes blur the picture no more than one does, restore finds the original pixels, and Restore all puts back the whole layer (inside the selection, if there is one). The session ends when you pick another tool; after that, restore goes back only to that point. A selection limits Liquify: what lies outside it stays where it is. Freeze does the same with the brush: in the modes freeze and thaw you paint what should stay where it is (shown in red while the tool is Liquify, with Freeze ticked) and free it again; Alt swaps the two, a lower strength freezes only partly, and the two buttons beside the tick clear the freeze or invert it. The freeze belongs to the layer while the document is open, across tools and sessions; it is not undone and not saved. On the base Liquify works on a copy of it, the layer Liquify, directly above it; one Ctrl+Z takes the copy away again. The layer mask stays where it is and a layer does not grow: what is pushed past a layer's edge is cut, and what is pulled in from outside is transparent (on a layer as large as the picture, its edge repeats). Liquify refuses a text or filter layer, a scaled layer or one placed between pixels, a layer whose transparency is locked, and quick mask or a mask being edited. The grid it moves on is 1 pixel up to 4 megapixels, 2 up to 16, 4 above (8 beyond 256 megapixels), so on a very large picture a very small brush bends softly; the picture while you drag is a little softer than the result.

Around all this sit transform (move, scale, rotate, flip, with a perspective mesh), crop, and extend canvas — which is how outpainting starts: extend the canvas, select the new empty part, prompt, generate. Or pick an Outpaint recipe (Image Expand on Magnific), which extends the picture outward from what is kept: after Extend canvas the new border is already selected, so Generate is the only step left.

A filter in Scumble is a layer, not a one-way change to your pixels. Add one and everything below it is filtered; drag it up or down and it filters more or less; set its opacity, give it a mask, or switch it off. Its settings stay editable a week later.

The built-in set covers the photographic basics: grain with film presets, curves, levels, colour balance, colour grading, HSL, vibrance, gradient map, threshold, posterize, exposure and contrast, sharpen, blur, lens blur, normalise, vignette, haze by depth, dehaze, and LUTs from .cube files. They run on the GPU through WebGL2, so they stay interactive on large pictures, with a processor path as a fallback. A filter layer can be limited by depth, brightness or colour: it acts only where the picture lies in a chosen range, with soft feathering at each end, while a painted mask refines it further. A colour or haze that grows with distance is a fill or filter layer with a depth limit.

Haze by depth simulates atmospheric haze and aerial perspective using the scene's depth map: pixels farther away fade smoothly into airlight with adjustable density, start distance, falloff curve, and desaturation. The airlight colour can be sampled automatically from the farthest distance in the picture or set to a custom tint. When edge snapping is active on the depth map, haze respects fine object silhouettes without halos.

Dehaze takes haze out of what is below it. The picture finds the haze in the picture itself; The depth map takes it from the distance, which keeps near things untouched. Protect sky holds back where the picture is close to the haze colour, so a clear sky does not turn grey or noisy.

Lens blur simulates optical depth-of-field and realistic disc bokeh using the scene's depth map: blur grows away from the focus depth with a circular aperture disc sampled by a 64-tap Vogel spiral. Aperture controls the blur radius (up to 1.5% of the long side), while Depth of field sets the sharp range around the focus plane. Specular highlights can be boosted with adjustable brightness threshold and strength. Foreground boundaries are protected by scatter-as-gather sample weighting, preventing blurred background colours from bleeding over in-focus subjects.

Colour grading provides four colour wheels (Shadows, Midtones, Highlights, Global): drag a wheel's puck for hue and saturation, double-click to reset, and adjust brightness with the slider underneath. Balance shifts where shadows and highlights meet the midtones; Blending softens or hardens the crossover.

HSL adjusts hue, saturation and luminance across 8 colour channels (red, orange, yellow, green, aqua, blue, purple, magenta): mode buttons switch between Hue, Saturation and Luminance, with a swatched slider per channel (-100 to 100), and a Reset button (click to reset the current mode, Shift+click to reset all three modes). Smooth bell-curve channel weighting preserves neutral greys and low-saturation pixels cleanly.

Vibrance enhances colour saturation with skin tone protection: lower-saturated colours receive more boost than already-saturated ones, and warm skin tones (where red exceeds green and green exceeds blue) are preserved with halved boost. Saturation provides uniform adjustment across all colours.

Gradient map maps the picture's Rec. 601 luminosity across colour gradients, with built-in presets (Cyberpunk, Sunset, Teal / Orange, Sepia, Infrared, B&W contrast) or custom two-tone gradients (Shadow and Highlight). Includes reverse mapping and opacity blend.

Threshold converts the image into high-contrast pure black and white at an adjustable luminosity level (1 to 254), preserving layer alpha.

Posterize quantizes pixel values into a discrete number of tonal steps (2 to 32 levels per channel), creating stylized graphic and poster effects.

Every filter layer ends with a Limit row. Set it to Depth, Luminosity or Colour to confine the effect to a chosen range: the range bar shows the histogram of what lies below the layer, with draggable range handles, soft feather ramps at each end, Invert, and an eyedropper to pick a value straight from the picture (or a colour swatch and tolerance when limited by colour). For example, to darken the far half of a landscape, add a curves layer, pull down the curve, and in its Limit row pick Depth with a range of 0.5 to 1 and a feather of 0.1; the filter then acts only in the distance, leaving the foreground untouched. If the document has no depth map yet, an inline Compute depth map button calculates it directly from the row. The Edges slider in the depth controls snaps depth boundaries cleanly to picture edges (hairs, leaves, silhouettes) without re-running the model. Fill layers can also be limited by depth to create distance haze or atmospheric fog. Choosing Off removes the limit.

A fill layer works the same way but paints instead of filtering: the fill button in the layer list adds a layer of one colour (the paint colour to start with), and its row turns it into a gradient, linear, reflected or radial, between two colours that each have their own opacity (from the fill's colour to transparent to start with), with an angle, a scale and a centre set in per cent. It covers what is below it until its blend mode, its opacity or a mask lets the picture through, and it can be changed as long as the document exists. PSD and ORA exports write it as an ordinary layer of pixels.

Two plugins ship with the app: the film pack and the effects pack.

The film pack goes further: film looks with real film names, halation, glow, bleach bypass, cross processing, split toning, light leaks, frames, and control points that steer a look locally. Control points (U) can be circles, oriented ellipses (with draggable long-axis placement and dual radius/height handles), closed polygons (3 to 16 corners with draggable vertices, Enter/double-click closing, Backspace undo, and an adjustable feather slider), or graduated lines (dragging from zero to full effect with orientation, feather, and softness handles), with adjustable softness (diffusion 0..100, default 75), size, second axis height, and feather, in addition to colour tolerance, exposure, contrast, saturation, warmth, and structure. Escape cleanly deselects the active point (and cancels box placement in the boxes tool). Points can be copied and pasted across pictures or layers via the assistant or commands (film.copy_points and film.paste_points, scaled to document dimensions with radii scaled by the geometric mean and anchor colours re-sampled). The names are there so you know what a look is after; the values are Scumble's own approximations, not licensed manufacturer data, and the tooltip and the About dialog say so.

The effects pack adds creative optical, dispersion and distortion filters: - Chromatic shift: simulates dispersion and colour fringe aberration across three styles: Plates (three colour plates out of register 120 degrees apart), Lateral (transverse aberration radiating outward from the picture's centre), and Linear (directional dispersion along an adjustable angle). An accelerated WebGL2 path and an exact CPU twin ensure consistent rendering across exports and platforms. - Glass: simulates architectural glass fluting, ripples and tiles across six styles: Ribbed (sine ridges), Reeded (fluted linear lens per rib), Wavy (2D orthogonal waves), Blocks (hash-based tile facets), Frosted (fine-grained fractal value noise), and Pebbled (organic Voronoi-like lens cells with jittered centres). Adjustable size, displacement amount, orientation angle, specular sheen, seed, and Frost blur (0..20 px pre-displacement light scattering) create textured, tactile optical distortions.

Text is a layer that stays text: font, size, colour, spacing, alignment and a few effects, editable after the fact, exported into PSD as its own layer. The bundled fonts are open-licensed; the + beside the font list adds your own font file (.ttf, .otf, .woff or .woff2), which stays in the list from then on. Fonts installed on your system are not listed: add the file with + to use one.

The shape tool draws rectangles, ellipses, polygons, Bezier paths and freehand paths, filled, outlined or both, with a corner radius, clipped to the selection if there is one. Each shape is one undo step.

Brushes can be loaded from Photoshop .abr files, which means the brush set you already own works here for painting and for masking. Click the tip's thumbnail in the brush bar to see every tip with a stroke drawn with it, the ones you used last on top and a search box for a pack of hundreds; a click tries a tip, a double click or Enter takes it and closes the list.

And there are 3D objects: drop a .glb file in, and it is placed into the picture as a layer you can rotate, scale and light. It is a niche feature with a clear use — a product, a prop or a reference shape put into a scene in the right perspective before you let a model paint over it.

The Upscale button sits next to Generate new and opens a small dialog: which upscaler, then the selection or the whole picture, then the factor. Which of the two you pick changes what happens more than it sounds.

The selection goes out at its own size and comes back sharper at the document's resolution — a detail pass on a face, a label, a piece of texture, landing as a layer like any other result. The whole picture goes out alone and the answer becomes the new base: the document is resized, layers, masks and the selection scale with it, and that is one undo step.

Through a provider you get Topaz (Precision, Bloom, Wonder), Clarity, SeedVR2, Recraft and Magnific (Precision and Creative), each on its own key or through fal; the three Topaz models also through Oxen.ai. Times differ wildly and the status line warns you about the slow ones — Magnific Precision took five minutes for a small box in my own test, Topaz about twenty-five seconds for the same kind of job.

On your own ComfyUI, the Upscale model recipe runs any model in your server's upscale_models folder — ESRGAN, UltraSharp, DAT, whatever you have. RTX Video Super Resolution (ComfyUI) runs NVIDIA's video upscaler on an RTX card there: it takes compression artefacts out and cleans edges without inventing detail, 1 to 4 times, with a Quality setting (LOW to ULTRA). It needs the node pack Nvidia_RTX_Nodes_ComfyUI on that ComfyUI, and its answer may be at most 8192 pixels on the long side, so a large box or picture at 4× is refused before anything is sent. RTX Video Super Resolution (Comfy Cloud) is the same upscaler on Comfy Cloud's GPUs, on your Comfy key and billed in Comfy credits, with nothing to install: the same factors, Quality and 8192-pixel cap, for the selection or the whole picture, listed with the providers; it ran a 1024 × 1024 picture to 2048 × 2048 in about 21 seconds (2026-10-04), and a cut-out picture comes back opaque, black where it was transparent. Both ComfyUI recipes work on the selection and on the whole picture: for the whole picture the base goes to your ComfyUI alone, and the answer becomes the new picture with every layer scaled along, as with the providers. For the whole picture, the Upscale model recipe takes at most 2048 pixels on the long side, so a 4× model answers at most 8192; a selection has no such cap. On this route a cut-out picture comes back opaque, black where it was transparent (ComfyUI loads it without the alpha), and the dialog says so. While it runs, the title row's timer shows the recipe and its Cancel takes the job off your ComfyUI. Three of the upscalers, Clarity, Magnific Creative and Topaz Bloom on Oxen.ai, also take a prompt; since 0.1.27 the dialog shows a prompt field for those, filled from the Generate tab but sent separately. An upscale sends no reference pictures, so an @img token comes into that field as its layer's name.

Generated people often come back with skin like wax and hair and fabric that look moulded rather than grown or woven. The Realism Pass sends the picture through DLSS 5 Neural Rendering, NVIDIA's neural renderer, on your own ComfyUI, so that generated skin, hair and fabric look less waxy. It is a refiner first: at 1× the picture keeps its size, and the answer comes back as a new layer above it, so the picture underneath stays as it was. At 1.5× to 3× it also makes the picture larger, with the pass on top at the new size. The label says what it needs and means it: a ComfyUI on Windows with an NVIDIA RTX card, and a community node pack with its runtime that you install there yourself. Scumble ships none of it.

Open Upscale, or Image › Realism Pass (Windows only, RTX only)..., which opens the same dialog with the pass already chosen, and pick Realism Pass (Windows only, RTX only) as the model. The factor offers 1× (refine), 1.5×, 1.7×, 2× and 3× (1× to start with), and the scope is the whole picture; the selection is not used. The row below holds the pass's own settings: Style (Default, Natural or Cinematic), Strength (0 to 1, how strongly the neural rendering is applied) and Preset, the DLSS model preset (Default, J, K, L or M; L to start with). They count for every document, not for one picture. Press Upscale and the dialog closes; the status line follows the pass while it reads the picture, sends it, waits in your ComfyUI's queue and runs, and the title row shows its timer with Cancel beside it.

What goes out is the picture as you see it: every visible layer with its filters and blend modes, without the reference layers. The exception is a run of filter layers at the top of the stack, such as a film look or grain: they are not sent, because the pass would smooth grain away as noise, and the new layer goes in under them, so they stay live above it. The new layer is called Realism Pass (Windows only, RTX only), covers the whole picture, and adding it is one undo step. It comes without a colour match, since the pass shifts colours a little along with the texture: its opacity sets how much of the pass you keep, its Match slider takes a colour shift back (its source is underneath: the picture the layer covers), and a mask keeps the pass off a part of the picture, a background that should stay soft, say. A second run reads everything visible, the first pass layer included, and stacks its own layer above it. The pass also takes noise and grain out of the picture itself, so a grainy photo comes back cleaner; put grain back with a filter layer above it if you want it. A transparent picture goes out over mid-grey and comes back with exactly its own transparency; soft edges can come back a little lighter.

At 1.5×, 1.7×, 2× or 3× the pass makes the picture larger in the same run: DLSS answers at that many times the size (1.7× is its Balanced mode, 1.724 times), the document is made that much larger first, the base and every layer, mask and the selection scaled as the Canvas section's Resize row scales them, and the pass layer covers the larger picture. Making it larger and adding the layer are one undo step: one Ctrl+Z takes both back. Only the pass layer holds new detail; the layers under it are resampled, so the pass layer is what you keep, or hide it to see the picture merely enlarged. The pass answers at most 7680 × 4320 (long side × short side) and 27.9 megapixels: the pack makes up to 7680 × 4320, but when it was measured, answers near 30 megapixels sometimes came back with broken colours and no error, and larger ones always did, so Scumble stays below that with a margin. A picture whose answer would be larger is not refused: it is scaled down first, with plain resampling and no model, to the largest size of its shape whose answer fits, so the answer comes back as large as the pass allows, smaller than the factor alone would make it. The dialog's size note says what goes out and what the picture becomes, and the status line says "Realism Pass (Windows only, RTX only) scaled the picture down to W × H first: its output is capped at 7680 × 4320 and 27.9 megapixels." A 5456 × 3072 picture at 1.5×, for example, goes out at 4690 × 2640 and comes back at 7036 × 3960, and a 3840 × 2160 picture at 2× goes out at 3520 × 1980 and comes back at 7040 × 3960. A picture that is already about as large as the pass answers (7680 × 4320, say) cannot get larger, and a long narrow picture whose scaled-down copy would be under 64 pixels a side is refused; both before anything goes out.

On an RTX 5090, a 5456 × 3072 picture took about 8 seconds on the ComfyUI at 1× (10 seconds in all, reading and sending included) and about 4.6 GB more graphics memory while it ran; a box of about 1000 × 1000 pixels through the recipe took about 12 seconds; at 2× a 1920 × 1080 picture took about 7 seconds and about 3.2 GB more graphics memory (measured 2026-10-04). The DLSS worker starts anew for every run, so a small picture does not take much less.

The pass goes to the front of your ComfyUI's queue but never interrupts a job that is already running there; while it waits, the status line says how many jobs are ahead. Cancel takes only Scumble's own job off the server. While the pass works on a document, that document takes no second run that would land in the same picture: an API Generate, an upscale, Generate new and a turn of the picture are refused with a note until the layer is in, while Generate with a recipe on your own ComfyUI still queues. If the picture changes while the pass runs, the layer shows it as it was when the pass started, and the status line says so. Closing the tab asks first and ends the pass, and nothing is added.

The pass is also a recipe of the same name in the recipe picker, among the local recipes. With it selected, Generate sends the selection's box with its surroundings at its own size, without a fill and without the reference layers, and the answer lands over the box as a result layer, stitched like any local result; Select All first runs it over the whole picture that way. Its Settings section has the DLSS model preset row with two presets that come with the recipe, L (the default) and M; Style and Strength are the ones in the Upscale dialog's row. Use the box with care: the pass changes colour and texture and takes out the grain, so a passed box can stand out against the unpassed picture around it, its edge showing where the grain stops. For an even look, pass the whole picture and mask the layer where it should not show. Generate new does not offer the recipe, since the pass makes nothing from a prompt.

There is no Comfy Cloud version of the pass. Comfy Cloud runs no custom nodes, and the runtime needs Windows on the machine with the graphics card; the recipe has no Cloud copy, and nothing of the pass goes to Comfy Cloud.

Everything the pass needs lives on the machine your ComfyUI runs on, which need not be the one Scumble runs on: Scumble asks the connected ComfyUI what it runs on, not your own computer. That machine needs Windows; an NVIDIA RTX 50, 40 or 30 card with a current driver (NVIDIA ships DLSS 5 for the RTX 50 series, the community runtime also runs it on the 40 and, as an experiment, the 30 series, and RTX 20 and older are refused); a ComfyUI recent enough for the V3 node API; the Inpaint Canvas node pack, as every local recipe does; the community node pack ComfyUI-DLSS5-Enhancer (github.com/Blueforcer/ComfyUI-DLSS5-Enhancer); and that pack's runtime, a download of about 467 MB (about 700 MB on disk) from the community project Merserk/dlss5-visual-enhancer on GitHub. The runtime holds NVIDIA's proprietary DLSS libraries and other files under their own terms. The pack's installer tells you to install only components you are authorised to use; install it only if you trust the source.

The steps below follow the pack's README as it was on 2026-10-04 (pack version 1.1.0); where the README says something different by the time you read this, the README is right. The commands are for the Windows portable ComfyUI and run in its folder, the one that holds python_embeded and ComfyUI; with another install, use the Python your ComfyUI runs with.

A Relight layer illuminates your picture with up to four interactive light sources in 3D space, calculated in real time from the scene's 16-bit depth map. Add one from the Layer menu (New Relight Layer) or the Add Filter list. If the document has no depth map yet, Scumble calculates one automatically using Depth Anything V2 Small.

The Lights tool. Select the Lights tool (L) or click Edit lights in the layer row to interact with light sources directly in the viewport: - Move: Drag a light handle across the picture to move its source in 2D coordinates. While dragging, a fast quarter-resolution preview updates interactively. - Distance: Hold Alt and drag up or down over a handle to bring the light closer or push it deeper into the scene (negative values place the light in front of the image plane; positive values place it behind). - Diffusion and intensity: Roll the mouse wheel over a handle to adjust light diffusion (softness), or hold Shift while scrolling to adjust intensity. - Nudge: Press the Arrow keys to nudge the selected light by 1 pixel, or Shift+Arrow for 10 pixels. - Add and delete: Click anywhere on the picture to add a new light at that point (up to four lights per layer), or press Delete / Backspace to remove the selected light. - Hide handles: Press H or click the handles eye toggle button in the relight controls header to hide on-canvas handles for an unobstructed view of the relit picture. - Own light: A grey compass ring indicates the estimated direction of the original scene lighting.

Light types and controls. Each light can be configured individually in the layer row: - Presets: The Presets dropdown in the relight header provides 8 curated setups (Studio portrait, Warm sunset, Cyberpunk neon, Rembrandt, Soft window, Dramatic rim, Golden hour, Film noir) scaled to your document's dimensions, undoable in a single step. - Point light: Casts omnidirectional light with smooth inverse-distance attenuation and distance-based falloff. - Sun: Casts parallel directional sunlight from a distant azimuth and elevation angle, illuminating the entire scene without radial falloff. - Spot: Projects a focused cone of light with adjustable cone angle, soft feathered boundary, and target aiming. - Gobo patterns: Spot lights support procedural gobo masks (None, Blinds, Window, Leaves, Stripes) that project architectural slats, window mullions, or foliage silhouettes into the beam. - Colour and temperature: Set the light tint using Kelvin presets (Tungsten 2700 K, Halogen 3200 K, Fluorescent 4000 K, Daylight 5500 K, Overcast 6500 K, Shade 8000 K, Blue sky 10000 K) or a custom colour picker. - Gloss (specular): Adds Blinn-Phong specular highlight reflection off 3D surface normals (0% to 100%, default 0%), enhancing eye catchlights, shiny surfaces, or moist skin without altering diffuse shadow tones.

Global parameters. The relight filter row provides four master controls: - Original light: Fades down the existing lighting in the original photograph (100% preserves original shading, 0% flattens shading) using an estimated ambient-diffuse reflectance decomposition. - Ambient: Sets the minimum fill floor so deep shadow recesses remain visible. - Depth: Adjusts the extrusion scale of the 3D surface normals generated from the depth map (5% to 200%). - Shadows: Enables screen-space raymarched cast shadows with contact hardening and soft penumbra. Setting the slider to 0 turns off shadow raymarching for instant rendering.

Where a strong light pushes a bright area past white, it rolls off softly towards white instead of clipping flat; parts of the picture the lights leave alone keep their exact values.

Routes and generative relighting. Relighting can run directly inside the app or route to generative models: - App (default): Runs on your own computer. The graphics card draws the light; the surface shape and the cast shadows are worked out on the processor in background threads. It is completely non-destructive and needs no network and no AI tokens; the depth model it uses is a one-time download in Settings › Helpers (in-app models). - Generative routes: The Relight layer offers alternative render passes that feed your lighting geometry and prompt words into external diffusion models: - Magnific (image-relight): Sends the picture and an isolated light map (ambient floor plus lighting term alone, mode 1) to Magnific Relight. - ComfyUI local (relight_qwen_local): Executes locally on your ComfyUI instance using Qwen-Image-Edit-2509 with the Relight LoRA and Lightning 4-step LoRA. - Comfy Cloud (image_qwen_image_edit_2509_relight): Runs the detached 2509 relighting workflow on Comfy Cloud. - fal (fal-ai/iclight-v2 and bria/fibo-edit/relight): IC-Light v2 steers lighting via position and initial latent; Bria relighting takes its Light type from the lights by default (From the lights: a sun gives low-angle sunlight, a spot a spotlight on the subject, otherwise soft overcast daylight) or one of 13 curated lighting atmosphere styles (e.g. sunrise, midday, blue hour, studio lighting, moonlight); a style picked there is kept for new relight layers until From the lights is picked again. - Detail from original: On generative routes, Scumble computes a channel ratio between the generated result and the original base, upsampling it via a bilateral guided filter against the high-resolution picture. This transfers the model's new lighting while preserving 100% of the photograph's fine micro-texture and sharpness. It works up to 27.9 megapixels: on a larger picture a render with it on is refused before anything is sent, so turn it off or scale the picture down. - One-click landing: Clicking Render lands the result as a new pixel layer named Relight (<route>) directly under the top filter run, hiding the filter layer in a single undo step so you can easily adjust lights and render again.

A green or blue screen behind a subject (a photo plate, or a subject you generated on a flat green) can be cut out far better than a selection does: hair, motion blur and see-through edges keep their soft alpha, and the screen's colour that spilled onto the subject is taken out. Image › Key Green / Blue Screen... does that with CorridorKey 2.0 by Corridor Digital, a keying model that runs on your own ComfyUI through the community node pack ComfyUI-CorridorKey2.0. Scumble ships none of it: the pack and its models live on the machine your ComfyUI runs on, which need not be the one Scumble runs on.

The dialog keys once when you press Key. Drag it by its title row to move it off the part of the picture you want to see: it stays inside the window and comes up in the same place until Scumble closes, and a double click on the title row puts it back top right. Its × closes it, as Close and Escape do. Screen is Auto (Scumble reads the colour along the border of the box; when it is neither clearly green nor clearly blue it asks you to pick), Green or Blue. Hint is From the selection: the selection's coverage tells the model roughly where the subject is, a rough brush selection or a selection by text is enough; or None, and the model decides alone. Trust says how much the hint is believed: Rough (0.5) for a quick brush, Automatic (0.75), Clean (0.95) for a selection that already follows the edge. Despill (0 to 1, 0.5 to start with) is how much of the screen's colour is taken out of the subject. Source is the visible picture, or the active layer. A line under the route says whether your ComfyUI can key and what is missing if not, and another says which box goes and at what size.

The answer lands as one new layer Key: the subject's own colour with the spill taken out, its layer mask the matte (white where the subject is), trimmed to the part of the box the matte keeps. With the visible picture as the source, a mid-grey Fill layer Grey goes under the key so you see the matte against something neutral; replace it with your background, or tick Leave the base as it is in the dialog. The key of the visible picture goes to the top of the stack, under a run of filter layers there (a film look or grain), which stay live above it. With a layer as the source the key goes directly above it, and that layer is hidden in the same step. Adding it is one undo step: one Ctrl+Z takes the key, the grey layer and the hiding back.

The box is the selection's bounds grown by half their longer side for context, at least 768 pixels a side, kept inside the picture; a box cut tight to the subject keys worse, since the gaps between hair or leaves need the screen around them. Without a selection the box is the whole picture, or the source layer. The box goes at its own size up to 16 megapixels and 8,192 pixels a side; a larger box (a 15,000 × 10,000 picture as a whole, say) is sent scaled down by one factor, and its matte is brought back to the box's size and its edge fitted to the picture at full resolution. Nothing is refused for its size.

With the Key layer active the dialog offers Re-key: paint the layer's mask where the matte is wrong (add hair it missed, take out a spot it kept), and Re-key sends the mask as a Clean hint with the picture the key was made from (the hidden source layer, or the picture under the key), and replaces the layer's pixels and mask in one undo step. After a restart Scumble no longer knows what the key was made from: Re-key then starts from the layer's bounds and reads the hidden layer directly under it, else the picture under it.

On an RTX 5090 (2026-11-06) the key itself took about 2.3 seconds at 1 megapixel and about 7 seconds at 16 megapixels on the ComfyUI; the first key after any other job there takes about 10 seconds more, since the pack loads its 4.7 GB of models again, and that job's models load again at its next run (a FLUX 3 Image Klein Generate took about 3 seconds more). Keep the model on the GPU between keys saves the load for keys in a row, at the price of about 4.6 GB that stay on the card until ComfyUI's Free model and node cache releases them. The key goes to the front of your ComfyUI's queue but never interrupts a job that is already running there. The title row shows its timer with Cancel beside it; Cancel takes only Scumble's own job off the server. Wait (300 seconds to start with) is how long your ComfyUI has to answer once the key runs, its queue not counted. Closing the tab ends the key, and nothing is added.

CorridorKey 2.0 is by Corridor Digital, under the Corridor Key Licence 2.0 (CC BY-NC-SA 4.0 with their terms), and Scumble uses it with their permission as a free app. It builds on C-RADIOv4 (NVIDIA Open Model License), MoGe-2 (MIT) and RVM (Google DeepMind, CC BY 4.0), about 5.1 GB in all, which the node pack downloads from their publishers onto your ComfyUI. Your keyed pictures are yours, also commercially. Organisations with more than US $20M yearly revenue need one CorridorKey seat per user (corridorkey.com). There is no Comfy Cloud or paid-host version: the licence does not allow paid inference, and Comfy Cloud runs no custom nodes.

What your ComfyUI's machine needs: an NVIDIA card of the RTX 30 generation (Ampere) or newer, data-centre cards such as an A40, A100, L40S or H100 included (CorridorKey 2.0 runs on CUDA in bf16); ComfyUI 0.25 or newer (the pack's README; Scumble ran it on 0.44); the Inpaint Canvas node pack, as every local recipe does; the node pack ComfyUI-CorridorKey2.0 (github.com/marawan206/ComfyUI-CorridorKey2.0); and about 5.1 GB of disk space for its models in ComfyUI/models/corridorkey2. The pack ComfyUI-CorridorKey2 (another community pack for the same model) is refused: it downloads its models by itself inside the first key's job, which would hold your ComfyUI's queue for minutes, and it has not keyed with Scumble.

The steps below follow the pack's README as it was at its commit c7662de (2026-11-02), the one Scumble was tested with on 2026-11-06; where the README says something different by the time you read this, the README is right. The commands are for the Windows portable ComfyUI and run in its folder, the one that holds python_embeded and ComfyUI; with another install, use the Python your ComfyUI runs with. ComfyUI-Manager's search does not list the pack; its Install via Git URL does take it.

An exported picture is the end of the road. PSD and ORA keep the layers for other programs, but a filter layer survives there only in the merged picture, and the prompts and the results stay behind. A .scumble file is Scumble's own document: Ctrl+S writes the tab into one, and opening it next week, or on another machine, brings the document back with every part of it still editable.

What goes in is everything the document is. Every layer with its pixels, its mask, blend mode, opacity, role, lock and alpha lock. Filter layers with their settings, LUTs and grain plates included. Text layers as text: a font you added yourself travels in the file, a system font is only named and falls back to another one on a machine that lacks it. 3D objects with their model file, so Edit 3D object still works after reopening, on another machine too. The selection and the saved selections, the guides and the crop, the prompt, the negative prompt and the generation settings. And the result history: the results and the prompts of earlier runs.

What stays out is what belongs to you or to this machine rather than to the picture: API keys, the ComfyUI connection, the app's settings, the undo history, and the view — zoom and pan. The recipe choice stays yours as well; the file only notes which recipe it was saved with.

The first Ctrl+S asks where; after that it writes to the same file, and Ctrl+Shift+S (Save As) writes a new one, which the tab follows from then on. The tab carries the file's name and shows its path in the tooltip. A * after the name, in the window title too, means the tab has changes that are not in its file, or has no file yet. The picture export that used to be on Ctrl+S is on Ctrl+Shift+E now (the next chapter).

The result history is work you paid for, in money or in GPU time, so it goes into the file. A Save As of a document that holds results asks once — Save with History, Save without History, or Cancel — and leaving it out is for sharing a picture without how it was made. The tab's file remembers the answer, so the next Ctrl+S does the same.

Closing a tab with changes, or with a picture that was never saved, asks: Save, Don't Save or Cancel. A tab whose file holds everything closes without a question. Either way Ctrl+Shift+T brings back the last ten tabs closed in this session, also after Don't Save. Quitting Scumble asks nothing: the session keeps every open document, the unsaved ones still marked with *, and they come back at the next start.

A save cannot leave half a file behind. It is written beside the target under a temporary name and only then renamed over it, so a crash, a full disk or a killed process leaves the old file as it was. A long save or open shows a chip on the tab, "Saving 43 %", with a cross that cancels it; a cancelled or failed save leaves the old file alone too. Closing the app or installing an update waits for a save in progress.

Ctrl+Shift+E, File › Export Image, writes the visible picture in the format the Export panel is set to: PNG, JPEG, WebP or TIFF for a flat result, PSD or OpenRaster when you want the layers, masks and selections to survive into Photoshop, Krita or GIMP. Ctrl+S used to do this; it saves the .scumble document now (the chapter before). You can export at a percentage, at a pixel size, or into a frame of a given size with a background of your choosing, and a single layer or the mask on its own.

A PNG export can carry the prompt, the negative prompt, the seed and the recipe as text inside the file: Prompt and recipe in the PNG in the Export panel is on unless you untick it, and it stays as you set it for every document. Anyone who gets the file can read what it carries, and a recipe you imported from your own ComfyUI workflow carries every setting of that workflow, except the ones named like a key, a token, a secret or a password (an API key typed into a node, for one), which are left out. JPEG, WebP, PSD and ORA never carry them. Every PNG export is marked as sRGB, which it is; JPEG and WebP exports carry an sRGB profile.

The AI label panel stamps the EU's icon for AI-generated or AI-modified content onto the picture as a layer of its own, for the day you need to show that a model was involved: move and scale it like any layer, and every export shows it while it is visible.

Every document is a tab, and tabs come back, saved as a .scumble file or not. The session is autosaved and restored at the next start, with no server needed for it, because every image the editor sends or receives is kept locally under %APPDATA%/Scumble/files/ (in a portable copy: data/files/ beside Scumble.exe) in folders that mirror ComfyUI's own input and output. That is also why a restarted or freshly rented ComfyUI just works: before a run the app uploads what the server does not have.

Closing Scumble asks nothing about unsaved documents. It waits until your last changes are in the session, and for a document save that is still running; on a very large picture that can take a few seconds, and closing again meanwhile asks whether to wait. If the window crashes, it comes back with your documents. Settings › Local files › Earlier states opens the documents of the last two sessions as new tabs, for the day a start did not bring back what you expected.

Ctrl+Shift+A opens a chat column next to the canvas. Tell it what you want — "remove the bollard on the left and match it to its surroundings" — and it does it by calling the same commands an external agent would: select, prompt, generate, match, layer by layer. Every call is a card you can open to see exactly what it did.

It runs on your own API key. Anthropic, OpenAI and Google directly, or anything OpenAI-compatible: OpenRouter, DeepSeek, Moonshot, Z.ai, ToAPIs, WaveSpeed, Oxen.ai, or a local server that needs no key at all. The picker groups models by provider and greys out the ones you have no key for. Your own model ids can be added in Settings › Language models, so a model released after this version of Scumble still works.

It asks before it does anything expensive or irreversible: generating, upscaling, selecting by text, anything that queues on your ComfyUI or costs a provider call, anything that clears the undo stack, anything that touches a layer that is not its own. The question card shows the reason, the file, the recipe and the old and new values, and neither button is the default one.

And it can be taken back. Ctrl+Z undoes its steps one at a time like your own, and Undo this turn puts every document the turn touched back to where it was before — even when the turn was longer than the undo stack. Chats are saved with their screenshots and can be reopened; Settings › Assistant deletes everything it ever stored, your keys excepted.

F1, the Help button in the top bar or Help › Scumble help opens this manual in a column beside the canvas. It is the same text as on the website, shipped with the app, so it works offline and describes the version you are running. Type into the search field and the chapters narrow down to the ones that mention every word you typed, with the words marked; Enter jumps to the first of them.

Above the manual sits a chat. Ask it how to do something, "how do I take a piece out of a selection?", and it answers from this manual and from nothing else, and ends with the chapter it took the answer from; a click on that line opens the chapter. When the manual does not cover a question, it is told to say so and point you to the docs on GitHub instead of inventing a menu item.

The chat runs on any model you have a key for, including small text-only ones: it needs no eyes and no tools. It cannot change anything in the app, which is the assistant's job (Ctrl+Shift+A). Without any key the panel is simply the manual.

Underneath the interface, everything the editor can do is a named command with documented parameters. The assistant uses them. So can you: Help › Copy MCP registration puts the line for your MCP client on the clipboard (Claude Desktop also takes the .mcpb file of every release: open it, and the server is installed with one click; it finds the installed Scumble by itself, a portable copy is named in the extension's settings), and after that Claude Code, Claude Desktop or any other MCP client drives Scumble directly — open a picture, select the handbag, generate, export. For scripts there are --headless and --cmd, which run the app without a window.

Plugins are JavaScript. A plugin folder with a plugin.json can add filters (with a GPU and a processor path), panels, menu actions, tools and commands of its own. The film pack, the 3D object tool and the AI label panel are plugins themselves, which is the honest test of whether an extension point is good enough.

The same editor also lives on as the ComfyUI node Inpaint Canvas, built from this repository. If you work inside ComfyUI, you get the same canvas there.

Scumble keeps the picture, every layer and every mask in tiles rather than in one big canvas, and the pixel work — flood fill, grow and shrink, blur, blending, the match — runs as compiled Rust in worker threads. That is the reason a 15,000 by 10,000 document paints, selects, filters and exports without the window locking up, and why export and selection work happens off the main thread.

The tile engine is on by default. Settings › Rendering has the switch back to the old canvas path, which exists as an escape hatch if something ever looks wrong on your hardware; the app is slower and hungrier that way, but it is there.

Above the browser's canvas limit — beyond about 268 megapixels — pictures are opened and written in strips instead, which is how PNGs up to 65,535 pixels a side and about a gigapixel work at all.

Every inpainting model has a size it works at, and it is small: around one megapixel, four at the very top end. Your picture is not. A 6000 by 4000 photo is 24 megapixels, and the thing you selected in it might be 300 pixels across. That gap is the whole problem of inpainting at photo resolution, and everything in this chapter exists to close it.

The naive answer — scale the picture down, let the model paint, scale it back up — ruins everything outside the selection and gives you a soft patch inside it. Scumble does the other thing: it cuts a box around your selection, sends only that, and puts the answer back at the document's own resolution. Nothing outside the box is ever touched, because nothing outside the box ever leaves your machine.

The box is not the selection. Around it goes context — the surroundings the model needs to match light, texture and perspective — and Scumble works out how much from the selection's own size: roughly a tenth of its diagonal as the feather, a little more as padding, and never a box smaller than 512 pixels. A tiny selection therefore still goes out as a workable picture instead of a postage stamp. You can override all of it in the Crop panel, and Context is the one worth touching: too little and the model has nothing to match, too much and your selection becomes a detail the model stops caring about.

Then comes the part with the odd name. The box gets sent at the size the chosen model actually takes, and that is usually larger than the box's own pixels. Select a 300-pixel bag in a photo and the crop goes out at 1440 or 2048 or 3840, depending on the model: the model paints far more detail than that area of your picture holds, and the answer is scaled back down into the box. The detail survives the scaling down; it would not have survived being invented at 300 pixels. That is the Highres fix, and it is why an inpaint in a big photo does not come back looking like a blurred sticker.

The Highres fix select in the Generate tab decides how far to push it. Maximum, the default, uses everything the model allows. 2x crop and 4x crop send the box at twice or four times its own resolution, still under the model's ceiling — cheaper, faster, and enough when the selection is already large. Target size keeps the number in the node parameters, and Off sends the crop exactly as it is. The ceiling itself is not a guess: every provider variant carries the size rules of its endpoint, the longest side, the rounding step, the smallest side, a pixel budget and a floor, and a crop steeper than the model's allowed aspect gets more context on its short side rather than being refused.

Coming back, the answer is scaled to the box and blended in, not pasted. Scumble builds a composite mask from your selection — grown by a few pixels, then blurred by the feather — so the patch writes at full strength in the middle, fades out at the edge and does not touch a pixel you did not select. This matters most for the models that take no mask at all: GPT Image, Nano Banana, FLUX.2, FLUX 3 Image, Seedream and the rest get the crop and an instruction, they hand back a whole repainted box, and it is this mask that keeps the repaint inside your selection. Then colour match runs if it is on, matching the patch's per-channel mean and spread to the ring of picture around it, and the result lands as a layer at the box's position at full resolution.

On your own ComfyUI none of the size machinery applies: there the Inpaint Canvas node does the cropping and stitching on the server, the recipe's Target size rules, and the app sends the canvas and the mask rather than a finished crop.

Scumble is built to be used with one hand on the keyboard. A tool is one letter, the brush size is two brackets, and the things you do a hundred times a day — undo, deselect, fit the view, generate — are one chord each. Nothing here has to be learned first; the status line under the canvas says what the current tool does.

Two of them are worth knowing before the rest. Hold the backslash key to peek at the picture underneath everything you have added, which is how you judge a result in a second. And press F to fit the picture back into the window when you have zoomed yourself into a corner.

Ctrl+, opens the settings: the ComfyUI server and its authentication, API providers, language models, recipes, helper models, the assistant, the appearance, plugins, local files, rendering and updates. Most of it you set once.

Settings › Helpers (in-app models) manages the local neural models: SAM2 (object hover and box drag), RMBG / BiRefNet (background removal cut-outs), LaMa (in-app object remove and content-aware move), and Depth Anything V2 Small (depth maps for depth selection and depth-limited filter layers). Each model can be downloaded or removed individually, and runs on your GPU or processor. Every download is checked against its published checksum where there is one, and a stopped download resumes; the Hugging Face token you save there is sent to Hugging Face only.

Settings › Appearance switches the app's look: the default, 90s, Duck, Comfy, Black Forest or a skin you add (docs/SKINS.md); View › Skin does the same from the menu, and View › Skin › Default brings the default back if a skin makes the app hard to read. A skin recolours the app's questions too, but cannot hide them or change the order of their buttons.

Updates come from GitHub releases. A few seconds after the start the app looks for a new version and downloads it in the background (Settings › Updates switches the check off). Once it is downloaded, a question names the version and what changed since yours, one line per change. Restart and update saves your documents, installs it and starts the new version with them. Later installs it when you close Scumble. Skip this version leaves it out until a newer one comes; closing Scumble then installs nothing. The question comes once per start and waits while you draw, type or answer another question; a key you were still typing answers Later. When a restart would end a run, the assistant's turn or an agent's session, it asks first. The Update button in the title row and Settings › Updates, which has the whole release notes of every version since yours, install a downloaded version at any time, a skipped one too. Nothing is installed while you are working. The copy from the Microsoft Store is updated by the Store. A portable copy never installs anything: it says once that a version is out, and Download opens its release page.

When something misbehaves: Ctrl+Shift+L opens the log, which is also written to a file. The status line under the canvas carries the last thing that happened, including the reason a run was refused — a missing key, a server that did not answer, a size a provider would not take. An error, a model that still has to be downloaded, a size or limit a run would pass, or a result that came out only in part shows red and blinks five times, then stays red until the next line (it does not blink when the system's animation effects are off); a hint such as "Select a layer first" stays grey. A click on the line opens the log. And the changelog says what changed in the version you are on, which is often the answer by itself.

Scumble is at 0.1.x and it says so. Not every path has been tested end to end; the API providers in particular are written from their documentation and only some have run against the live service. Keep backups of pictures you care about, and report what breaks in the issues — a bug with a picture and a version number attached is a bug that gets fixed.