r/GaussianSplatting

Today I tested the new Spatial Capture feature by Insta360, using my Insta360 X5. This feature allows you to create gaussian splats by just taking a 360 video with your insta. The actual process of creating the 3dgs is easy, and it works also with just a 30 seconds video. But how to get there was tricky, as I couldn't find clear official guidelines from start to end, and at first the "Spatial Capture" tab was not showing.

I explain everything in this video, so it will be easy for you: https://youtu.be/rDATvx6kjJU?is=ygk\_MPX8G-cSEP\_t

And no, you don't need the X6 for using spatial capture. You can even use X5 and X4

Hello everyone! I’ve been having a lot of fun making collages with my scans and animating them. Wanted to share one of my latest ones. Three different scans in me scene here. The main environment is a scan from an abandoned hotel in Allegan, Michigan, it’s been virtually untouched for the last 50 years! Thanks for looking.

Been experimenting with Gaussian splatting for spatial interfaces and ended up building this little interactive demo.

It basically warps a 3DGS scene into an “inception map” type view, where you can see the space around you while also getting more of a top-down overview further away.

You can move around, rotate the view and toggle the effect on/off.

Try it here:
https://www.orbify.eu (link edited to load properly)

Still very much an experiment, so I’d be interested to hear what you think. Does this kind of view make sense to you? Any use cases or datasets you think would be fun to try with it?

https://github.com/Herolias/Reconstrura-Splat-Animator/

I've only tested it with Linux and NVIDIA GPU, but it should also work with AMD and Windows. I will likely add more transitions/features in the future and contributions are welcome if you want to add new transitions yourself

Hi everyone,

We've been building LocalMesh for the past few weeks, and the beta just opened.

Short version: one photo goes in, and you get a 3D Gaussian splat (~60s on a 5090, ~2min on a 4060 laptop), then a textured mesh** (UV-unwrapped, photo reprojected, AO, normal map) exported as GLB/PLY/OBJ.

Everything runs locally. No upload, no queue, no credits. Turn off your Wi-Fi, it still works.

The mesh part is the bit we're proud of. Poisson reconstruction on gaussian centers drapes a tarp over your object: a Poisson solver has to close every surface, and can never say "I can see through here".

So instead: 60 virtual cameras on a golden-angle sphere, gsplat renders depth for each, every ray carves out the empty space it travels through, and the 60 depth maps fuse into a 768³ TSDF volume. Carving instead of guessing. (gs2mesh principle, written from scratch.)

Other things you might enjoy:

- It runs on 8 GB cards. The entire conversion (splat rendering, TSDF fusion, decimation, atlas bake) stays under 7.3 GB of VRAM, so a 4060 laptop finishes the exact same job as a 5090, just slower.

- No CUDA toolkit, no Visual Studio, no Python, no admin rights on the client. We ship a fat gsplat wheel with precompiled kernels, RTX 20 to 50.

Limits, upfront: one photo means the back of the object is invented, not measured. Windows + NVIDIA 8 GB only. No Authenticode cert yet, so SmartScreen will grumble on first launch.

7 days free, no card to start, then $39 once, no subscription, because there's no cloud to pay for: https://local-mesh.com

Break it and tell us, that's what the beta is for.

Happy to answer anything about the pipeline in the comments.

you probably had a client asking it works on iPad with no wi-fi.
You could build yourself a self contained experience app but having this on scale without any worries and just toggling a switch button is actually powerful and handy.

i vibe coded this demo on my platform of a gaussian splat with UI interactions, data, lottie animations, all running in a web browser, with an optional "Download contents" button. And its good to go because it works on modern browsers using their caching api (Safari is tricky as always).

Users don't need to worry anymore about next projects because they have xr suite and infrastructure, can just say to the client: "Yes it supports offline contents natively 😎"

Hello r/gaussiansplatting,

Here is the lastest 3dgs I have been able to produce with LCC (latest version).

This cloister has been my favorite test model for quite some time, and after spending some time fixing alignment errors, I got to this result. This is the 1st time I can read the text on the signs and see the columns in such detail.

The total splat count is 21,489,691. Here it is on Supersplat

Hi everyone! I am a software engineer who has worked in the following domains at major tech companies most of my career: XR, Graphics & GPU programming, Spatial algorithms and AI, and 3DGS.

I have a project I started a few months ago that I have recently hit a key milestone in. The idea is a focused library that implements 3DGS training from first principals with an emphasis on performance and safety. Think production use cases without relying on tools intended for research. VkSplat is an inspiration (along with other things) but I have intentionally not reviewed their, or anyone else's, code.

The recent milestone I reached was rendering a scene with 5 million splats at 60fps on my Ampere A6000. I have a few more goals I'd like to reach, but I do intend to publish on Github under MIT license. If it gains traction I would like to build some additional tools and infra using this project, but for right now the 1.0 MVP idea is a fully GPU resident solution for rendering and training at state of the art speeds. I plan to implement and optimize the following features:

• Global image alignment
• Fully fused forward and backward passes
• Adam optimizer
• Aggressively optimized adaptive control and densification
• Stable but highly flexible C api.

I do have many more thoughts and ideas, but I am trying to take it one step at a time, so this is my goal for 1.0. This is my stack as of now:

• Languages: C++23, Cuda, GLSL (planning to move to slang)
• Build: CMake & Ninja
• Compiler: GCC, Clang, MSVC (may drop for now)
• Target Platform: Linux (Linux 7.X)
• Tooling: LLVM, perf, nsight
• GPU: Vulkan w/ Nvidia
• Dependencies: googletest, googlebenchmark, ngfx

Right now, the project is in a place where it is still extremely early, but it is starting to take shape and get large enough that more than one person can work on it comfortably. I am posting here looking for people interested in contributing. Knowledge is not a prerequisite as I am learning a lot myself in this endeavor, but passion is mandatory.

Currently I am mostly needing help in the areas of, CI/CD (build, package & deploy), nsight/gpu optimization, designing and implementing a good api, and figuring out how to test and benchmark appropriately.

If you have skills or experience in any of these areas, or you're just interested in contributing, please reach out!

TL;DR: SuperSplat now has a public REST API for publishing splats, so the tool you train in can upload directly instead of you exporting a multi-gigabyte PLY and re-uploading it by hand. Three integrations are live today!

How the API works

• Auth is an access token you can obtain from your PlayCanvas account page
• Scenes arrive unlisted by default, so nothing is public until you choose
• Metadata includes a field recording which tools made the scene

Guide: https://developer.playcanvas.com/user-manual/supersplat/api-integrations/

Endpoint reference: https://developer.playcanvas.com/user-manual/api/supersplat/

LichtFeld Studio

Adds a SuperSplat tab next to Rendering and Training. Sign in once, choose which splats to upload, then it exports PLY or SOG with live progress and resume.

We wrote this plugin ourselves and it's MIT licensed, so it also serves as the reference implementation of the API - if you want to see the whole upload flow end to end, it's all there: https://github.com/playcanvas/supersplat-lichtfeld-plugin

XGRIDS LCC Studio

Publish straight from My Models in Lixel CyberColor. LCC2 is the recommended format, which gets you compressed streaming output without a separate conversion step. You get the viewer link back when the upload finishes.

Teleport by Varjo

Connect once under Settings → Integrations, then publish per capture. Takes phone images, 360 video or up to 10,000 drone images and trains georeferenced splats up to 100M Gaussians.

If you build splat software

The API is documented and the reference implementation is MIT, so there's a complete working example to copy. Setting softwareTools on upload also gets your tool a logo chip on every scene published with it, and a collection page that accumulates those scenes.

Why we built it

Naturally, we are keen to see more splats on SuperSplat! But the export-then-reupload round trip is the worst part of every splat workflow and it didn't need to exist. For what it's worth, SuperSplat, the viewer, the PlayCanvas engine and splat-transform are all MIT licensed, so you can self-host the whole stack if you'd rather not depend on us.

Screen recordings of each integration and more detail: https://blog.playcanvas.com/new-in-supersplat-introducing-the-new-publishing-api

Want to meet the SuperSplat team (and a huge 3DGS community)? Come join us on Discord:

https://discord.gg/RSaMRzg

I’ve been working on an open-source frame extractor for video-to-COLMAP/3DGS workflows:

https://github.com/morishuz/frame-extractor

Instead of extracting at a fixed FPS, it tracks points using dense optical flow and selects a new frame when camera motion, tracked-point loss, or a maximum interval crosses a threshold. It also writes a CSV containing the selection and timing diagnostics.

The goal is to reduce redundant COLMAP inputs without leaving gaps that are too large to match.

I’m looking for feedback from people working with handheld, drone, dash-cam, or large-scene video:

• What do you currently use to select frames?
• Which failure matters most: excessive processing time, blurry frames, too little baseline, or failed registration?
• Would anyone be willing to compare this against fixed-FPS extraction on a difficult clip?

Current limitations: this is a Python CLI rather than an end-to-end 3DGS application, and it has not yet been validated broadly on stitched 360 or multi-camera video. Reflections, texture-less surfaces, and poor capture geometry still cannot be fixed through frame selection alone.

Feedback, test results, and critical failure cases are very welcome.

Here’s a sneak peek at the ViewForge 3DGS Slicer UI.
It slices a 360° equirectangular panorama into 16 perspective views, allowing you to select them à la carte to export a clean transforms.json for training. You can also apply camera jitter (randomized offsets) when slicing to augment your dataset.
I’m currently planning to add Colmap export support as well!

IOS 27 3DGS viewer

I've been experimenting with manipulating Gaussian Splats directly in real time — not just rendering or editing the capture.

This test can break the scene apart, keep the splats moving as a dynamic material, and reconstruct the original scene. Underneath it I'm experimenting with independently timed behaviors and higher-level creative controls, so this is heading toward a system for designing different kinds of Gaussian-based VFX rather than a single effect.

It's still very experimental and I'm figuring out what the right creative abstraction should be.

I'm curious what people working with Gaussian Splatting think: does treating splats as a manipulable VFX medium feel like an interesting direction? What would you want to be able to do with them?

GaussianCrowds is a tool in development for Unreal Engine 5.7/5.8, built to render thousands of 4D Gaussian splat performances in real time.

• Nanite-Style Dynamic LOD’s: Automatic adaptive detail scaling and frustum culling allows hundreds of concurrent splat sequences to render in real-time
• Multi-light Relighting: Supports Lumen global illumination, directional, point, and spot lights, shadow-casting, and self-shadowing using automatic normal-map generation. 
• Deformation-Based Playback: Native support for compressed deformation containers (SpacetimeGaussians, etc..) as well as PLY sequences.
• Procedural Crowd Placement: Create crowds with spline-based tools that distribute 4DGS performers along splines. Customize spacing, orientation, playback timing, and more - to fill stadiums/battlefields/streets.
• Editor Toolset: Cull volumes, crop boxes, recoloring/brightness/tint, comprehensive settings panel, debug views, custom brush textures for stylized/painterly splats, and performance presets.
• Sequencer Integration: Three playback modes: sequencer-locked, free-run preview, and hand-keyframed, with adjustable playback rate for stop-motion looks, and dynamic fps reduction for distant splats. 
• nDisplay and Compositing: Compatible with multi-computer nDisplay workflows for LED volumes. Depth of field, volumetric fog, and depth-passes for compositing are built-in. Splat’s pass through the project's OCIO color transforms identically to native geometry.

We are currently testing this implementation on an upcoming feature film shot on an LED Volume. Happy to compare notes with anyone else working in the 4DGS capture and streaming pipeline space

Still admiring Dany Bittel's experience.
Hours of focus stacking, COLMAP, masking, Postshot. Once the splats were ready, the rest was creative, not technical. Upload each insect, build a scene around it, add UI and interactions, publish one link.

It deserves more than a orbit in a viewer.

Appreciate here: https://cyango.com/explore/story/690b2b6c0b6362dfb5dd5ea8
Download: https://www.cyango.com

After months of iteration and some great feedback from community, Memo is finally on the App Store.
Memo is a 3DGS app for iPhone that handles both high-quality scanning and fully local training — no cloud, no Pro model required.

Scanning
Memo exports COLMAP-compatible data so you can train on your PC with your preferred pipeline.

Two things I focused on:
Pose accuracy. ARKit poses are convenient but not quite good enough to train on directly, so memo runs a refinement pass on them before export.
No LiDAR requirement. Instead of depending on the depth sensor, Memo uses a diffusion-based depth estimation method to generate initial priors. The results are surprisingly good and significantly speed up training. Any AR-capable iPhone works — you don’t need a Pro. (You can still switch to LiDAR in settings if you have one.)

On-device training

You can also train 3DGS entirely on-device. I spent a lot of time optimizing specifically for iPhone hardware. On the Fast preset, a scene like this trains in 45 seconds on iPhone 15 Pro. You can tweak training parameters yourself or just use the presets. Once done, you can publish the scene straight to SuperSplat with one tap, or export the scene file directly.

Fast preset training

You can also view any scene in AR in Memo

Memo AR — Splat by Dymensium

Memo app: https://apps.apple.com/us/app/memo-on-device-3dgs/id6791409163

All scenes in my SuperSplat profile were scanned, trained, and published directly from iPhone using Memo: https://superspl.at/user/frs0n

Would love to hear your feedback, suggestions, or questions. Happy to go deeper on the technical side in the comments.

octane + postshot + houdini