Super Pop Color Adjustment (SuperBeasts.AI)

Super Pop Color Adjustment is why most people find this pack. It's a trained residual color-correction model from SuperBeasts.AI - an Instagram creator who grades literally everything he posts - that pushes vibrant palette, deep blacks, crisp highlights and a bit of HDR bite in one pass. The "one shot" is the whole pitch: instead of chaining four curve nodes and praying, you drop in an image and get something that looks finished.

Important distinction up front: this is not a filter, and it doesn't call any API. It's a small network that runs locally on your machine.

How it works

The model analyzes your image in 512×512 patches and predicts a residual - the per-pixel difference between your image and the "corrected" one. Patches are stitched back together using a linear weight map in the overlap regions (that's what your overlap setting controls, and why low overlap shows seams on big images), and the residual is added back onto the original at the strength you pick. Because it's a residual, it can't hallucinate content or rewrite the composition - it just nudges color and levels, which is what makes it safe to throw at almost anything.

Two details are worth knowing because they'll save you head-scratching:

• The context thumbnail. The model gets a 64×64 downsampled copy of the image as a global color reference while it grades each patch. Leave the context socket empty and the node builds that thumbnail from your source automatically - that mirrors how it was trained and is the safest default. Plugging something in (a palette swatch, a hero frame from earlier in a video, a totally different artwork) steers the global color mapping toward that reference.
• The 7-channel input. Internally the node appends YCbCr and saturation channels to each RGB tile to match the format the network was trained on. You never see this, but it's why a 512px patch needs a separate global reference at all.

The inputs that matter

Full list: model, image, max_strength, count, overlap, initial_context_for_batch, plus optional context. You'll actually touch these:

• max_strength (default 1.0) - how hard the grade lands. 0.5 is subtle, 2.0 is dramatic, and past 2.0 you start clipping highlights.
• count (default 1) - output N variants at evenly spaced strengths from max_strength/count up to max_strength. Set max_strength 1.0 and count 2 and you get a 0.5 and a 1.0 version. Great for A/B-ing without rerunning.
• overlap (default 0.5) - blend between adjacent patches. For images over ~2K, push it to 0.8–0.9; seams get invisible at the cost of more compute.

Outputs are images (the graded batch), filename_prefix (a SPCA_<strength>_ string you can wire straight into Save Image), and residuals - a special SPCA_RESIDUAL type that you feed into Super Pop Residual Blend to re-apply any strength later without re-running the model.

Install

Same pack as everything else on this repo:

cd ComfyUI/custom_nodes
git clone https://github.com/SuperBeastsAI/ComfyUI-SuperBeasts

then restart ComfyUI. Or just search "SuperBeasts" in ComfyUI Manager and hit install. No extra Python deps to babysit - it's torch, Pillow, NumPy.

You also need the SB Load Model (SuperBeasts.AI) node, which is in the same pack. Connect its model output here, set it to SuperPopColorAdjustment/latest, and the weights download automatically on first run into custom_nodes/ComfyUI-SuperBeasts/models/ (a ~2GB safetensors on the v2.0 build). The download is checksum-verified; if it ever errors with a checksum mismatch, delete the file and let it re-download.

Where people get burned

The author is upfront that this is a personal project shared as-is, so expect edge cases. The three recurring ones, all straight from the docs:

• Patch sensitivity on big images. Above ~2K you can see slight local exposure shifts at patch boundaries. More overlap fixes it; that's the trade you're making.
• It eats atmospheric tints. The model corrects blacks and whites aggressively, so a matte-style cinematic wash can get dialed back. Keep strength around 0.7 or blend the result with the original.
• Speed on the old model. The v1.0 ONNX build runs on CPU but is painfully slow; onnxruntime-gpu gives roughly a 10× speedup. The v2.0 safetensors build (what latest resolves to) runs natively and is the one to use - on a 4090 it does 1024² in ~1.6s and 2048² in ~5.2s.

Also note the weights are SPCA-Community-NoSaaS: local, personal and client work are fine, but you can't wrap this model in a public SaaS/API without a license. That banner prints in your console the first time weights download.