r/GaussianSplatting

Little excerpts of me playing my chaotic pointcloud system, in which the particles are being audioreactive to the incoming audio signal in real-time. What do you guys think?

More experiments, project files, and tutorials, through my YouTube, Instagram, or Patreon.

I've been playing with adding some life to Gaussian splat scenes and built a small reusable script for the PlayCanvas engine that makes trees sway in the wind. Video above — and this is a streamed LOD scene (a skatepark loaded progressively), not a single baked splat, which was the fun part to get working.

The idea is that it's drop-in: you add the script to a splat entity, hand it a list of spheres marking where the trees are (center + radius), and it does the rest. The bottom of each sphere is treated as the trunk anchor, so the sway is zero there and grows up and out toward the branch tips — trunks stay planted, canopies move.

How it works under the hood:

• During the copy-to-work-buffer stage, each splat's "binding" to a tree (sway amount, height, tree index) is baked once into an extra work-buffer stream — not per frame. A uniform grid accelerates the sphere lookup so hundreds of trees stay cheap.
• Because it hooks that stage, it works transparently on streamed LOD content: as new LOD chunks stream in and get copied to the work buffer, their splats get bound to the trees automatically — no need for the whole scene to be resident up front.
• A tiny per-frame vertex modifier then reads the baked data and applies the actual sway (a cantilever oscillation + a slow gust envelope + fast flutter).

Controls for strength, speed, direction, gustiness and flutter are all live. There's also an edit mode with gizmos to place the tree spheres and print them back out.

Runs on both WebGPU (sway happens in the projection compute pass) and WebGL (per-vertex). It's going into the engine examples as an open PR, so the script and the full example are there to read/reuse.

Happy to answer questions about the approach — curious if anyone has cheaper ideas than the per-splat texture fetch for the animated read.

Latest experiment with Gaussian splats in the PlayCanvas engine: sealing a splat inside a solid glass shape and refracting the view through it. Video above; live demo at the bottom.

You pick the shape — cube, sphere, gem, or hex prism — and the glass bends both the splat and the skybox behind it at the surface, with chromatic dispersion splitting the colors slightly. There are live controls for refraction index, reflection, dispersion, and frost.

How it works:

• The splat renders into its own layer placed before the camera frame's scene-color grab pass, so the refractive glass material can sample that grab texture and bend the already-rendered splat + background through the shape's surface.
• The splat is cropped to the inside of the shape by scaling any splats outside its faces to zero, and splats near the surface are shrunk a bit so they don't poke through the glass.
• Refraction/dispersion/reflection are a fairly standard screen-space glass material on the shape mesh — the interesting part was getting the splat to live inside the grab pass so it refracts correctly rather than just compositing on top.

Runs on WebGPU and WebGL. It's an open PR into the engine examples, so the full source is there to read and reuse.

Live demo: https://engine-it4qgogtr-playcanvas.vercel.app/#/gaussian-splatting/glass-refraction

Happy to answer questions on the approach.

Creating a basic polygon mesh from a Gaussian splat is now easy in SplatEdit.

There are three algorithm options to choose from, depending on the result you want.

Just go to:
Tools > Create proxy
Then save the output as a GLB.

Free to use. No login required.

https://www.splatedit.app

Open to hear from you how to take this tool further!

Hi,I have already tried IGS+ and it was waaaaaay worth. I am a bit lost. of why it end so bad, especially as I had som pretty good splat on my garden ans smaller object.. Colmap was created with RealityScan. Any idea what could have went wrong?

Edit: Camera used: Sony 7aIII 4K footage, Picture extracted with sharp frame extractor.

Most 3D Gaussian Splatting scenes look great, but they are usually hard to edit once you want proper lighting, material changes, or dynamic objects.

This new NVIDIA research is interesting because it brings ray-traced lighting control into 3D Gaussian scenes, while still using a neural renderer to make the final result look realistic.

The basic idea:

• Reconstruct a real-world scene as 3D Gaussians
• Use ray tracing to generate physical guidance like PBR shading, irradiance and shadows
• Feed those structured buffers into a neural renderer
• Keep the scene editable instead of turning it into a fixed AI-generated video

What this enables:

• Controllable relighting inside Gaussian scenes
• Editable materials like albedo and metallic values
• Dynamic object insertion with matching shadows
• More stable video output compared to diffusion-only relighting
• Better bridge between captured 3D scenes and editable 3D environments

Important note: the code is still marked as coming soon, so this is research/demo for now, not a ready-to-use tool yet.

Source: https://research.nvidia.com/labs/sil/projects/tron/

I added segmentation selection to SplatEdit.

It makes selecting parts of a splat much faster and easier. Just pick what you want, then use the refine toggle to lock the selection in 3D.

It runs Segment Anything locally in the browser, so there are no server costs and no setup.

I’ve already found this super useful for cleanup and editing.

Free to use. No login required.
https://splatedit.app

almost melted my GPU , definitely not running this local next time.

Linked a MFT via TDMap to GSOP parameters!

My friends had a Gaussian splat of me (scanned in 2023) printed in clear resin by crysta.ai and I'm honestly amazed how well the detail survived. My bike gear + helmet, face + hair...the fidelity is insane!

The source splat is here if you want to compare against the print:

https://superspl.at/scene/a5d25fb4

Happy to answer questions about how it turned out.

SuperSplat (the free, open-source splat editor from PlayCanvas) just got 360° video rendering. You set up a camera fly-through on the timeline as usual, pick Render → Video → Projection: 360° Equirectangular, and it exports a 2:1 equirect video up to 4096×2048 that plays in any 360 viewer.

Demo (YouTube 360 — drag to look around, works in a headset):
https://www.youtube.com/watch?v=6oGjT8eubMc

How it works under the hood, since I know this sub will ask:

• Each output frame is rendered as the 6 faces of a cube from the camera position, then a shader projects them into the equirect frame. Everything runs through the existing WebCodecs encode pipeline (H.264/HEVC/VP9/AV1 in MP4/WebM/MOV/MKV).
• Because gaussian sorting is view-direction dependent, the splats are re-sorted for every face. Adjacent faces can still composite big overlapping splats in a slightly different order (and the projected splat shapes differ a bit off-axis), which initially showed up as visible seams at face boundaries — so the faces are actually rendered at 100° FOV and blended across the overlap, which feathers the mismatch away.
• MP4/MOV exports get Spherical Video V1 metadata injected, so YouTube, VLC and Quest recognize them as 360 automatically — no need to run Google's spatial media injector.
• There's a Level Horizon toggle (on by default): only camera yaw is baked into the projection so the horizon stays level even if the camera path pitches up/down — much more comfortable in a headset. Turn it off if you want full camera orientation baked in.

It's monoscopic for now (stereo ODS is a much bigger lift for splat rasterization). Fair warning: it renders each frame 6 times with a re-sort per face, so it's roughly 6× slower than a normal video export — fine for offline rendering.

This will ship in the next release; if you can't wait, build from source — the PR landed here: https://github.com/playcanvas/supersplat/pull/933

Happy to answer questions about the implementation. Would love to see what you render with it — post your 360s!

(Fun fact: the feature was built using Claude's latest model Fable 5 — welcome to the future!)

I tested the same industrial site with two different drone capture approaches. There's 4 stages in this comparison.

-The first reconstruction uses only Mavic 4 Pro images. It gives better overall site coverage, especially from above, but the building itself lacks close-range detail (≈1H flight time).

-The second one uses only Avata 360 images. The building has more local detail, but the surrounding area is much weaker because the flight was shorter and closer (13min flight time).

-The third version combines both drone datasets, which gave the best raw result.

-The final version uses the same combined dataset, but with longer training and cleanup to remove floaters.

The capture light wasn't stable, sunny/cloudy changes.

This is just a practical 3DGS workflow comparison for visual documentation.

I ported Apple’s SHARP model to ONNX and now works in the browser with WebGPU.

No install required, the weights download to your browser and you can start using it immediately

Happy Splatting!

⭐ Demo: https://sharp-onnx-webgpu.vercel.app/

⭐ Code: https://github.com/pristinaai/Sharp-Onnx-webgpu/tree/main

⭐ Weights: https://huggingface.co/sentiantai/sharp-onnx-webgpu-weights/tree/main

Two years on, and I'm still madly in love for how a discontinuated camera and TouchDesigner can turn a silly performance into an audio-reactive particle spectacle.

Full HD video-demo at: https://www.youtube.com/watch?v=6tORsukgx4E

You can also access the project files [touchdesigner] through my Patreon page! - https://www.patreon.com/c/uisato