Video Right Eye Disparity

Here's the pitch in one line: you've got a regular video and a per-frame depth map, and you want the right-eye view so the whole thing plays back as 3D in a headset. This node takes your left-eye frames as a batch, warps each one using its depth map, and hands back a right-eye video. That's it. No new models, no downloads - it's the video wrapper around the same reprojection math as the pack's single-image node.

The genuinely useful part is that it only ever generates the right eye. That halves the work compared to the stereo pipelines that compute both views, which matters when you're chewing through a few hundred frames. The tradeoff is you have to bring the left eye and the depth maps yourself.

How it works

Each frame goes through the same path: grayscale-convert the depth map (or resize it to match the frame), then call create_stereoimages() from ComfyStereo with the divergence negated so the reprojection lands on the right eye. The node disables direction_aware_depth_blur and skips returning the modified depth map - both deliberate, both memory savings. It also shows a progress bar, which is a small mercy when the queue is long.

Inputs and outputs that matter

• images - your left-eye video frames, as a batch tensor.
• depth_maps - one depth map per frame, same length as the batch.
• fill_technique - how to patch the occluded regions revealed by the shift. Default "Fill - Polylines Soft" is the README's recommendation; leave it there initially.

Then the same optional sliders as the image node: divergence (default 3.5) is the 3D strength, separation shifts the whole view, stereo_balance splits the effect between the eyes, and the two depth-blur knobs smooth artifacts at depth edges. Output is a single images tensor - the right-eye frames - which you feed into a Video Combine / Meta Batch node with the original left-eye video to produce the final stereo file.

The workflow

Depth maps come from a MiDaS or Depth Anything node upstream (the README's example pipeline is Load Video → MiDaS Depth → this node → optionally upscale each eye separately → Video Combine). No other custom nodes are required - it's deliberately short.

Installing it

Via ComfyUI Manager (search "RightEyeDisparity"), or:

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

Restart after. Dependencies are torch, numpy, Pillow, opencv-python, numba, and scipy. Numba is the one that tends to fight your Python/numpy versions; if it can't import, the pack prints a warning and runs in slower pure-Python mode rather than failing outright. No model files to fetch.

Where people get burned

• Temporal flicker. Depth maps estimated frame-by-frame with an image model flicker, and this node faithfully turns that flicker into stereo flicker. If your depth source wobbles, so will the 3D. A video-native depth model (DepthCrafter is the usual suggestion) fixes most of it - the KB covers this exact trap.
• Memory. Per-frame it's cheap, but a long high-res batch adds up fast. Cut the batch size or process at working resolution and upscale the left/right pair afterward - the README's own advice for OOM.
• Strong divergence = big gaps. Crank divergence to 15 and every frame gets huge empty regions the fill has to guess. Keep it in the 2–5 band the README recommends, and if you're chasing quality, note that the single-image node additionally outputs a gap mask you can route through inpainting - the video node doesn't give you that safety net.

It's a narrow tool: input video, depth per frame, right eye out. For VR content from flat video, that's most of the hard part done - and done in a way that doesn't eat your whole VRAM budget.