Emissive Color (Polly)

Emissive maps are how you tell a game engine or a stylized render "this surface is lit from within, not just bright." The problem is that standard brightness-based masking can't tell the difference between a glowing orange lava blob and the white specular glare sitting right on top of it - both are "the bright parts," so the mask grabs the reflection too, and your emissive texture ends up with a big dead white blob where the highlight was. Emissive Color (Polly) exists to solve exactly that one problem, and it does it with HSV saturation logic instead of a naive threshold.

Here's the whole trick, and it's a good one: glare (specular reflection off a glossy surface) is bright but low-saturation - it's white, or close to it. Glow (a lit-from-within emissive material) is bright and saturated - lava is orange, neon is magenta. The node converts your image to HSV, then computes a scoring map of value × (saturation + (1 − saturation_filter)), normalizes it, and thresholds it into a mask. Run the numbers and you'll see the elegance: at saturation_filter = 1.0 that collapses to value × saturation, which scores pure white pixels near zero no matter how bright they are. That slider is your "ignore glare" dial - crank it and white speculars fall out of the mask while saturated color stays in.

The node is one file, emissive_color.py, and it's genuinely small - it converts to HSV with OpenCV, does the masking math, blurs, and picks a color, all in a loop over the batch. No models, no weights, no API. That's refreshing in a pack era where half the custom nodes need a download manager.

The inputs that actually matter

• mode - the four choices are the whole product. Vivid (Lava/Neon) is the default and the reason this node exists: it picks the single pixel maximizing value × saturation^color_boost, so a saturated-but-slightly-dim lava orange beats a bright-but-white reflection. Brightest Pixel is the classic luminance pick (Rec. 601 weighted), for ordinary light sources. Dominant (Average) takes the mean color of everything reasonably bright - a "what color is this glow overall" fallback. Manual Override just uses your hex.
• saturation_filter (0–1) - the glare killer described above. This is the one you'll actually fiddle with.
• mask_threshold (0–1) - how much of the image ends up inside the mask. Higher = only the core glow; lower = spillover.
• blur_amount (0–100) - softens the hard binary mask edge into a natural glow falloff via Gaussian blur. Default 2 keeps it subtle.
• color_boost (1–10) - in Vivid mode this is an exponent on saturation, so higher values even more aggressively ignore grey/white.

There's also color_picker_override (a hex string, default #FF6600) and, of course, the image input. One gotcha worth knowing before it bites you: the code reads the override as a plain string, and if it can't parse your hex it silently falls back to white. So a typo like #FF66 gives you a white solid color, not an error. Keep it to a clean #RRGGBB.

The outputs

Three of them, all per-image, batch-aware:

• Mask (MASK) - the grayscale emissive mask. Wire this into anything mask-based: compositing, a KSampler denoise region, or straight to a file as your alpha/emissive channel.
• Emissive (IMAGE) - the mask multiplied by the picked color: flat glow color over black. This is the one you actually bake into a texture.
• Solid Color (IMAGE) - the full-frame picked color. Mostly a preview swatch, handy for checking what the node decided your glow "is" before you commit to it.

Installing it

ComfyUI Manager, search "Polly", install, restart. Or the manual route:

cd ComfyUI/custom_nodes
git clone https://github.com/polly-creative/ComfyUI_Polly_Nodes.git
# restart ComfyUI

The entire dependency story is one line in requirements.txt: opencv-python. No model downloads, no HF weights, nothing heavy. ComfyUI already ships an OpenCV (headless) in most installs, so import cv2 usually just works; if you hit a ModuleNotFoundError: cv2, pip install opencv-python into your ComfyUI venv fixes it.

Common issues

• Mask looks like confetti on noisy renders. Binary threshold on raw generation noise does that. Raise blur_amount or drop mask_threshold; the source applies blur after thresholding, so heavy blur rescues most of it.
• Glare still sneaking in. Push saturation_filter toward 1.0 and raise color_boost - white highlights need both before they score near zero.
• Manual Override gives you white. See the hex-parse fallback above; that's the code doing you "a favor."

Honest verdict: this is a niche utility for a specific job - baking emissive maps for PBR work or punching up flat-color neon stylization. If you just need any old glow, you can fake it with threshold + blur nodes, but the saturation-vs-value split is genuinely the right idea and this is the only place you get it in one node. The pack is brand new (March 2026), MIT-licensed, one author, zero community chatter yet - so treat it as unproven but sound. For its one job, it's the node I'd reach for.