CRTLike Effect

The one-liner

Pixydust Quantizer gives you the pixels; CRTLike Effect gives you the monitor. It renders an image the way an actual CRT display would have shown it: RGB subpixel stripes, phosphor glow, and slight color bleed between channels, all wrapped in a gamma curve. It's the finishing pass that makes 16-color sprites look like they're being seen on a screen, not just sitting in a file.

One thing up front so it doesn't confuse you later: the output is 4x the input size in both dimensions. That's not a bug - it's the subpixel simulation doing its job.

How it works

Reading the source (the README is loose with numbers here, the code isn't): the image gets a nearest-neighbor upscale to 4x, then the R, G, and B channels are masked into a repeating subpixel pattern - each color only gets its column slot, like a real aperture-grille display. Each channel is then convolved with its own anisotropic Gaussian kernel whose falloff is shaped by the gamma parameter, multiplied by intensity_scale, pushed through a 1/gamma tone curve, and clamped.

Translate that out of GPU-speak: every logical pixel becomes a cluster of RGB subpixels, and each subpixel bleeds light into its neighbors. That's the phosphor glow and the color bleeding in one shot - and because the bleeding is per-channel and anisotropic, you can make it smear horizontally the way a shadow-mask tube did.

The settings that matter

• gaussian_width_x / gaussian_width_y - how far the bleed travels on each axis. Set x higher than y and you get the classic horizontal CRT smear. This is the pair you'll actually fiddle with.
• intensity_scale - overall effect strength, 0.1 to 10. The shipped default is 5.0 (don't trust the README's "1.2" - the code and the node both say 5). Crank it for a glowy retro look, drop it for subtle.
• gamma - 0.1 to 5, default 1.0. It shapes both the glow falloff and the final tone curve. Leave it alone until the look is wrong in a specific way.
• gaussian_kernel_size - 5 to 15, default 11. Larger = softer glow, slower.
• enable_resize / resize_pixels - this is the trick that makes the whole thing work. On by default, it downsizes the long edge to resize_pixels (256) before the 4x upscale. So a 1024px render becomes a 256px sprite that blows back up to 1024 with authentic chunky subpixels. Turn resizing off only when you're feeding genuinely small sprites already.

Wiring

One IMAGE in, one IMAGE out. The natural chain: Quantizer → CRTLike Effect → PreviewImage. Because the output is 4x, a 512px sprite becomes 2048px wide - keep enable_resize on unless you want giant output, and remember the 4x expansion eats VRAM if you're processing a long batch.

Install and gotchas

Same install as the rest of the pack - it ships in the same repo, so install once and you get all three nodes. No models to download; it's all convolution math.

cd ComfyUI/custom_nodes
git clone https://github.com/sousakujikken/ComfyUI-PixydustQuantizer.git
pip install -r ComfyUI-PixydustQuantizer/requirements.txt

Then restart ComfyUI. Two things to know:

• Apple Silicon runs this on CPU. The quantizer node got MPS support in v2.1.0, but this node's device check is CUDA-or-CPU. Fine for a single still, genuinely slow for a 4x upscale across a long batch.
• RGB only. It raises a ValueError if you feed anything that isn't 3-channel, so strip the alpha before it gets here.

There's built-in OOM handling - if a batch overflows VRAM it quietly reprocesses image-by-image - but max_batch_size (default 4) is there so you don't hit that in the first place. A tiny pack, an unglamorous job, and it does it well.