Skip to content
Back to search

scumble

Free, open-source desktop editor for AI inpainting: select, prompt, get a colour-matched layer. FLUX 3 Image, FLUX.2, GPT Image, Nano Banana, Seedream and Qwen through your API key or your own ComfyUI. Layers, PSD export, MCP.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/DenRakEiw/scumble with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/DenRakEiw/scumble'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/denrakeiw--scumble/badge.svg)](/listings/denrakeiw--scumble)

HTML

<a href="/listings/denrakeiw--scumble"><img src="/api/listings/denrakeiw--scumble/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Windows (10 and 11, 64-bit)

- **Microsoft Store:** [Scumble in the Microsoft Store](https://apps.microsoft.com/detail/9NDBTNNMXF2R), or in a terminal:

  winget install scumble

(winget installs the same Store copy and may ask you to accept the Store's terms first.) Microsoft signs the Store copy, so it installs without a SmartScreen warning, and the Store keeps it up to date. A new version arrives there after Microsoft has certified it, so sometimes a little after the GitHub release. The Store copy keeps its own settings, keys and files (`%APPDATA%\Scumble Store`), so it can sit beside the GitHub one. - **Installer from GitHub:** `Scumble-Setup-<version>.exe` from the [latest release](https://github.com/DenRakEiw/scumble/releases/latest). It is not code-signed yet, so SmartScreen shows "Windows protected your PC" once: click *More info*, then *Run anyway*. After that the app downloads its own updates and asks before it restarts into a new version. - **Portable zip:** `Scumble-<version>-portable-win-x64.zip` from the same release. Unpack it into a folder you can write to, such as `C:\Tools` (not Program Files, not a folder OneDrive syncs), and start the `Scumble.exe` in its `Scumble` folder (SmartScreen asks once, as for the installer). Everything it stores stays in a `data` folder beside it, so it runs beside an installed Scumble. It does not update itself: it tells you when a new version is out, and you unpack the new zip over the old one (the `data` folder stays). API keys are encrypted for the Windows account, so on another PC they have to be typed again (and after that possibly on the first PC too).

Linux

The same release carries `scumble-<version>.AppImage` and `scumble-<version>.deb` (x64). **They are built by CI and have not been run by the author yet; reports are welcome** in the [issues](https://github.com/DenRakEiw/scumble/issues). Details are under [Linux notes](#linux-notes) below.

macOS

Planned, not started yet.

What you need to render

- **Only an API key:** *Settings › API providers* (Ctrl+,), paste the key, Save. No ComfyUI and no server; you pay the provider directly. The same keys serve the assistant and prompt upsampling. - **Your own ComfyUI:** the node pack [ComfyUI-InpaintCanvas](https://github.com/DenRakEiw/ComfyUI-InpaintCanvas) installed there, and the models of the recipe you pick. Install the pack with git into ComfyUI's `custom_nodes` folder, then restart ComfyUI (the pack needs no extra Python packages):

  cd ComfyUI/custom_nodes
  git clone https://github.com/DenRakEiw/ComfyUI-InpaintCanvas

The ComfyUI Manager does not list the pack at the moment; once it does, you can install it from there too. Then type the server's address in Scumble's top bar and press Connect. Scumble checks for the pack when it connects and says so when it is missing; it does not install it for you. Boxes for FLUX 3 Image Klein need the node's current version from GitHub (the Comfy Registry's 0.3.4 has none yet): update a clone with `git pull` in its folder, replace a copy installed from the Registry with the clone above, then restart ComfyUI. - **Comfy Cloud:** your Comfy key in *Settings › API providers*; the same key runs Comfy Router.

Without any of these Scumble still opens, paints, selects, layers, filters, saves and exports, and its in-app models (object selection, background removal, Remove, the depth map) run on your own machine once downloaded.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/plugin.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "scumble",
  3. "displayName": "Scumble",
  4. "version": "0.1.45",
  5. "description": "Desktop editor for AI inpainting with layers. Run selections, generative inpainting, GPU filter layers, and PSD/ORA exports directly from Claude.",
  6. "author": {
  7. "name": "Dennis Schoeneberg (DenRakEiw)",
  8. "email": "schoenebergde@gmail.com",
  9. "url": "https://www.denrakeiw.com"
  10. },
  11. "homepage": "https://www.denrakeiw.com/scumble",
  12. "repository": "https://github.com/DenRakEiw/scumble",
  13. "license": "GPL-3.0",
  14. "category": "design"
  15. }
README.md · README · 462 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <h1 align="center">Scumble</h1>
  2. <p align="center">
  3. <b>An AI-native image editor for ComfyUI and the models you already use.</b><br>
  4. Inpaint, edit, upscale and generate, and every edit comes back as a layer of its own.
  5. </p>
  6. <h3 align="center">
  7. ⭐ <a href="https://github.com/DenRakEiw/scumble">Star on GitHub</a>
  8. &nbsp;·&nbsp;
  9. <a href="https://github.com/DenRakEiw/scumble/releases/latest">Download</a>
  10. &nbsp;·&nbsp;
  11. <a href="https://apps.microsoft.com/detail/9NDBTNNMXF2R">Microsoft Store</a>
  12. </h3>
  13. <p align="center">
  14. <a href="https://github.com/DenRakEiw/scumble"><img alt="Star Scumble on GitHub" src="https://img.shields.io/github/stars/DenRakEiw/scumble?style=social"></a>
  15. <a href="https://github.com/DenRakEiw/scumble/releases/latest"><img alt="Download the latest release" src="https://img.shields.io/github/v/release/DenRakEiw/scumble?label=download"></a>
  16. <a href="https://apps.microsoft.com/detail/9NDBTNNMXF2R"><img alt="Get it from the Microsoft Store" src="https://img.shields.io/badge/Microsoft%20Store-get%20it-0078d4"></a>
  17. <a href="LICENSE"><img alt="Licence: GPL-3.0" src="https://img.shields.io/badge/licence-GPL--3.0-blue"></a>
  18. </p>
  19. <p align="center">
  20. <img src="docs/images/readme/workflow.gif" width="100%" alt="One key visual built in Scumble, its layers landing one by one: the generated and upscaled base, the wheels inpainted from a reference photo, a detail pass tile by tile, the face and the shoes swapped from references, the Realism Pass (sped up, the waits cut out)">
  21. </p>
  22. <p align="center"><sub>One picture from the first generation to the finished frame, 17 layers, without leaving the editor (sped up, the waits cut out; the app wears its Lighthouse Academy skin).</sub></p>
  23. ## Get Scumble
  24. | Platform | Get it | Notes |
  25. |---|---|---|
  26. | **Windows** | [Microsoft Store](https://apps.microsoft.com/detail/9NDBTNNMXF2R), or `winget install scumble` | Signed by Microsoft, no SmartScreen warning, updated by the Store |
  27. | **Windows** | [Installer](https://github.com/DenRakEiw/scumble/releases/latest): `Scumble-Setup-<version>.exe` | Updates itself; not code-signed yet, so SmartScreen asks once |
  28. | **Windows, portable** | [Zip](https://github.com/DenRakEiw/scumble/releases/latest): `Scumble-<version>-portable-win-x64.zip` | No install; keeps its data in a folder beside it |
  29. | **Linux** (x64) | [AppImage or .deb](https://github.com/DenRakEiw/scumble/releases/latest) | Early builds made by CI, not run by the author yet; reports welcome |
  30. | **macOS** | coming soon | In the works |
  31. Scumble is free and needs no account of its own. The details, and what it needs to render, are under
  32. [Installation](#installation).
  33. ## What can it do?
  34. Scumble is a desktop image editor built around AI models. Select part of a picture, or draw boxes on an empty
  35. canvas, say what should be there, and the answer comes back as a layer of its own, colour-matched to what surrounds
  36. it, that you can mask, blend, filter and export like any other. It renders on your own ComfyUI (on your machine or a
  37. remote one), on Comfy Cloud, or through the API keys you may already have for FLUX, GPT Image, Nano Banana, Seedream
  38. and more: a key alone is enough, no ComfyUI needed. It is free software (GPL-3.0), runs on Windows today, and is
  39. young (0.1.x), so expect rough edges and keep backups of your pictures.
  40. ## Five things it does well
  41. ### Every result is its own layer
  42. A result lands over your selection as a new layer, faded in at the edge and colour-matched to the picture around it.
  43. The Match slider in the layer's row changes that match at any time, and nothing else is baked in either: mask the
  44. layer, erase parts, change its blend mode, put filters and text on top. The picture only becomes one when you flatten.
  45. The status line and the result's row in the history say where it ran ("FLUX 3 Image via Comfy Router, 23 s", or "via
  46. your ComfyUI"). An answer that comes back slightly shifted or scaled is lined up with the picture's edges, and *Match
  47. edges to the layer below* in a layer's menu does the same afterwards. Each result is one undo step of its own:
  48. Ctrl+Z takes exactly that result back, also when it lands after you went on working.
  49. ![Colour match: the same result layer at Match 0 % with a visible cold rectangle, and at 100 % blended into the ground; below, the layer row with the Match slider](docs/images/colour-match.jpg)
  50. ### Say where things go: boxes and `@img1`
  51. Draw boxes on the picture and describe each one: something new, something kept, moved or removed, a reference picture
  52. placed, words rendered. FLUX 3 Image from Black Forest Labs (on every provider Scumble runs it on, and its open Klein
  53. model on your own ComfyUI) gets the boxes with the prompt and is told where each thing goes; Ideogram 4 on fal takes
  54. the new, kept and text boxes, and MOSS-Image on your own ComfyUI lays out a new picture from the new and text boxes. Reference layers are named in the prompt as `@img1`, `@img2`, and each one goes out
  55. under the name the chosen model knows that picture by.
  56. ### Your ComfyUI, Comfy Cloud, or just your keys
  57. Recipes instead of node graphs: you pick a model and where it runs. On your own ComfyUI, local or on a rented box
  58. such as RunPod, any workflow with the Inpaint Canvas node becomes a recipe, and the *ComfyUI* button opens your
  59. ComfyUI's own page beside the editor to change a recipe's graph and save it back; up to five LoRAs from your ComfyUI's
  60. own list (or Comfy Cloud's) go into a recipe's runs without touching its graph. Comfy Cloud runs on your Comfy key
  61. through Comfy's official SDK, with 15 recipes from Comfy's own templates, and the same key reaches the partner models
  62. on Comfy Router. Or paste a key into *Settings › API providers*: Black Forest Labs, OpenAI, Google, fal.ai, Replicate,
  63. OpenRouter and more. Keys go into the system's credential store, never into a settings file.
  64. ### Agents can drive it
  65. Every feature is a command, and the commands are an MCP server: *Help › Copy MCP registration* (or, for Claude
  66. Desktop, the `.mcpb` file of every release, installed with one click), and Claude Code, Claude Desktop or any other
  67. MCP client gets 124 tools to open, select, generate, match and export, in the same window and with the same undo. (A built-in chat assistant on your own key is there too; see [The assistant](#the-assistant).)
  68. ### Made for real files
  69. PSD export with layers and masks, OpenRaster with layers, and both open again with their layers. A tile engine with
  70. compiled Rust kernels keeps a 15,000 × 10,000 pixel document painting, selecting and exporting without freezing the window, and
  71. PNGs up to 65,535 pixels a side open and save in strips. Filters are layers too, on the GPU: 46 film looks, grain,
  72. curves, LUTs and more.
  73. ![The layer stack: a vignette and a film look as filter layers, a text layer and the base](docs/images/layers.jpg)
  74. The photo in the editor screenshots (the woman on the blue car) is a sample picture used to show the features;
  75. nothing in it was generated with Scumble. The key visual in the clip at the top is the author's own work, made in
  76. Scumble from the first generation to the Realism Pass; the café picture below was made in Scumble with FLUX 3 Image.
  77. ## Before / After
  78. <p align="center">
  79. <img src="docs/images/readme/before-after-cafe.jpg" width="100%" alt="Left: three boxes with their descriptions on an empty canvas. Right: the café picture FLUX 3 Image made from them.">
  80. </p>
  81. Three boxes drawn and described on an empty canvas (left), and the picture FLUX 3 Image made from them with
  82. *Generate new* (right).
  83. ## Installation
  84. ### Windows (10 and 11, 64-bit)
  85. - **Microsoft Store:** [Scumble in the Microsoft Store](https://apps.microsoft.com/detail/9NDBTNNMXF2R), or in a
  86. terminal:
  87. ```
  88. winget install scumble
  89. ```
  90. (winget installs the same Store copy and may ask you to accept the Store's terms first.) Microsoft signs the Store
  91. copy, so it installs without a SmartScreen warning, and the Store keeps it up to date. A new version arrives there
  92. after Microsoft has certified it, so sometimes a little after the GitHub release. The Store copy keeps its own
  93. settings, keys and files (`%APPDATA%\Scumble Store`), so it can sit beside the GitHub one.
  94. - **Installer from GitHub:** `Scumble-Setup-<version>.exe` from the
  95. [latest release](https://github.com/DenRakEiw/scumble/releases/latest). It is not code-signed yet, so SmartScreen
  96. shows "Windows protected your PC" once: click *More info*, then *Run anyway*. After that the app downloads its own
  97. updates and asks before it restarts into a new version.
  98. - **Portable zip:** `Scumble-<version>-portable-win-x64.zip` from the same release. Unpack it into a folder you can
  99. write to, such as `C:\Tools` (not Program Files, not a folder OneDrive syncs), and start the `Scumble.exe` in its
  100. `Scumble` folder (SmartScreen asks once, as for the installer). Everything it stores stays in a `data` folder beside it, so it runs beside an installed Scumble.
  101. It does not update itself: it tells you when a new version is out, and you unpack the new zip over the old one (the
  102. `data` folder stays). API keys are encrypted for the Windows account, so on another PC they have to be typed again
  103. (and after that possibly on the first PC too).
  104. ### Linux
  105. The same release carries `scumble-<version>.AppImage` and `scumble-<version>.deb` (x64). **They are built by CI and
  106. have not been run by the author yet; reports are welcome** in the
  107. [issues](https://github.com/DenRakEiw/scumble/issues). Details are under [Linux notes](#linux-notes) below.
  108. ### macOS
  109. Coming soon.
  110. ### What you need to render
  111. - **Only an API key:** *Settings › API providers* (Ctrl+,), paste the key, Save. No ComfyUI and no server; you pay
  112. the provider directly. The same keys serve the assistant and prompt upsampling.
  113. - **Your own ComfyUI:** the node pack [ComfyUI-InpaintCanvas](https://github.com/DenRakEiw/ComfyUI-InpaintCanvas)
  114. installed there, and the models of the recipe you pick. Install the pack with git into ComfyUI's `custom_nodes`
  115. folder, then restart ComfyUI (the pack needs no extra Python packages):
  116. ```
  117. cd ComfyUI/custom_nodes
  118. git clone https://github.com/DenRakEiw/ComfyUI-InpaintCanvas
  119. ```
  120. The ComfyUI Manager does not list the pack at the moment; once it does, you can install it from there too. Then
  121. type the server's address in Scumble's top bar and press Connect. Scumble checks for the pack when it connects and
  122. says so when it is missing; it does not install it for you. Boxes for FLUX 3 Image Klein and MOSS-Image need the node at
  123. 0.4.1 or newer (on the Comfy Registry since 2026-10-23; 0.3.4 and older have none): update a copy installed from the
  124. Registry there, a clone with `git pull` in its folder, then restart ComfyUI.
  125. - **Comfy Cloud:** your Comfy key in *Settings › API providers*; the same key runs Comfy Router.
  126. Without any of these Scumble still opens, paints, selects, layers, filters, saves and exports, and its in-app models
  127. (object selection, background removal, Remove, the depth map, the surface maps for Deep paint, layer names and
  128. descriptions) run on your own machine once downloaded.
  129. ## Demo: videos and the manual
  130. [![Scumble, explained by someone who did not ask: the video, 4:40](https://www.denrakeiw.com/scumble/videos/scumble-explained.jpg)](https://www.denrakeiw.com/scumble/videos)
  131. - **[Videos](https://www.denrakeiw.com/scumble/videos):** four parts, two voices, one of them a sceptic, each recorded
  132. in the app: "Scumble, explained by someone who did not ask" (4:40) and "Scumble, part two: he has more questions"
  133. (4:03) at version 0.1.28, "Scumble, part three: the client has notes" (5:34, 0.1.42: boxes for FLUX 3 Image, a
  134. reference photo in the prompt) and "Scumble, part four: the show is on Friday" (5:18, 0.1.46: a depth map, lens blur
  135. and haze, 27 blend modes).
  136. - **[Manual](https://www.denrakeiw.com/scumble/manual):** from the first picture to the export. The same text ships
  137. with the app: F1 opens it beside the picture, searchable and offline, and with any API key a chat answers questions
  138. from it. Its source is [docs/MANUAL.md](docs/MANUAL.md).
  139. ## ⭐ If you like it
  140. If Scumble is useful to you, a [star on GitHub](https://github.com/DenRakEiw/scumble) helps other people find it.
  141. Something broken? Open an [issue](https://github.com/DenRakEiw/scumble/issues) with what you did and what happened;
  142. Ctrl+Shift+L opens the console, which shows the path of the log file. What is being built, what was measured and what
  143. did not work is on the [dev blog](https://www.denrakeiw.com/scumble/blog), and [CHANGELOG.md](CHANGELOG.md) lists
  144. every version.
  145. ---
  146. ## What has been tried live
  147. Scumble is at 0.1.x and not every feature has been tested end to end. Run against the real thing so far: local
  148. rendering through ComfyUI (FLUX 3 Image Klein with boxes among it), the in-app helper models, the film pack, the
  149. command core, the MCP server, the tile engine on large documents and auto-update; among the API providers FLUX 3 Image
  150. on Black Forest Labs (with boxes), OpenRouter and Comfy Router (on Comfy Router also through Comfy's SDK since 0.1.49),
  151. GPT Image 2.5 through OpenRouter, GPT Image 2 and Nano Banana 2 on Comfy Router, Seedream 5.5 on Comfy Router and
  152. OpenRouter, HY Image 3.5 through Comfy's Partner
  153. API, Ideogram 4 on fal (with boxes), Qwen Image 2.1 Edit on Comfy Cloud, Z-Image Turbo, Flux.2 Klein 9B and a Nano
  154. Banana 2 edit on Comfy Cloud through Comfy's SDK and its API v2 (a Cancel there stopped the job on Comfy's side), and
  155. the upscalers Topaz Precision on fal and Magnific Precision and Creative on Magnific; on a local ComfyUI the Realism
  156. Pass (Windows only, RTX only), RTX Video Super Resolution (on Comfy Cloud too), MOSS-Image, MOSS-Image Edit (its
  157. edit on Comfy Cloud too), P-H3-Image, LoRA rows (on Comfy Cloud with Qwen Image Edit 2509 too) and the green screen
  158. key with CorridorKey 2.0. The other API routes were
  159. built from the providers' documentation and have not run against the live services yet, nor have relight's model
  160. routes, the assistant's model calls, the portable zip on a second PC, or the Linux builds.
  161. ## Features in detail
  162. ### Select, prompt, generate
  163. ![A rectangle selected around the handbag, the Generate tab with the prompt, the recipe settings and the seed](docs/images/selection.jpg)
  164. - Selection by brush, rectangle, ellipse, lasso, magic wand, object hover or box (SAM2, in the app), by depth,
  165. brightness or colour range, or by text (SAM3 on your ComfyUI); grow, shrink, feather, invert, from layer, saved
  166. selections.
  167. - A frame from a video: *File › Open* and a drop on the window take .mp4, .m4v, .webm and .mov files and show a small
  168. player with a slider and one-frame steps; the frame you stop on becomes a new picture, a layer or a reference layer.
  169. - A depth map of the picture, computed in the app (Depth Anything V2 Small, *Selection › Depth*) and saved with the
  170. document: it selects, limits filter layers, and drives lens blur, haze and Relight.
  171. - Models: FLUX 3 Image, FLUX.2 (max, pro, flex, klein) and FLUX.1 Fill from Black Forest Labs; GPT Image 2.6 and 2.5
  172. Flare / Sunburst and GPT Image 2; Nano Banana 2.1, 2, 2 Lite and Pro; Seedream 5.5 (on WaveSpeedAI, Comfy Cloud,
  173. ToAPIs, Comfy Router, Oxen.ai and OpenRouter, and on BytePlus ModelArk in early access; run live on Comfy Router and
  174. OpenRouter, the other hosts not yet), 5 and 4.5; Qwen Image Edit and Qwen Image 2.1;
  175. Ideogram 4 and 4.5; Grok Imagine, Krea 3 Edit and Krea 2, Recraft V4, Reve, Z-Image, HY Image 3.5, P-H3-Image and MiniMax-H3-Image (on MiniMax's own API, not run live yet); Magnific's Mystic, Ideogram
  176. inpainting and Image Expand outpainting. Each runs on the model's own API where Scumble
  177. has one, or through ToAPIs, fal.ai, Replicate, WaveSpeedAI, Comfy Cloud, Comfy Router, OpenRouter, Oxen.ai and
  178. Magnific. API runs go out at the size the provider really takes, with your reference layers.
  179. - On your own ComfyUI: FLUX 3 Image Klein, Black Forest Labs' open model (ComfyUI 0.41 or newer; it edits the selection
  180. with up to three more pictures, makes new ones with *Generate new* and takes boxes; Black Forest Labs' prompt
  181. upsampler writes your prompt out first when its file is on your ComfyUI; its weights come under Black Forest Labs'
  182. own licence), Flux.2 Klein 4B / 9B, Qwen Image Edit 2.1 and its Turbo, MOSS-Image (ComfyUI 0.42 or
  183. newer; new pictures with *Generate new*, its JSON layout from your boxes; Apache-2.0), MOSS-Image Edit (ComfyUI 0.43
  184. or newer, also on Comfy Cloud; it edits by instruction with up to three more pictures, through the edit LoRA of
  185. Comfy's own template), MiniMax-H3-Image (ComfyUI 0.45 or newer, not run yet), and P-H3-Image (ComfyUI 0.44 or newer, also on Comfy Cloud and WaveSpeedAI; edits with up
  186. to seven more pictures and new pictures, Pruna AI's prompt upsampler in front; powered by MiniMax H3, whose licence
  187. does not cover the EU, the UK, South Korea or the US without a separate licence from MiniMax), Fibo 2.0 Edit Turbo
  188. (edits by instruction with up to three more pictures, Comfy's Prompt Enhancer in front; not run yet; Bria's weights
  189. are CC BY-NC 4.0, non-commercial, commercial use needs an agreement with Bria); the upscale, Realism
  190. Pass and relight recipes are below.
  191. - LoRAs for every recipe on your own ComfyUI with one model loader: up to five per recipe in the *LoRAs* section of
  192. the Generate tab, each picked from your ComfyUI's list with a strength and an on / off tick, kept per recipe and
  193. loaded into the copy of the graph a run queues. A line under each says which base model the file looks made for
  194. (amber when it does not fit the recipe's, since ComfyUI loads such a LoRA silently and changes nothing), its trigger
  195. words go into the prompt with a click, and a file your ComfyUI lacks stops the run before anything is uploaded.
  196. The Comfy Cloud recipes take LoRA rows too, from Comfy Cloud's catalog and the LoRAs you imported there.
  197. - Your own workflow becomes a recipe when it holds an Inpaint Canvas node. The *ComfyUI* window (Ctrl+Shift+K) shows
  198. your ComfyUI's page or Comfy Cloud; *Edit in ComfyUI* opens a recipe's graph there, and *Save to recipe* or *Save as
  199. new recipe* brings it back. Its *Parameters* list turns any input of the graph (denoise, steps, a LoRA or ControlNet
  200. strength, a sampler, a text) into a row of the recipe's Settings panel with a tick, so nobody edits recipe files by
  201. hand. The Settings you pick for a recipe stay with it: a new tab, or the recipe picked again later, starts with the
  202. values you last chose.
  203. - Comfy Cloud has a mode of its own beside *local* and *api*. Fifteen recipes from Comfy's templates come with
  204. Scumble (image edits, and new images for Generate new); *Cloud copy* turns one of your ComfyUI recipes into one that
  205. runs there, and a workflow made on Comfy Cloud imports as it is. Comfy Cloud and Comfy Router run through Comfy's
  206. official TypeScript SDK ([`@comfyorg/sdk`](https://www.npmjs.com/package/@comfyorg/sdk)). *Cancel* stops a Comfy
  207. Cloud or Comfy Router job on Comfy's side, the status row's bar follows a Cloud run node by node, and a Cloud job
  208. still running when Scumble closes or crashes is asked for at the next start, its picture opening as a document of
  209. its own.
  210. - *Each area* beside Generate, shown while the selection holds two or more separate areas (people selected by text,
  211. say): each area goes as its own crop and run with the same prompt, one after another, each result its own layer,
  212. instead of one crop of all of them scaled down to the model's size. Up to 8 areas; before an API run Scumble asks.
  213. - *Generate new* makes the base picture from the prompt alone, locally or through a provider, and you edit it from
  214. there. *New* in the top bar can make the empty canvas for a model, in one of its own aspects and size classes (1k,
  215. 2k, 4k), so boxes are drawn in the shape the picture will have; Generate new then opens on that choice. While the
  216. current tab holds work, both open a tab of their own and take the reference layers, prompt, settings and boxes
  217. along, so the document you were in stays as it is.
  218. - Boxes in the prompt for FLUX 3 Image, for FLUX 3 Image Klein and MOSS-Image on your own ComfyUI (with the Inpaint Canvas node's
  219. current version, see [What you need to render](#what-you-need-to-render)) and for Ideogram 4 (on fal): the Boxes
  220. tool (X) draws them, a double-click describes one right on the picture, one switch under the prompt turns them on
  221. and off, and they are saved with the document. With the switch on and no boxes drawn, the selection goes as one box.
  222. Ideogram 4 takes the new, kept and text boxes (it has no move, remove or reference boxes).
  223. - Prompt upsampling through a stored API key (Gemini 4 Hydrogen on a Google or OpenRouter key among the models) or a
  224. local OpenAI-compatible server, with your own prompt-writing rules as Markdown templates.
  225. ### Retouch, upscale, refine
  226. - Clone, heal, smudge, dodge and burn, liquify, and *Patch* for a whole area. *Remove* and *Content-aware move* fill
  227. with LaMa, a model that runs inside Scumble: no prompt, no key, no ComfyUI (download it once in *Settings › Helpers
  228. (in-app models)*).
  229. - Object masks (SAM2), background removal (BiRefNet, RMBG), the depth map (Depth Anything V2 Small), the surface maps
  230. (Marigold IID Lighting, MoGe-2) and Florence-2 run in the app through ONNX Runtime, in a process of their own so the
  231. window stays responsive. With Florence-2 downloaded, new results, pastes, cut-outs and reference images get a short
  232. name from what it sees ("Woman sitting on the hood of a blue car" instead of "Result 3"), and *Image › Describe
  233. Selection* writes a caption of the selection or the picture to copy or use as the prompt.
  234. - *Upscale* takes the selection (it comes back as a layer) or the whole picture (it becomes the new base, every layer
  235. and mask scaled along, in one undo step). Topaz, Clarity, SeedVR2, Recraft and Magnific through their providers; the
  236. upscale models of your own ComfyUI; RTX Video Super Resolution on your ComfyUI or on Comfy Cloud, 1 to 4 times (on
  237. your ComfyUI with an RTX card and the node pack Nvidia_RTX_Nodes_ComfyUI, whose current version needs `nvidia-vfx`
  238. 0.2 or newer; [docs/RECIPES.md](docs/RECIPES.md) has the install line).
  239. - *Realism Pass (Windows only, RTX only)*, a refiner for generated pictures: it sends the picture through your own
  240. ComfyUI and adds the answer as a new layer, so generated skin, hair and fabric look more natural; at 1.5× to 3× it makes
  241. the picture larger in the same step. It needs a ComfyUI on Windows with an RTX 30, 40 or 50 card and a community node
  242. pack with its runtime, which you install there; Scumble ships none of it, and there is no Comfy Cloud version. The
  243. [manual](docs/MANUAL.md)'s chapter of the same name has the steps.
  244. - *Image › Split into Layers...* takes one picture apart into a base and separate layers with Seedream's layer
  245. decomposition on BytePlus ModelArk, or for Seedream 5.5 on WaveSpeedAI, Oxen.ai or OpenRouter (up to 99 layers and
  246. a base on Seedream 5.5, up to 32 on OpenRouter): they land above your layers in one group, one undo step.
  247. - *Image › Key Green / Blue Screen...* keys a subject shot on a green or blue screen (or generated on a flat green)
  248. with CorridorKey 2.0 by Corridor Digital, on your own ComfyUI through the community node pack ComfyUI-CorridorKey2.0.
  249. It needs an NVIDIA card of the RTX 30 generation or newer on that machine; the pack and its models, about 5.1 GB,
  250. are installed there, never by Scumble, and there is no Comfy Cloud version. The answer is one new layer **Key**: the
  251. subject's own colour with the screen's spill taken out, and the soft matte (hair, motion blur) as its layer mask; the
  252. selection is the hint, and a key of the picture gets a mid-grey layer under it. CorridorKey 2.0 is under the Corridor
  253. Key Licence 2.0 (CC BY-NC-SA 4.0 with their terms), used with Corridor Digital's permission in this free app; your
  254. keyed pictures are yours, also commercially, and **organisations with more than US $20M yearly revenue need one
  255. CorridorKey seat per user** (corridorkey.com). The [manual](docs/MANUAL.md)'s chapter *Key green / blue screen* has
  256. the steps.
  257. ### Layers, filters, text
  258. - A full layer stack: paint, image, text and filter layers, groups, masks, 27 blend modes (from multiply and screen to
  259. hard mix, divide and luminosity, the same on screen, in exports and in PSD files), opacity, transform (a moved or
  260. scaled layer snaps to the canvas, the guides and the other layers), crop and extend, copy and paste of whole layers
  261. between tabs, SVG files as layers.
  262. - Outpainting in one step: tick *Generate the new border* in the Canvas tool, and applying an extend starts Generate
  263. with your selected recipe on the new border (a recipe on an API provider asks first, since it is a paid run).
  264. - *Add Contact Shadow* (Layer menu): a cut-out, a keyed subject or a pasted picture gets a soft shadow of its own
  265. shape under it, darkest where it meets the ground, as an ordinary multiply layer; a depth map fades it where the
  266. ground lies farther away.
  267. - Colour match per layer, non-destructive, matched to the picture around the layer or to what lies below it.
  268. - Filter layers on the GPU (WebGL2, with a processor fallback): grain with film presets, curves, levels, colour
  269. balance, colour grading, HSL in eight channels, vibrance, gradient map, threshold, posterize, LUT (.cube), vignette,
  270. sharpen, blur, lens blur by the depth map, haze and dehaze, and more; each can be limited to a depth, brightness or
  271. colour range. The film pack plugin adds 46 film looks, halation, glow, bleach bypass, cross processing, split toning,
  272. light leaks, frames and control points; the effects pack adds chromatic shift and glass displacement. A *Scope*
  273. section shows the live histogram of the visible picture, and Alt+J marks pure black blue and pure white red on the
  274. screen while you grade (never in exports).
  275. - *Relight* (*Layer › New Relight Layer*): a filter layer that lights the picture anew from its depth map, with up to
  276. four point, spot or sun lights placed with the Lights tool (L), each with a colour temperature or colour, an
  277. intensity and a softness; soft shadows, gloss, patterns for a spotlight and eight presets. *Render* sends it through
  278. a model instead (Magnific Relight, IC-Light v2 or Bria on fal, Qwen Image Edit 2509 with a relight LoRA on your
  279. ComfyUI or on Comfy Cloud) and lands the answer as a pixel layer. Agents use the `relight` command, a preset by name
  280. too.
  281. - *Deep paint*: paint on the picture's surfaces. *Image › Surface Maps* splits the picture once into its light, its
  282. reflections and its surface shapes, on your own computer; on a *Deep paint layer* what you paint lands under the
  283. picture's own light and keeps its highlights, and the eyedropper picks the surface's own colour. *New Light Brush
  284. Layer* paints light where the brush goes, Relight layers on such a picture light its own colour and keep its
  285. reflections, and *Wrap onto Surface* lays a logo, a pattern or a word round a curved surface such as a cup or a
  286. bottle, in perspective and under the picture's light.
  287. - A shape tool, custom brushes from `.abr` files, and 3D objects (`.glb`) placed into the picture with their own
  288. light; a built-in posable mannequin (seven base poses, turnable joints) with its depth and an OpenPose bones layer
  289. as control layers.
  290. - `.scumble` documents keep everything editable (layers, filters, text, 3D objects, prompts and results). Export
  291. PNG, JPEG, WebP, TIFF, PSD and ORA, at a percentage or into a frame of a given size; the *AI label* panel adds the
  292. EU's label for AI-generated content.
  293. ### The assistant
  294. A chat column next to the canvas (Ctrl+Shift+A), on your own key: Anthropic, OpenAI, Google or any OpenAI-compatible
  295. endpoint (OpenRouter, DeepSeek, Moonshot / Kimi, Z.ai / GLM, ToAPIs, WaveSpeed, Oxen.ai, or a local server). It drives
  296. the editor through the same commands an MCP client gets. Everything that costs money, queues on your ComfyUI, clears
  297. the undo stack or touches a layer it did not make asks first. Ctrl+Z takes back each of its steps; chats are saved
  298. with their screenshots, and *Settings › Assistant* deletes everything it stored. What leaves your machine per provider
  299. and what it costs: [docs/ASSISTANT.md](docs/ASSISTANT.md).
  300. ### Large pictures, plugins, agents
  301. - The tile engine keeps the picture, every layer and every mask in tiles, and the pixel kernels run as compiled Rust
  302. in workers. PNGs beyond the browser's canvas limit (up to 65,535 px a side, about a gigapixel) open and save in
  303. strips.
  304. - JavaScript plugins (filters with GPU and processor paths, panels, menu actions, tools, commands) and a command core
  305. with 124 documented commands, 104 core and 20 from the built-in plugins ([docs/COMMANDS.md](docs/COMMANDS.md),
  306. [docs/PLUGINS.md](docs/PLUGINS.md)).
  307. - MCP server for any MCP client (an `.mcpb` bundle for Claude Desktop with every release), plus `--headless`,
  308. `--cmd` for scripts and `--run` for batches: a list of commands in one call, once per file of a folder
  309. ([docs/MCP.md](docs/MCP.md), examples in [docs/examples](docs/examples)).
  310. - A status line that shows errors in red, and a thin bar beside it that follows each run: the node and the sampler's
  311. steps on your ComfyUI, the node on Comfy Cloud, the seconds on other providers.
  312. - Tabs with session restore, a local file mirror (no server needed to reopen your work), a console and a log file,
  313. updates from GitHub releases with the release notes shown before you restart.
  314. - Requests to API providers, Comfy Cloud, model downloads and a remote ComfyUI go through your system's curl
  315. (*Settings › Network*, on by default): company networks often let curl through where they block other programs.
  316. - Skins (*Settings › Appearance*): the default look, 90s, Duck, Comfy, Black Forest and Lighthouse Academy, or one
  317. you add ([docs/SKINS.md](docs/SKINS.md)).
  318. ## Linux notes
  319. The AppImage: `chmod +x` it and start it; it updates itself like the Windows app (the .deb does not: install the next
  320. one over it). On Ubuntu 23.10 and later AppArmor's limit on unprivileged user namespaces may keep Electron's sandbox,
  321. and so the AppImage, from starting; the .deb installs the sandbox helper properly. The helper models run on the
  322. processor on Linux. API keys go into the desktop's keyring (GNOME Keyring, KWallet); without one, *Settings › API
  323. providers* says the keys are only obfuscated.
  324. ## First steps
  325. For an API model, put its key into *Settings › API providers* (Ctrl+,). For your own ComfyUI, type its URL in the top
  326. bar (default `http://127.0.0.1:8188`) and press Connect; when none runs there, the dot stays grey with "No ComfyUI
  327. running", and only ComfyUI recipes and selection by text need one. Then open a picture (Ctrl+O, drop, paste), paint a
  328. selection, type a prompt and Generate (Ctrl+Enter). Ctrl+S saves the document as a `.scumble` file, Ctrl+Shift+E
  329. exports the picture. Every document is a tab (Ctrl+T new, Ctrl+W close, Ctrl+Tab next); a run keeps going while
  330. another tab is in front. Ctrl+Shift+A opens the assistant, F1 the manual.
  331. Every image the editor uploads or receives is kept under `%APPDATA%/Scumble/files/` (in a portable copy `data/files/`
  332. beside `Scumble.exe`), in `input/` and `output/` folders that mirror ComfyUI's. The server only holds copies: before a
  333. run the app uploads what the server lacks, so a fresh or restarted ComfyUI (RunPod) works without reloading the
  334. document, and the last session comes back at the next start even with no server connected.
  335. ## Run from source
  336. ```
  337. npm install
  338. npm start
  339. ```
  340. `npm run dist` builds the installer (`dist/Scumble Setup <version>.exe`, NSIS, unsigned), then `npm run dist:portable`
  341. the portable zip from the same build (`dist/Scumble-<version>-portable-win-x64.zip`). Releases are built by GitHub
  342. Actions: a tag `v<version>` that matches `package.json` builds a draft release with the installer, its blockmap,
  343. `latest.yml` (the auto-update feed), the portable zip, the `.mcpb` bundle and the Linux AppImage, .deb and
  344. `latest-linux.yml`; its notes are that version's section of CHANGELOG.md, and the build stops without one. Publishing
  345. the draft makes it visible to the app. The Rust
  346. pixel kernels are committed as `renderer/editor/px/px.wasm`; `python tools/build_px.py` rebuilds them.
  347. The tests live in `tools/` ([docs/TESTING.md](docs/TESTING.md) says what each covers), and `tools/run_gates.sh` runs
  348. a list of them on a fresh instance. How releases are built, who approves them and what the app sends over the network
  349. is in the [code signing policy](docs/CODE_SIGNING_POLICY.md). See `CLAUDE.md` for the development notes.
  350. ## Layout
  351. ```
  352. electron/main/ main process: window, scumble:// scheme with the ComfyUI proxy, websocket, menu, dialogs, settings,
  353. file mirror, keys.js (safeStorage), recipes.js, llm.js + llm_custom.js (prompt upsampling, the user's
  354. own models), providers/ (one adapter per API provider), onnx/ (SAM2, matting), plugins.js,
  355. updater.js (GitHub releases), bridge.js + local.js + mcp/ (agents), assistant/ (the loop, the
  356. policy, the four model adapters, the chat store), comfyview.js (the ComfyUI window),
  357. documents.js + docfile.js (.scumble files)
  358. electron/preload.js
  359. renderer/ shell.js (connection bar, recipe picker, tabs, settings), commands.js (the command core),
  360. plugins.js (plugin loader and the `scumble` API), assistant.js (the chat panel)
  361. renderer/editor/ the editor, shared with the ComfyUI node (docs/BUILD_NODE.md); host.js is the app side of it,
  362. inpaint_filters_gl.js the WebGL2 filter path, stitch.js the in-app crop / stitch for provider runs,
  363. inpaint_tiles.js + inpaint_arena.js + inpaint_pool.js the tile engine and its workers, px/ the Rust
  364. kernels (wasm), inpaint_bands.js the strip writers
  365. crates/px/ the Rust source of the pixel kernels
  366. recipes/ ComfyUI recipes, Comfy Cloud recipes and model recipes (one per model, a variant per provider),
  367. docs/RECIPES.md
  368. plugins/ built-in plugins: sample, film (the film pack), effects (chromatic shift and glass),
  369. glb (3D objects and the mannequin), ailabel (the EU AI label), boxes (boxes in the prompt), and
  370. five skins
  371. docker/runpod/ Dockerfile + provision.sh for a ComfyUI box on RunPod (draft, docs/RUNPOD.md)
  372. tools/ build_node.py (the node's editor), build_px.py (the kernels), cdp.py (DevTools driver), the tests,
  373. run_gates.sh
  374. docs/ MANUAL.md, BRIEF.md (vision, decisions, phases), ASSISTANT.md, COMMANDS.md, PLUGINS.md, FILM.md,
  375. MCP.md, RECIPES.md, HELPERS.md, TESTING.md, CODE_SIGNING_POLICY.md and more, images/
  376. .github/workflows/ build.yml (Windows installer, portable zip and .mcpb, Linux AppImage and .deb, draft release on a
  377. version tag)
  378. ```
  379. The editor is the same code as the ComfyUI node [Inpaint Canvas](https://github.com/DenRakEiw/ComfyUI-InpaintCanvas):
  380. if you work inside ComfyUI, you get the same canvas there.
  381. ## Licence
  382. GPL-3.0, the same licence as the Inpaint Canvas node and ComfyUI. See `LICENSE`. Free to use, modify and
  383. redistribute; modified versions must be published under the same licence. Bundled fonts are OFL / Apache licensed,
  384. see `renderer/editor/fonts/licenses`; the FLUX 3 Image Klein recipe carries Black Forest Labs' prompt upsampler guides
  385. (Apache-2.0), see `recipes/licenses`. Film names in the grain presets and the film pack are trademarks of their
  386. owners; the looks are Scumble's own approximations, not licensed products. The *get a key* links of ToAPIs and
  387. WaveSpeedAI carry the author's referral code.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.