Gaussian Shot Render

Gaussian Shot Render is the "press the shutter" node of the gaussian-splat-shot-render pack. Feed it a Gaussian Splatting PLY scene and it renders a camera shot - yaw, pitch, roll, distance around a pivot - and hands you a completely ordinary IMAGE on the other end. That's the whole point: it's not a 3D tool that happens to live in ComfyUI, it's a way to turn a 3D scene into images you can push through img2img, inpainting, ControlNet or upscaling like any other tensor.

The fun part is the interactive WebGL scout viewer that lives inside the node. You orbit, dolly and tilt in real time in the browser, and the actual raster stays aligned with what you're looking at. The node is one half of a two-shot workflow this pack ships: point it at a PLY you already have, or pair it with the pack's SHARP nodes (Load SHARP Model + SHARP Predict) to go from a single photo straight to a splat scene, then start framing shots. Single image → 3D → cinematic camera moves, all in the graph.

How it works

This is where you need to calibrate expectations. The inline viewer is WebGL (gsplat, vendored in the repo so you don't need any extra 3D pack) running on your GPU, and it's smooth. The final raster - the thing that actually becomes your image - is a CPU splatter written in NumPy, optionally Numba-JIT compiled. Preview and capture are completely different code paths. Realtime preview absolutely does not imply a fast render. When you hit "run," the node decodes the PLY, builds a camera state from your pivot and angle inputs (or from SHARP's extrinsics/intrinsics if you've connected them), splats the in-frustum gaussians onto a canvas, and returns the image plus a JSON blob of camera state for the viewer to sync with.

The inputs that actually matter

Most of the widget list is camera math you can poke from the viewer and let sync back, but a few you'll set by hand:

• ply_path - the PLY file. It's marked optional in the schema because it can be wired in, but there's no render without it; the node throws if it's missing.
• extrinsics / intrinsics - SHARP's camera metadata. Connect them and use_source_resolution makes the output match the source photo's size, ignoring output_width/output_height.
• output_width / output_height - raster resolution (64–4096); the viewer matches the aspect.
• camera_locked - commit to the procedural output camera instead of following your interactive preview.
• seed plus the rand_* min/max pairs - jitter translation, yaw, pitch, roll per seed. Handy for generating a batch of subtly different "takes" off one framing.
• max_gaussians (0 = uncapped, or top-N by importance), gaussian_scale, background (black / mid-gray / white).

Output is a single image (IMAGE tensor). Wire it straight into your downstream nodes.

Installing it

Grab it through ComfyUI Manager (search "Gaussian Splat Shot Render"), or the usual way:

cd ComfyUI/custom_nodes
git clone https://github.com/EnviralDesign/gaussian-splat-shot-render-comfyui
pip install -r gaussian-splat-shot-render-comfyui/requirements.txt

Then restart ComfyUI and refresh the browser. The requirements are light - numpy, plyfile, huggingface-hub - plus numba, which is listed as strongly recommended rather than mandatory. No model download for the render node itself; you just need a PLY. (The SHARP path pulls a checkpoint from Hugging Face on first use.)

Where people get burned

• The raster is CPU. Install numba or a 1024² render of a dense splat will feel like a long bath. The first splat in a session may pause while LLVM compiles; later runs are fast. Disk cache is off by default - set GAUSSIAN_SHOT_NUMBA_DISK_CACHE=1 on a stable machine to keep the compile.
• VRAM confusion. The node never runs the splat on CUDA. GPU memory you see afterwards is SHARP, preview caches, or the browser's WebGL tab, not this node.
• RAM creep. One decoded PLY is cached in-process (path + mtime keyed), which is great for repeat runs and heavy on big clouds. GAUSSIAN_SHOT_DISABLE_PLY_CACHE=1 trades I/O for memory if it bites.
• License. The original code is MIT, but the bundled WebGL viewer is GPL-3.0-or-later (from comfy-3d-viewers) - fine for personal use, just know it's in the third-party notices.

Compared to a full 3D viewport pack like Action Director, this is a scalpel: it doesn't animate rigs or emit depth/normal passes, it frames shots and bakes them to images. If that's the job, it does it without dragging a whole 3D pipeline into your graph.