MarigoldDepthEstimation_v2

This is the node that actually runs Marigold, in its current, officially-supported-by-Diffusers form. Feed it a MARIGOLDMODEL from MarigoldModelLoader and an image, and it denoises its way to a depth map - not in one pass like a discriminative model, but through an actual multi-step diffusion process. That's the whole appeal and the whole cost of Marigold in one sentence.

Why you'd reach for it over the obvious default

Depth Anything V2 is the community default for a reason: one forward pass, sharp edges, done in a second. Marigold isn't trying to beat that on speed - it's a generative model built on Stable Diffusion's prior, and that prior is exactly why it holds up on inputs discriminative models choke on: illustrations, stylized renders, synthetic scenes, anything out of the ordinary-photo distribution those other models were trained on. It's also the model people reach for when they want the sharpest possible height field for 3D printing - the diffusion + ensembling combo produces cleaner, more confident maps than a single forward pass, at the cost of taking noticeably longer per image.

How it works

Feed it the loaded pipeline and an image, and it runs denoise_steps of diffusion, optionally repeating the whole process ensemble_size times and merging the results into one steadier depth map - more independent estimates averaged out means fewer artifacts, at a straight multiplicative cost in runtime. Everything happens at processing_resolution internally regardless of your input size, because Marigold was trained around 768px and that's still the resolution it's most reliable at.

The inputs and outputs that matter

• marigold_model (MARIGOLDMODEL) - from MarigoldModelLoader. Whatever checkpoint you picked there (depth, normals, or one of the other variants) is what this node runs.
• image (IMAGE) - your source image.
• denoise_steps (default 4) and scheduler (default LCMScheduler, or DDIMScheduler) - these two travel together. The LCM checkpoints are distilled to converge in a handful of steps with LCMScheduler; if you switch to the base (non-LCM) model, you'll want DDIMScheduler and considerably more steps for a clean result.
• ensemble_size (default 3) - how many independent passes get merged. Push it up for a more reliable map, at a direct multiple of the runtime.
• processing_resolution (default 768) - the internal working resolution. This is Marigold's sweet spot; going much higher is a real gamble on quality per the author's own notes.
• use_taesd_vae - swaps in a tiny, fast approximate VAE for the decode step instead of the full one. Worth trying if you want a speed bump and can tolerate a small quality hit.
• keep_model_loaded (optional, default false) - flip this on for a batch run so the pipeline stays resident between executions instead of reloading every time.

One output: image (IMAGE), the resulting map. Wire it into RemapDepth or ColorizeDepthmap to inspect it, SaveImageOpenEXR if you need the full float range for VFX, or straight into a depth ControlNet apply node.

How to install it

ComfyUI Manager: search "marigold", install, restart. Manual:

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

You also need MarigoldModelLoader upstream - this node has no model-loading of its own, unlike the legacy MarigoldDepthEstimation.

Common issues & troubleshooting

It's much slower than the depth ControlNet preprocessors you're used to. That's expected, not a bug - you're running real diffusion steps, potentially several times over for the ensemble. If you're just after a fast ControlNet preprocess, this genuinely isn't the tool; Depth Anything V2 is.

Out of memory / it's eating a lot of VRAM. The pack's own README calls this one out directly - Marigold "can [be] pretty memory hungry." Try use_taesd_vae, drop ensemble_size to 1, and keep processing_resolution at or near the 768 default rather than pushing it up.

The output doesn't look like a normal grayscale depth map. Double-check what checkpoint you loaded upstream - if it's one of the normals or intrinsic-decomposition models, this node will happily process it and hand you back a normals map or a lighting map, which is correct behavior, just not what a "depth" node name implies.

Downloading takes forever the first time you try a new model. That's MarigoldModelLoader fetching the pipeline via huggingface_hub - a one-time cost per checkpoint, not this node's problem.