Adaptive Noise Filter

Flat, uniform noise is a lie. Real film grain and real sensor noise are adaptive: heavy in textured, high-frequency areas, barely there on smooth gradients like sky or skin. Dump uniform noise on a portrait and you sandpaper the face as hard as the background. AdaptiveNoise fixes that by looking at the image's own frequency content and pouring more noise where the detail already is. It's one of the better "make this look like it was shot on film, not rendered" tricks you'll find as a single node.

It comes from AnotherUtils (marcoc2/ComfyUI-AnotherUtils), in the same family as the pack's GEGL-style filters - the author explicitly models these on GIMP's own filter implementations, and the quality shows. Pure PyTorch, no models, no dependencies beyond torch itself.

How it works

The pipeline is: convert to linear light (sRGB → linear, because noise behaves differently in gamma-encoded space), compute a luminance image, run a Sobel edge detection to find where detail lives, and build a frequency map by Gaussian-blurring the edge magnitude. That blurred edge map is then normalized and used to modulate the noise amplitude per-pixel. In flat areas the noise is throttled way down; at edges and textures it's turned up. There's even per-channel noise injection rather than just luminance noise, which is what gives it that organic, film-like character instead of a digital "static" look.

adaptation_strength is the dial that matters: at 0 you get essentially uniform noise (with edge-threshold control doing nothing), and as it climbs toward 2 the noise concentrates more and more on high-frequency regions.

The inputs that matter

• image - any batch of images. RGBA inputs get their alpha preserved and passed through, which is a thoughtful touch for compositing.
• noise_strength - overall intensity, 0–1. Start at 0.3 and nudge up.
• adaptation_strength - how aggressively noise follows detail. 0 = uniform, 1 default, 2 = very edge-focused.
• edge_threshold - the sensitivity cutoff for what counts as an edge. Lower = more areas treated as flat.
• blur_radius - how smooth the frequency map is; higher radius means broader regions of "textured vs flat" rather than pixel-level flicker.
• noise_type - gaussian or uniform. Gaussian looks like sensor noise; uniform reads more like film grain at higher strengths.
• seed - deterministic noise, so re-runs are reproducible. Lock it while you tune, then let it ride.

What comes out

One image tensor, same shape as the input, with the adaptive noise baked in.

Installing it

Same as every node in this pack:

cd ComfyUI/custom_nodes
git clone https://github.com/marcoc2/ComfyUI-AnotherUtils.git

Restart ComfyUI, or search "AnotherUtils" in ComfyUI Manager. No models.

Where people get burned

The trap is cranking noise_strength to hide banding and then wondering why the whole image got crunchy - remember the point is the adaptation, so keep strength moderate and let adaptation_strength do the work. And don't forget that it operates on linear light internally, so results can look different from what you expect if you feed it an already-graded image. It's a finish-pass node: run it last, after color grading, and save a version with and without to see what it actually bought you.