Beyond cover art: background removal, batch resources, and two GPUs of throwaway pixels

TL;DR

Cover art was the gateway drug. The same local ComfyUI install that generates this blog’s headers also strips the cluttered background off a photo of hardware on my bench, upscales a small generation to retina resolution, and batch-produces a consistent set of illustrations from a prompt template. Two Mac Studios mean I can fire a batch at one box and keep working on the other. It’s all driven from scripts and agents, and it all costs $0 per image because it never leaves the house.

If you haven’t read the setup post or the blog-image pipeline post, start there — this one assumes ComfyUI is already running and you’re already generating headers. This is the “what else is it good for” tour.

Background removal without a subscription

The most useful thing I do with ComfyUI isn’t generation at all — it’s background removal. I photograph hardware on whatever surface is handy (a cluttered bench, a carpet, a cardboard box), and I want a clean white-backdrop cutout for a blog gear shot or a wiki page without paying a SaaS “remove.bg”-style subscription per image.

The tool is a custom node, ComfyUI-RMBG, running the BiRefNet segmentation model:

• It’s a single custom node added to the ComfyUI install.
• BiRefNet is MIT-licensed — which matters, because plenty of background-removal models carry non-commercial licenses that quietly make them useless for anything but a hobby. MIT means I never have to think about it.
• The model (~1 GB) auto-downloads on first inference and lives in models/RMBG/.
• On the M3 Ultra’s GPU a cutout takes a couple of seconds.

The workflow is: load the photo → BiRefNet produces an alpha matte → composite onto a white (or transparent) background → resize. The original pixels of the object are never altered — it only replaces what’s behind them — so a hardware photo stays an honest representation of the thing. That distinction matters if you ever use these shots anywhere a misrepresentation would be a problem.

One gotcha worth flagging: the RMBG node ships with a pile of dependencies aimed at NVIDIA/Linux (onnxruntime-gpu, decord, triton) that don’t install on macOS. The install strips those out, and BiRefNet runs fine on MPS without them. If you bolt this onto a Mac and it explodes on pip install, that’s why.

Batch generation, where consistency is the hard part

Generating one image is easy. Generating twelve that look like they belong together — a set of section icons, a row of illustration cards, social images for a whole series — is the actual challenge, and it’s where scripting beats clicking.

The trick is to hold everything constant except the subject:

STYLE = ("flat vector icon, single object, centered, muted slate and blue, "
         "white background, minimal, consistent line weight, no text")
NEG   = "photo, realistic, gradient, shadow, text, watermark, busy"

subjects = ["a server rack", "a network switch", "a hard drive",
            "a padlock", "a terminal window", "a wifi router"]

for i, subject in enumerate(subjects):
    generate_image(
        prompt=f"{subject}, {STYLE}",
        negative_prompt=NEG,
        checkpoint="sd3.5_large.safetensors",
        width=512, height=512,
        steps=25, cfg=7.0,
        seed=1234,          # fixed seed = shared visual DNA across the set
    )

Pinning the seed and the style/negative strings is what makes the set cohere. A fixed seed with a varying subject keeps composition, palette, and “feel” consistent while the actual object changes — which is exactly what you want for an icon row. SD 3.5 Large is the right checkpoint here because it follows the compositional instructions (“single object, centered, consistent line weight”) more faithfully than the photoreal SDXL checkpoints.

I still throw away half of what comes out. But generating a 12-icon set and keeping the 8 good ones costs me ten minutes and zero dollars, versus commissioning or licensing a set.

Upscaling the keepers

A 512×512 draft is fine to evaluate but too small to ship as a cover. Rather than regenerate at full size (and risk a different image), I run the keeper back through an upscale pass inside ComfyUI. Generate small and fast to find the composition you like; upscale only the winner. It’s the same logic as shooting RAW and only editing the frames worth editing — cheap to capture, expensive only where it counts.

A few LoRAs ride along on the realism work when I want extra polish:

I don’t stack these by default — they’re situational. For a flat vector icon set they’d actively hurt. For a hero photo of hardware, add_details plus a light AntiBlur pass is the difference between “fine” and “sharp.”

Two boxes, so a batch never blocks me

I run ComfyUI on two Mac Studios. The MCP layer exposes them as comfyui (port 8188) and comfyui-2 (port 8189), so an agent — or I — can target either one. The practical payoff: I fire a slow batch of two dozen icons at box two and keep generating one-off headers on box one without queueing behind myself. When I’m not batching, box two is busy with local LLM work, so neither sits idle.

The model library outgrew a single SSD a while ago, so checkpoints overflow to MinIO object storage and sync back every 30 minutes via rclone. ComfyUI is pointed at both the local SSD and the synced overflow directory through extra_model_paths.yaml, so it finds a model whether it’s hot on disk or archived in object storage — I never think about where a given checkpoint physically lives. Hot models stay fast; the long tail stays out of the way.

What I reach for, by job

Pulling the whole tour together:

The honest caveats

• Background removal is not perfect on thin or transparent things. Cables, mesh, glass, and wispy edges confuse the matte. For 90% of solid hardware it’s flawless; for the other 10% I still touch it up.
• Batch consistency is a constant fight. A fixed seed gets you most of the way, but one subject in twelve will still come out stylistically off and need a re-roll.
• Licensing is a real consideration. “Commercial-safe” is a property of the model, not the tool. I deliberately use MIT-licensed BiRefNet for cutouts. If you’re publishing, check the license on every checkpoint and node you adopt — some are research-only.
• More LoRAs is not more better. Stacking realism adapters on a flat-illustration job produces an incoherent mess. Match the adapter to the intent or skip it.
• Curation still doesn’t scale. Free generation means infinite candidates, and infinite candidates means I become the rate limiter. The GPU is never the bottleneck; my eyes are.

Lessons

• Background removal is the sleeper feature. Generation gets the headlines, but the cutout workflow is what I use almost every week.
• Pin the seed for sets, randomize it for one-offs. That single parameter is the difference between a cohesive batch and twelve unrelated images.
• Generate small, upscale the winner. Don’t pay full resolution to discover a composition you’ll throw away.
• Two GPUs turn “wait for the batch” into “fire and forget.” Parallelism beats a faster single pass for this kind of bursty, interactive work.
• Read the license before you adopt the model. Free to run is not the same as free to publish.

No second Mac Studio in the closet? None of this needs two of them — a single GPU runs every workflow here, just serially. And if you don’t have a homelab at all, a DigitalOcean GPU Droplet will run ComfyUI, RMBG, and batch jobs the same way — you’re renting the GPU by the hour instead of owning it.