DDColor_Colorize

You've got a stack of old black-and-white family photos, or a 1920s film you want to bring back to life, and you don't want to spend a whole diffusion pipeline to do it. That's exactly the niche DDColor_Colorize fills. Feed it a grayscale image and it hands back a colorized one in a couple of seconds, no prompt, no sampler settings, no 8GB model download. It's a one-trick node - but the trick is genuinely good, and it's the colorizer most restoration workflows in the wild actually lean on.

This is also the gentlest possible introduction to a Kijai pack. The same author behind ComfyUI-WanVideoWrapper, KJNodes, and CausVid (the guy who's shipped multiple models straight into ComfyUI core) knocked this one out in a single file. It's been dormant since January 2024 and still works fine, which tells you something: it's a thin, finished wrapper around a good model, not a project that needs babysitting.

How it works

Under the hood it runs DDColor, the Alibaba model from CVPR 2023 that made colorization respectable again. The pipeline is worth understanding because it explains why the results look the way they do:

1. The image is converted from RGB to LAB color space. The L channel holds all the luminance (detail) - that's what's preserved exactly.
2. The image is resized down to model_input_size, turned grayscale, and pushed through a ConvNeXt encoder into a multi-scale transformer decoder that predicts the a/b chroma channels (the color) at low resolution.
3. The predicted color is upsampled back to your original size and recombined with the original, untouched L channel.

The key takeaway: DDColor never touches your detail. It adds color on top of a perfectly preserved grayscale structure. That means you can feed it a 4000px scan and it'll still be sharp - the chroma just gets upsampled to match, while your luminance stays pixel-identical. It's why this node is so much more predictable than running an img2img colorization pass, which tends to "improve" (read: drift) your image while it's at it.

The three inputs, and honestly only one matters

• image - any IMAGE tensor. Grayscale or already-color both work; it'll colorize whatever you feed it.
• checkpoint - four choices from the piddnad/DDColor-models repo. Here's the trap: the dropdown defaults to ddcolor_paper_tiny.pth, the lightweight variant. The author's own model zoo recommends ddcolor_modelscope as the best all-rounder for real-world photos (trained with the BigColor data-cleaning scheme), with ddcolor_artistic as the punchier, more stylized option. The tiny one is for speed; the other three use the heavier ConvNeXt-Large encoder. For your great-grandma's wedding photo, switch to modelscope and don't look back.
• model_input_size - the resolution the model actually processes color at, default 512, range 32–4096. This is the one knob you'll actually touch, and it's the biggest trap in the whole node.

Installing it

ComfyUI Manager: search "ComfyUI-DDColor" and install. Or the manual route:

cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-DDColor
cd ComfyUI-DDColor
pip install -r requirements.txt
# restart ComfyUI

Dependencies are light: numpy, opencv-python, Pillow, timm, and huggingface_hub. Nothing heavy - no torch to install because ComfyUI already brings it. Models auto-download on first run into ComfyUI-DDColor/checkpoints/ (note: the pack's own subfolder, not ComfyUI's main checkpoints dir). If you're offline, grab the .pth files from piddnad/DDColor-models and drop them there manually.

Common issues

The one people actually hit: "Allocation error" when model_input_size is above 256. The ConvNeXt-Large encoder processes the full input resolution, so on a low-VRAM card (or a Mac without proper GPU support) anything past 256-512 can OOM. Drop it to 256 - since detail comes from the original L channel anyway, you'll lose almost nothing.

Also worth knowing, because it's the natural follow-up question: this node only colorizes. It won't remove scratches, fix faces, or sharpen anything. The workflow people actually run is LaMa/BigLAMA inpainting to clean damage first, then DDColor, then an upscaler and maybe a face-preserving pass. And unlike diffusion-based colorizers, there's no prompt and no semantic control - DDColor guesses colors from training data, so a green suit might come out blue. That's the trade-off for being fast and deterministic. For most restoration work, it's a trade worth making.