Scumble dev blog

Comfy launched something new this week: Comfy Router, a direct API for the partner models it already bills through ComfyUI's API nodes. Same Comfy key, same credits, but no workflow around it and, unlike Comfy Cloud, no paid plan. That was too good to leave for later, so this release is mostly about it.

Sixteen of Scumble's recipes can run on it now: GPT Image 2 and 2.5 (with your selection as a real mask), Nano Banana 2, 2 Lite and Pro, FLUX.2 pro and max, FLUX.1 Fill, Seedream 5.0 Lite and Pro, Qwen Image 3.0, Magnific Precision as an upscaler, and Grok Imagine, Ideogram 4 and Krea 2 for Generate new. It's always the last option in a recipe's provider list, so nothing you're used to changes. There's no new key field either: Comfy Router uses the key you put in the Comfy Cloud row.

The Router sends every model its own native request, so there's no one format to learn, there are nine. I didn't want to guess at any of them, so I downloaded the published schema of every model Scumble sends to and made the tests check every request against it, field by field. Runs go into Comfy's queue and get collected when they're done, and every run carries a key that makes a resend safe: if an answer gets lost on the way and Scumble asks again, Comfy hands back the first run instead of starting and billing a second one.

Then I tried it for real. GPT Image 2 painted an apple into a selection in 24 seconds for about three cents, Nano Banana 2 a potted plant in 16. The first key I pasted didn't work at all, by the way: it wasn't a Comfy key, and the Router said so on every route. Easy to check before spending anything, because listing the models costs nothing. The rest of the models haven't had their live run yet, and their notes say so.

And one model that isn't on the Router: HY Image 3.5 Preview, Tencent's new image model, which ComfyUI added as partner nodes a day earlier. Scumble talks to the same route those nodes use, with the same key. It edits with up to five pictures (name them @Image1, @Image2 in the prompt, like in ComfyUI) and does Generate new. My test edit, a coffee cup, took 28 seconds and cost exactly the $0.034 the ComfyUI node says it does. One honest warning: that route isn't a published API, it's what ComfyUI itself sends, so a change on Comfy's side can break it before I catch up. The recipe note says that too.

That $0.034 also cleared up a mystery: Comfy's balance endpoint answers in a field called micros, but it went down by exactly 3.432 for that run. So it counts cents, whatever the name says.

I also started a list of what comes after the Mac: making 3D objects with AI models and dropping them in as 3D layers, which Scumble can already render and turn. The Router has a few 3D models; whether their results are good enough to paint over is the first thing to find out.

Until now, Help › Editor guide opened the README of the ComfyUI node on GitHub. Wrong file, wrong repository, and not much help for a desktop app. So this release replaces it with the real thing: press F1, or the new Help button in the top bar, and the manual opens in a column next to your picture. It's the same manual as on this website, all 17 chapters, searchable, and it works offline.

Above the manual sits a chat. Ask it how to do something and it answers from the manual, and only from the manual, then names the chapter it took the answer from. One click and you're reading that chapter. I tried it on a real model with a question the manual doesn't answer (how to sync settings between two computers), and it said so and pointed me to the docs instead of making up a menu item, which is exactly the one thing a help chatbot must not do. It runs on any model you have a key for, including the small text-only ones, because it needs no eyes and no tools. It also can't change anything in the app; that's the assistant's job. With a small model through OpenRouter a question cost me about one cent.

The bigger change is behind the scenes: the manual used to live only in this website's code, which meant it would slowly drift away from the app it describes. Now it lives next to the code in the Scumble repository, and this page is built from a copy of it. A few checks make sure it doesn't name things the app doesn't have: every shortcut in the menus has to be in the shortcut list, and every settings section or menu item the manual mentions has to exist. They caught two mistakes on their first run, one of them mine from the same afternoon.

Scumble also has a logo now: a little creature made of paint, with a chalk brush stroke behind it that shows through its body. That's what a scumble is, a thin half-transparent layer over a dry one. At 16 and 24 pixels it gets its own simplified drawing, because the full one turns to mush that small.

The Upscale dialog has a prompt field now, for the two upscalers that take one (Clarity and Magnific Creative). They always used the prompt from the Generate tab, but the dialog didn't show it, so it looked like you couldn't give them one.

And an embarrassing one. In 0.1.26 I made the installer smaller by telling the build what to leave out. Turns out that when you only tell electron-builder what to leave out, it starts from everything, so 0.1.26 packed my whole project folder into every install: the development docs, the tests, the Rust sources, the build scripts. Nothing private, and nothing the app ever read, but it was about 5 MB of junk on your disk. The installer is 128 MB now, and there's a check that stops it from happening again.

One more honest correction: the recipes that run through OpenRouter all said they had never been tested against the live API. GPT Image 2.5 Flare and Sunburst have now done well over a hundred real edits through it, so those two say so, and the other models say the route works but that model hasn't been tried yet.

Next up is the Microsoft Store. The package is built and has run installed on my machine, and a Store copy gets signed by Microsoft, so no more SmartScreen warning for whoever installs it from there. The GitHub installer stays as it is.

The third release today, and the unglamorous kind: nothing new in the editor, it's all about how Scumble gets onto your machine.

The Windows installer was 188 MB. Turns out a good chunk of that was stuff a Windows PC never touches. The runtime for the helper models (SAM2 and background removal) comes with builds for macOS, Linux and Windows on ARM, and all of them went into every Windows installer. So did Chromium's interface texts in 55 languages, even though Scumble's own menus and dialogs are English anyway. Now it only packs the Windows x64 runtime and English plus German. The installer is down to 134 MB, and the installed app from 676 to 421 MB. I checked that the helper models still load from the smaller package, on the GPU and on the CPU.

And Scumble comes for Linux now. This release has an AppImage and a .deb next to the Windows installer, and so will every one after it. The AppImage updates itself like the Windows app does. Honest note though: I haven't run it on Linux myself, I don't have a Linux box at hand. So it's built, not tested. If you try it, tell me what breaks. On Linux the helper models run on the CPU for now, because the GPU runtime would have added a few hundred megabytes to the download.

Two small things came with it. If your Linux desktop has no keyring, the API keys would only be obfuscated, not really encrypted, and the settings now say so in plain words instead of pretending everything is fine. And the MCP registration you can copy from the Help menu points at the AppImage file itself. Everything inside an AppImage moves to a new place every time it starts, so any other path would have stopped working the next day.

The Mac comes next, but not yet. Scumble's icon is a 512 px picture with no source behind it, and a Mac wants a 1024 px icon. Instead of blowing up the old one, Scumble gets a proper logo first. The name already has the idea: a scumble is a thin, half-transparent layer of paint over a dry one, so the one underneath still shows through. That's exactly what an inpaint result over your picture is. Once the logo is there, the macOS build follows.

This one started as a bug report of my own: Scumble could save a PSD with all its layers, but not open one. Turns out it wasn't a broken path, there simply was none. The open dialog didn't even list .psd, and a PSD you dropped in went straight to the browser's image decoder, which has no idea what to do with it.

Now Open, drag and drop and the load_image command read Photoshop PSDs and OpenRaster ORAs as layers: names, positions, opacity, visibility and blend modes. If the bottom layer covers the whole picture, like Photoshop's Background or anything Scumble saved, it becomes the picture. Otherwise the picture is transparent and every layer stays a layer. Drop a PSD on a picture that's already open and its layers get added where the file has them.

Photoshop has things Scumble has no place for, so here's what happens to them. Layer masks get baked into the layer's transparency. Groups get flattened, and their visibility and opacity carry over to the layers inside. Adjustment and fill layers are left out, clipping masks aren't kept, and blend modes Scumble doesn't have become normal. The status line lists all of it, so nothing disappears quietly. RGB and grayscale, 8 and 16 bit work. PSB, CMYK and 32-bit files get refused with the reason.

I tested it on real Photoshop files from my own projects, with groups, masks and hidden layers. Stacked back up, the layers match Photoshop's own merged picture to within a fraction of a level. The only real difference came from files where a gradient fill layer was the background, and those say so when they open.

Writing the test for this turned up a bug in the other direction: the PSD export wrote every layer name as plain ASCII, so a layer called Gürtel came out as G_rtel, in Photoshop too. Both PSD writers now also store the full Unicode name, the way Photoshop does.

Upscaling got a local route too. There's a new recipe, Upscale model (ComfyUI), that runs any upscale model from your server's upscale_models folder: ESRGAN, UltraSharp, DAT, whatever you've got. It works on the selection. The box goes out at its native size, without a fill or reference layers, and the model's bigger answer gets fitted back in as a sharper layer. The whole-picture mode isn't offered here, because the node's stitch can only paste back into the box. It hasn't done a run on a real server yet.

And the upscalers from 0.1.24 have now run for real with my own keys. Topaz Precision through fal took about 25 seconds for a selection and for a whole 2 MP picture, and 34 seconds to take that picture 4 times larger to 33 MP. Magnific Creative took 13 seconds. Magnific Precision took five minutes for a small box, so the status line now warns you about that, the same way it does for Topaz.

There's a new Upscale button next to Generate new. It opens a small dialog: pick a model, pick the factor, and decide whether it works on the selection or on the whole picture.

On the selection it's a detail pass. The selected area goes to the upscaler at its own size, the sharper answer comes back and gets fitted into the selection at the document's resolution, as a new layer. Nothing gets bigger, it just gets crisper. Generate does the same thing while an upscale model is the selected recipe, so picking one from the recipe list is never a dead end.

On the whole picture the base image goes out and the answer becomes the new picture, 2, 4 or more times larger. Every layer, every mask and the selection are scaled along, and one Ctrl+Z takes all of it back. Pictures over 4096 px on the long side are refused before anything is sent. For those, upscale a selection. Doing whole huge pictures in bands comes later.

Nine models, in their own Upscale group of the recipe list. Through fal.ai, so no Topaz account needed: Topaz Precision, Bloom and Wonder, the open Clarity upscaler (your prompt guides the added detail), SeedVR2, and Recraft Crisp and Creative. Through Magnific, with a new key row: Magnific Precision (2 to 16 times) and Magnific Creative (2, 4, 8 or 16 times, prompt as guidance). Both Magnific upscalers and both Recraft ones also run on Comfy Cloud, billed in Comfy credits.

Two things to know. Topaz can take several minutes on a large picture. The status line tells you, and the window stays usable while it runs. And every Magnific API call costs credits, even if your web plan says unlimited. That allowance only covers their own web app.

Agents and the built-in assistant get an upscale command too. The assistant asks before it upscales, same as before it generates. Honest note: I wrote every one of these from the providers' docs and schemas, and none of them has done a real run against a live API yet. I'll be testing them with my own keys over the next few days.

A small patch, and the first one that started as a GitHub issue. You couldn't rename layers. Turns out the rename was never broken: a layer row was about 15 px wider than the panel, and the name was the only thing in the row that gave way. It got squeezed down to zero pixels. So you saw the eye, the thumbnail and the IMAGE / RESULT dropdown, but no name to double-click, the delete button was cut off, and the whole list scrolled sideways.

The panel on the right is 320 px wide now instead of 290, the row's buttons are a bit more compact, a name always keeps at least 48 px, and the rows of a text layer wrap instead of running off the edge. Double-click a name to rename it, like the tooltip always promised. And renaming is an undo step now, so Ctrl+Z brings the old name back.

New local recipe: Qwen Image Edit 2.1 (ComfyUI), built from ComfyUI's own template. One thing I found while wiring it up: Qwen's text encoder only reads the first picture of each input, so if you plug Scumble's crop batch straight into it, your reference layers quietly disappear. The recipe splits the batch instead: the crop is <image1>, the next two pictures (the Original copy, your reference layers) are <image2> and <image3>. It needs a current ComfyUI and the three Qwen Image 2.1 model files, and the recipe lists where to get them. I checked it against a real ComfyUI's node definitions, but it hasn't done a real run yet.

And there's a new upscale use case for prompt upsampling. Pick it next to the Upsample button and the language model describes what's already in the picture, plus the fine detail an upscale or refinement pass should bring out, and it's told not to add, remove or change anything.

A short one, same evening as 0.1.21. My list of built-in models is curated, but I kept wanting to try models that weren't on it. So now there's Settings › Language models: pick a provider, type the model id exactly the way that provider spells it, tick what it's for, done.

Tick Prompt upsampling and the model shows up in the editor's Upsample list. Tick Assistant and it appears in the chat's model picker, in its provider's group. It runs on the key you've already stored for that provider, so there's no new key to set up. If the model can't see images, untick Can see the picture: it'll never be sent the crop, and the assistant leaves its screenshot tool out.

For OpenRouter, the id field suggests from their live list of models that can use tools, so a model they add today works today, without a Scumble update. DeepSeek, Moonshot, Z.ai and WaveSpeed can do prompt upsampling now too. Until now their keys were only used by the assistant.

Fair warning: nothing checks whether the id exists or whether the model understands tools. That's between you and the provider, and whatever error they send back is what you'll see.

And something that had been bugging me: every row in the assistant's model picker said “not tried with a real key”. Ten providers, every single row. It read like the app was warning you about itself. That's gone. A row now says only what's actually true about that model, and the honest note that no model has finished a task against a live API yet is written once, in the docs and in the release notes.

This is the big one. There's now a chat column on the right: the Assistant button in the bar, View › Assistant, or Ctrl+Shift+A. You tell it what you want and it does it with the same commands an external MCP agent gets. It selects, adds layers, writes the prompt, renders, colour-matches and exports, and every step shows up as a card so you can watch what it's doing.

It runs on your own API key, across all four model families: Anthropic (Claude Sonnet 5, Opus 5), OpenAI (GPT-5.6 Terra, Sol, Luna), Google (Gemini 3.8 Flash, 3.1 Pro preview, 3.5 Flash-Lite) and anything that speaks the OpenAI chat format: OpenRouter, DeepSeek, Moonshot / Kimi, Z.ai / GLM, ToAPIs, WaveSpeed or your own local server.

I spent a lot of time on keeping it from going rogue. Anything that costs money or puts work on your ComfyUI asks first: generate, select by text, cutout, upsampling. So does anything that clears your undo history or bakes layers together, and any edit to a layer it didn't make itself. Neither button on those cards is the default, and pressing Enter in the chat never answers one.

Everything it does can be taken back. Ctrl+Z undoes each of its steps, including the ones the editor normally doesn't record. When a turn is finished, Undo this turn puts every document it touched back the way it was (pixels, selection, prompt, settings), even if the turn was longer than the undo stack. That one needs the tile engine. Chats are saved and can be reopened, and Settings › Assistant has one button that deletes everything the assistant ever stored. Your API keys stay.

What leaves your machine: your messages, a short note about the open documents (names, sizes, layer names), the results of its tool calls and any screenshots it takes. All of it goes to the provider you picked and nobody else. Where things stand: every model family was built from its docs and checked against the real servers as far as a key without credit lets you. No model has finished a real task yet. That's what my bug hunt after this release is for.

Also new: OpenRouter as an image provider (one key for GPT Image, Nano Banana, FLUX.2, Seedream, Grok Imagine, Krea and Recraft) and BytePlus ModelArk, which runs Seedream 5 straight from ByteDance. Both are opt-in, nothing moves over on its own. OpenRouter is told to skip every host it lists in China, and BytePlus runs in Malaysia or Dublin. Neither has been tried against the live service yet.

Two fixes I'm a little embarrassed about: FLUX.2 [flex] on fal ran with 2 steps instead of 50, because two settings rows were sharing one slot. And you couldn't import a recipe with several providers, which is the format of every recipe I ship. Both fixed.

This one is all about that moment when the window just stops. I work on 15k images a lot, and three things kept freezing it.

Opening a large JPEG, a WebP or a PNG with a colour profile used to lock the window for one to four and a half seconds while the browser decoded it. Now a background worker does that, and the window stands still for well under a tenth of a second. A JPEG with an Adobe RGB profile went from 3.7 seconds of freeze to 0.03. Same pixels as before, with the colour profile, EXIF rotation and transparency.

API runs: cutting out the crop and stitching the answer back in held the window for up to 6.3 seconds on a 15k document with a colour-matched layer and a film look. Now it's 0.05. All of that happens in the background, from the same picture.

And letting go of the brush or eraser on a huge layer: the hitch went from 0.29 seconds to 0.07. The stroke is now written tile by tile instead of through giant temporary pictures. Soft paint can come out one level different, which you can't see.

Colour match per layer is one of my favourite things in Scumble, but it had a price: any document with a matched layer took the slow path when you saved it or used the magic wand. Not anymore. The background workers now read the match statistics straight from the picture's tiles and apply the match themselves.

On a 15000 × 10000 picture with a big matched result layer, a PNG export went from 6.4 seconds to 1.8, and the window freezes for 0.08 seconds instead of 1.4. The magic wand went from 2.5 seconds to 0.9.

The honest part: a matched layer's colours can shift by a few levels in exports, because the statistics now come from samples of the picture instead of the whole picture drawn small. I measured it on four photos: 0.1 to 2 levels on average, 7 at most on a very textured landscape. You won't spot it, but I'd rather you know.

Also fixed: set_layer with match_source “below” was quietly treated as “surroundings”, so an agent couldn't pick the other source. And I moved some of the editor's plumbing into files of its own. That changes nothing for you, but it makes my life easier.

A big performance release. The idea behind all of it: stop pushing every strip of a huge picture through the browser's canvases, and let the background workers and the graphics card do the work directly.

Documents with filter layers save about twice as fast. A 15k picture with three paint layers and a levels layer went from 6.2 seconds to 1.4 for a PNG. Blend modes (multiply, screen, overlay and friends) now run in the workers too, and they're calculated more precisely than before. The magic wand and the bucket are about three times as fast on large pictures, and they select exactly the same pixels.

Opening a big plain PNG no longer freezes the window (2.1 seconds down to 0.1). Grow, shrink and feather on a large selection hardly hold the window anymore. And the soft masks that blend an API result into your image take 0.6 seconds instead of 2.5.

Pixels can be one level different here and there, where layers are partly transparent. The browser's own canvases disagree with each other by more than that.

Chromium can't hold a canvas bigger than 268 megapixels, so until now neither could Scumble. Now a PNG that big is read piece by piece straight into the tile engine. A 30000 × 20000 file (600 megapixels, 1.1 GB) opens in about ten seconds, and you can pan, paint, select, render and undo like with any other picture. The new limits are 65,535 px per side and one gigapixel. Pictures that size save as PNG, PSD or ORA. JPEG and WebP need one canvas of the whole thing, and Scumble tells you so instead of writing an empty file.

Saving doesn't freeze the window anymore either. A PNG is now written in strips, up to eight workers compress them at the same time, and a progress figure counts up in the status line. On a 15k picture the whole save actually takes a bit longer than before, but you can keep working while it runs, and the files are less than half the size.

A bug that had annoyed me for a while: vignette, Normalise, and the film pack's frame, light leak and halation were calculated on whatever part of the picture you were looking at. Zoom in and the vignette darkened the corners of your view, not of the image. Now they're placed in the whole picture, so the screen matches the export.

Also: faster PSD and ORA export, a lighter autosave, and plugins can now place their filters relative to the whole picture.

Grow, shrink, the magic wand, the bucket and the picture's detail levels now run as compiled Rust (WebAssembly) instead of JavaScript. The results are identical to the last bit, just faster: a magic wand across a whole 15k picture went from 4.6 seconds to 3.1. If the compiled code can't load for some reason, the JavaScript takes over as before.

The bigger win: a colour-matched layer used to be matched on a full-size copy of itself every time the view looked at it. On a 15k picture that was 1.1 GB of memory and a sluggish pan. Now only the part you see is matched, straight from the tiles: 0.13 seconds for the first frame, 3 ms per frame while panning, and no copy at all.

Also in here: the screen, the navigator and the eyedropper now agree on what a matched layer looks like. Cropping, resizing and flattening no longer decode the whole picture again, and their undo steps are much lighter. Brush strokes keep less in the undo history too.

Half a second after every change, the Film looks panel makes a small preview picture for its thumbnails. On a 15k document it built that on the thread that draws the window, so everything froze for half a second, every single time. Now a worker does it: the window is held for 47 ms instead of 700.

Same story with the screenshots agents ask for and the picture a language model sees when you upsample a prompt. They're at most 1024 px wide, but they were made from the full document: around 2 seconds and 1.7 GB each time. Now it's 0.1 to 0.7 seconds. The object tool and background removal start much faster too.

Also fixed a sneaky one: right after a change, the eyedropper could pick a matched layer's original, unmatched colour, and from then on the magic wand and the film thumbnails saw that layer unmatched as well.

The embarrassing part first: in 0.1.13 you only saw the first dab of a brush stroke while painting, and the rest appeared when you let go. The stroke itself was always right, only the screen didn't redraw. Fixed, same evening. Also fixed: the Settings dialog wouldn't close, because the Tile atlas box didn't accept its own default value. Yes, really.

New: ToAPIs as a provider. One key runs GPT Image 2 and 2.5, Nano Banana, FLUX.2, Seedream 5 and Qwen Image 3.0. There's a Channel setting: official is the model maker's own cloud, vip and standard cost a fraction of it. Nothing moves to ToAPIs on its own, and it hasn't been tried against the live service yet. Two things to know: your crop is uploaded to public ToAPIs file addresses for the run, because that's how their API works, and the key link carries my referral code.

With a ToAPIs key you also get cheap prompt upsampling, about a tenth of a cent per rewrite.

And switching models now starts from that model's own defaults, instead of carrying over a setting with the same name from the model before.

This is the release I'd been working towards for days. Scumble now keeps the picture, every layer, every mask and the selection in small 256 px tiles, and the screen only draws the tiles that are visible, at the zoom you see them at.

On a 15000 × 10000 picture with three paint layers, a matched result and a film look, the graphics process used to hold about 7.5 GB, much of it on the graphics card that ComfyUI wants as well. With tiles it's about 2 GB there. Panning at 1:1 takes about 3 ms a frame, a brush dab about a millisecond, and zooming back to 1:1 draws its first frame in about 20 ms instead of a second.

Layer masks cost almost nothing now (1.86 GB gone on that picture). A stroke only keeps the tiles the brush actually touched: a line across the whole picture went from 560 MB to 26. Grow, shrink, feather and invert work on the area the selection covers instead of the whole picture.

The memory moves, though: the window's own process holds more now, so several huge pictures open at once add up. Close the big tabs you aren't working on. Not everything is fast yet, and the changelog lists exactly what's still slow. If something goes wrong, Settings › Rendering › Tile engine switches it off and you're back to one canvas per layer.

On the surface nothing changed here. Underneath, every place in the editor that touches pixels (several hundred of them, each doing it its own way) now goes through one interface. That's the foundation the tile engine is built on.

Rewiring all of that turned up a surprising number of bugs, mostly around undo. Undo put flipped or merged layers back wrong. Pressing Ctrl+Z quickly could leave a layer half undone. Undoing further back could bring back changes you had already undone. Opening a new picture of the same size kept the old picture's history. And an edit made right after Ctrl+Z on a large picture could simply vanish. All fixed, and Flatten can be undone now too.

Closing a tab now actually frees its memory. Before, every closed document stayed in memory until you quit, and on large pictures that was gigabytes per tab. Oops.

And a restored document keeps its selection, including after the next save.

A quick note first: this version never went out as a download of its own. Everything in it reached you with 0.1.12 the next day.

Until now, the editor's code lived in my ComfyUI node Inpaint Canvas and was copied into the app with a list of patches. That's flipped: Scumble is the home now, and the node gets a build of it. A fix made once reaches both.

It's also the first real work on large pictures. On a 15k image a selection change held the window for 50 to 750 ms, now it's a few milliseconds. The magic wand and the bucket look at the region instead of the whole picture. A brush stroke no longer needs three canvases the size of the layer, which was 1.8 GB on that picture.

And Settings › Rendering now watches the whole graphics card, ComfyUI's models included, and releases caches when it gets tight.

Lots of new toys in this one. You can import Photoshop .abr brush packs, and they're still there after a restart. Every tip gets its own spacing and a Follow stroke option, and the eraser uses them too.

You can place 3D objects: Plugins › Place 3D object (.glb) opens a dialog with your picture as the backdrop. Turn the model, move it, set the light, place it as a layer. Then select it and run Generate with a denoise below 1, and the model paints it into the scene.

There's an AI label panel that puts the European Commission's official icon for AI-generated or AI-modified content on your picture in one click.

Smaller but handy: SVG files open, there's a Normalise filter layer, the export can put the picture in a frame, API results default to 2K instead of 1K, and layers snap to the canvas edges when you scale them. And finally there's a console (Help › Console) and a log file, so when a provider fails you can see why. Escape closes dialogs again, and the model folder scan finds the helper models' ONNX files in your ComfyUI models folder, whatever they're called.

A late-night release for two bugs that really hurt.

One: an erase or brush stroke could make a whole layer disappear from the screen, even a layer nowhere near the stroke. Zoomed out, the screen draws from a reduced copy of each layer, and refreshing that copy used a Chromium drawing mode that clears the whole copy, not just the stroke's rectangle. Your pixels were always safe, only the display lost them. That's exactly why it looked like erasing took chunks out of your layers.

Two: zoomed far out, a click with the rectangle tool could leave a tiny selection behind instead of clearing it. One wobble of your hand by a single screen pixel was a dozen image pixels. And since the brush and the eraser are clipped to the selection, retouching just stopped working with no visible reason. The drag is now measured in screen pixels.

The API size row is also called Highres fix now, with choices you can read without hovering for a tooltip.

GPT Image 2 and 2.5 can answer with a cutout, a subject on a fully transparent background. Set Background to transparent and the result layer keeps the model's own alpha channel: logos, products, objects, ready to drop over anything. Generate a new image has a transparent background tick for the same thing.

There's a Transparent asset prompt template that writes the wording the model needs for clean edges. The rest of OpenAI's image parameters are there too (file format, compression, moderation), and GPT Image 2.5 now goes out at up to 3840 px instead of 2048.

Fixed: the prompt templates were missing from Generate a new image until you had opened Settings once.

I found a silly limitation: every API run sent a 1024 px crop, whatever the model could handle, because one number controlled both local and API runs. Now every model knows its own ceiling, and a new row lets you choose how it's used, including a high-res fix that sends a small selection at twice or four times its own resolution.

New shape tool (Y): rectangles with rounded corners, ellipses, polygons, polylines, Bezier curves and freehand paths, filled, outlined or both, clipped to the selection, one undo step each. Before, this took a selection and the bucket.

Export can save smaller now (a percentage or a free size, with a quality setting for JPEG and WebP), and seven more models arrived: Z-Image Turbo, Ideogram 4, Grok Imagine 2.0, Reve 2.1, Krea 2, Recraft V4 and Z-Image base.

Published a few minutes after midnight, which tells you how that day went.

Generate new in the top bar makes an image from a prompt alone, on your ComfyUI or through an API provider, and then you edit it like any other picture.

Prompt upsampling works with your own local model now: point Settings at Ollama, LM Studio, vLLM or anything else that speaks the OpenAI chat API, no key needed. The way the model rewrites your prompt now comes from templates, plain Markdown files you can write yourself, import and pass on.

MCP clients that follow the spec to the letter refused to talk to Scumble, because Electron writes an empty line before the app even starts. A small launcher keeps the channel clean now, and Help › Copy MCP registration puts the right setup on your clipboard.

Plus a bunch of fixes from actually using it every day: width and height in two boxes, a click deselects again, the selection outline no longer disappears on white images, and you can copy and paste whole layers between tabs.

Found a leak: every large image you opened and closed stayed in memory with all its layers. After four 12k documents, the graphics card was holding 19 GB it couldn't use for anything, and sliders were five times slower. Now the same four rounds leave 35 MB behind. The culprit was in the plugin system.

Filter layers now stay on the graphics card for the whole chain instead of going back and forth to the processor once per layer. Free VRAM releases the caches too, and background tabs let go of what they can rebuild when memory gets tight.

Also fixed two regressions from 0.1.3: painting that seemed to snap back (the stroke was there, the screen just didn't show it), and a colour-match slider that did nothing on screen.

Every layer is now stacked in one shader pass on the graphics card instead of one at a time on the processor. With a dozen layers in a large window, the slowest frames went from about 10 ms to 0.2. I checked it pixel by pixel against the old way, across every blend mode, a masked layer, colour match and text: it agrees within one level out of 255.

Filter layers, a running brush stroke, transforms and exports stay on the old path for now, and a machine without WebGL2 works just like before.

Working on 6k to 12k images meant waiting after every single action. So I rebuilt the drawing pipeline around what's actually on screen. On a 96-megapixel document, the opacity slider went from 250 to 900 ms per step to under 10, the magic wand from about 2 seconds to 0.3, and saving a layered PSD from 4.1 seconds of frozen window to 0.1.

Images over 64 MB couldn't be loaded at all, because they took a route that needed ComfyUI. They're stored locally now like everything else, so loading works with no server at all.

New: prompt upsampling with your own API keys (GPT, Gemini, Claude), and presets for local recipes, so a model, text encoder and VAE combination can be saved under a name.

Two hours after the launch. Filters on very large images showed one corner blown up to full size, because Chromium caps a graphics buffer at about 33 megapixels. Above that, filters now render in tiles.

Two more API providers: WaveSpeedAI and Comfy Cloud. And the provider list in Settings no longer says “no key” right after you've saved one.

Scumble is out, free and under the GPL-3.0.

It's a standalone editor for AI inpainting that grew out of my ComfyUI node Inpaint Canvas: layers, selection by text, retouch tools, filter layers, colour match per layer, text layers, PSD and ORA export.

It renders through your own ComfyUI, on your machine or on a remote box, or through API providers. Background removal and object selection run right inside the app. There's a plugin system with a film pack of eleven looks built in, it speaks MCP so an agent can drive it, and it updates itself from GitHub.

Windows only for now, and the installer isn't signed yet, so SmartScreen will warn you on the first start: More info, then Run anyway.

About the name: a scumble is a thin, semi-opaque layer of paint over a dry one, so the layer underneath shows through. Which is pretty much what an inpaint result over your image is.