Pixel Perfect Depth (Video Depth)

The still-image depth node in this pack is the mature core; the video one is the frontier, and it shows. PPDVideoDepthMap runs the same "pixel-perfect" idea on a sequence: instead of a semantics encoder plus a plain diffusion transformer, it uses a video DiT with temporal attention - the model looks at frames as a block and refines depth across time, which is exactly what's needed to stop single-frame depth from flickering between frames. That's the hard problem in video depth, and the pack attacks it with the same machinery that makes the stills look so clean. The honest part: the author flags the video nodes as work-in-progress, admits they couldn't test at speed, and shipped full debug logging so the community can help chase bugs. Expect rough edges.

How it works

The video model (PixelPerfectVideoDepth) is built from a Pi3 semantics encoder plus a temporal diffusion transformer. It processes the clip in sliding 16-frame windows with overlap between chunks, so temporal context carries across the seams, and denoises depth over sampling_steps - default 4, which is low because per-frame diffusion at video cost adds up fast. It returns:

• depth_video - the full sequence of depth frames as a batched IMAGE, normalized 0–1 and colorized with the inferno colormap by default (grayscale toggles that off).
• ppd_depth - the raw float32 depth payload, which you can save with the pack's PPDVideoDepthSave node or unpack per frame.

Inputs

• images - a batched IMAGE: your video frames. Load with a video-loading node or by feeding a batch of stills; the model needs a temporal sequence, not just one frame. It warns (and pads) below 16 frames, and works best on 16-frame multiples.
• sampling_steps - 4 default, up to 50. More steps = better but far slower; on video, resist the temptation, because this runs per window.
• seed - the denoising seed; -1 randomizes.
• grayscale - off by default (inferno colormap); on for clean gray values.
• use_fp16 - on for CUDA/MPS, forced off on CPU.
• debug - this is the interesting one. The author explicitly built the node for debugging: enabling it turns on verbose per-stage logging (model load time, shapes, inference time). If you hit a crash, this is the switch to flip before you open an issue.

Install

One pack, all seven nodes:

cd ComfyUI/custom_nodes
git clone https://github.com/Apache0ne/ComfyUI-pixel-perfect-depth
cd ComfyUI-pixel-perfect-depth
pip install -r requirements.txt

Restart, then the video weights - this is the heavy one, and again there's no auto-download:

ComfyUI/models/ComfyUI-pixel-perfect-depth/Video/
├── model.safetensors   (~3.7 GB, Pi3 semantics)
└── ppvd.pth            (~2.1 GB, video diffusion transformer)

That's nearly 6 GB before you even get to the still-image weights, plus the pip install pulls ppd, open3d, and a pinned utils3d build. It's a real install.

Troubleshooting and honest advice

First-run model load is slow and hungry - ~6 GB of weights plus a temporal transformer is a genuine VRAM commitment, and this node is the most likely of the pack to OOM on an 8 GB card. If it does, drop sampling_steps, resize frames down, or shorten the clip. The debug flag exists for a reason: video is where the pack's bugs live, and a cryptic crash with debug off is probably a known-rough area, not something you did wrong.

Here's the honest take: if your goal is temporally stable video depth for ControlNet or parallax, the community's default is DepthCrafter, which was built for exactly this and has a mature ComfyUI node. Reach for this one when you specifically want the PPD edge quality in video form and are willing to babysit it - or when you want to feed the whole thing into the pack's video saver and produce colored depth videos. It's the most exciting node in the pack and the least finished; keep that in mind and it's a fun one to watch mature.