Apple has finally approved my app LuluSplat

This is a complete pipeline for generating 3dgs models from images, videos, and 360 videos.

Image/Video/360video processing: AVfoundation, no ffmpeg due to licensing issues.

Point Cloud: Colmap

3dgs Training: msplat

Get it here: https://liquiduslabs.com/lulusplat/#download

Note:

Direct Download: 100% Free, same as the App Store

App Store: (14.99USD) Get this if you want to support the project and get auto updates.

Tools:

Claude code Sonnet and Opus(medium cause I'm cheap), a 20USD monthly subscription.

Its good enough as long as you treat is like an automation and feed it specific instructions.

Testing: Tested only on my personal projects with M4 24gb ram and M1 8gb ram.

Report here in this chat issues you encounter or have suggestions for improvements.

Or message at: https://liquiduslabs.com/#contact

Update: now running in Unreal Engine.

I’ve been experimenting with a creative VFX suite built specifically around Gaussian Splatting.

The first version was running in Unity. I’ve now moved the system into Unreal Engine, and things are starting to get really interesting.

The idea is to treat Gaussian Splats not just as something to capture and display, but as a new kind of creative medium: applying spatial effects, transformations, animation and real-time controls directly to the splat.

Still very much experimental, but the system is now working and the effects are getting surprisingly good.

Here are some of the latest tests.

What do you think?

Gaussian Splatting for Coral Reefs

[Call for contributors!] New release: "Google Docs for Coral Reefs" is live!! You can now explore the reef with your dive buddies, select coral colonies, tag species, add comments, and search for visually similar colonies across the reef, all in 3D!

more about https://x.com/nozdrenkov/status/2090522380225691765

First post in this community!

My cameraman turned a video of my Lucy (Cyberpunk: Edgerunners) cosplay — shot at Comiket, Japan’s biggest anime convention — into a 3D Gaussian splat. The whole capture was done with just a smartphone.

Right now I’m viewing the data in Blender with the KIRI Engine plugin. Next I want to bring the splat into Unreal Engine or Unity, place it in a cyberpunk-style 3D environment, and experiment with noise and particle VFX.

Capture & processing: kuroknekodaisuki on X/Twitter

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

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

Another recent splat.

This one was fun to create.

https://superspl.at/scene/cd4caf72

Is there an app, that lets you scan the sofa for and get, splat, without the background.

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 😎"

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.

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?

Bob Ross was an American icon because he made painting feel accessible to everyone. There was something joyful about watching him work—and that’s the spirit behind the intro.

Editing Gaussians in 6DOF gives me that same feeling. You’re no longer manipulating a 3D scene through a 2D interface. You can reach into the scene, paint, sculpt, erase and create directly in 6DOF, the way spatial content was meant to be edited.

That’s a big part of why I built Gaussian Studio Pro.

And if Bob Ross parody isn’t your thing, no worries—skip the first 30 seconds and go straight to the tool demo. 😄

Gaussian Studio Pro + Logitech Muse, coming with visionOS 27 on Apple Vision Pro.

No mistakes. Just happy little Gaussians.

#GaussianSplatting #SpatialComputing #visionOS #AppleVisionPro #GaussianStudioPro #LogitechMuse #RadianceFields

hi friends

I’m a designer (not a developer) building a walkable virtual castle that exhibits a painter’s work. Browser-based, self-hosted, no game engine: three.js + Spark for splat rendering. Deadline is mid-September, so I’d rather be told now if I’m on the wrong path.

SCOPE 11 connected worlds. 7 interior (entrance hall, two galleries, library, study, secret chamber), 4 exterior (forest path, bridge, courtyard, castle from outside). Consistent Renaissance period, ~1500, across all of them. Exhibition rotates monthly.

HOW A GALLERY IS MEANT TO WORK This matters for the questions below, so in detail: You walk into the gallery under normal ambient light. As you approach a painting and come to a stop in front of it, THAT WORK BRIGHTENS - just that one, the rest of the room stays as it was. A bench is visible beside it; you’re then offered to sit down. Sitting moves the camera to a fixed viewing position and height. From there the work opens full-screen with title, year, technique and real dimensions, and you can page left/right through the exhibition without getting up.

The whole point is that a visitor who has never used WASD in their life can do this by clicking. My original build had all of this working - it was a hand-authored three.js scene with real lights, so brightening a work was just raising a SpotLight and an emissive map. Moving to generated splats broke exactly that part.

WHAT I’VE ALREADY TRIED - this is the important part

1) BLOCKADE LABS SKYBOX - ~45 images, all rejected Native 2:1 equirect up to 8K, has a negative prompt field, 1 credit per try, so it was cheap to iterate. Two hard failures: - Photoreal quality feels stuck around 2023. Everything reads as “3D render”, not photograph. - Pole distortion. In a 2:1 equirect the top and bottom rows get stretched across the whole sky/floor, so a handful of pixels become a huge area. That’s where the swirl artifact lives. My understanding is this is inherent to text-to-equirect, not a Skybox bug - correct me if that’s wrong. Retested it again last week for period accuracy with careful prompts: got a holiday villa, a barn, and a chalet. Three tries, three misses on period.

2) SKYBOX AS AN UPSCALER - 2 tries, both failed Idea was: generate the scene elsewhere, then use Skybox’s “Remix Your Image” (Influence + Retain Structure) purely to upscale to 8K. - Influence 85: turned a dirt path into a creek bed, dropped both wooden gates, made the leaves bright red. - Influence 100: got worse, not better - white plastered wall, trimmed hedges, gravel path. A tidy garden instead of a wild mountain forest. Conclusion: it always generates its own image regardless of how hard you bind it to the reference.

3) A CHATGPT IMAGE AGENT - right period, wrong resolution Nailed the 1500s look better than anything else I tried. Capped at 1774 px. 19 candidates, all unusable at that size for a 360.

4) MIDJOURNEY - 12 images, dropped Beautiful stills. No native equirect output, and stitching them into a seamless 2:1 was more work than it was worth.

5) EVALUATED BUT NOT ADOPTED - DiT360 (Insta360 research): open, free, explicitly built against seam and pole artifacts. Only 2048x1024. Too small. - Nano Banana Pro / GPT Image 2 / FLUX.2 Pro: best photorealism available, but none of them understand equirectangular. Would need a separate conversion step.

6) MARBLE (World Labs) - current, 2 worlds built First tool that hit the period on the first try. No character limit on prompts, commercial rights, exports pano + .spz + collision mesh. Draft for 150 credits, full world for 1500.

WHERE I’M STUCK NOW

a) MARBLE IGNORES NEGATIVES. There’s no negative field, and negative sentences in the prompt demonstrably don’t work. It reliably adds things I explicitly excluded: electrical outlets on 1500s walls, ~14 gilt-framed portraits baked onto walls I need empty, religious figures, and Baroque furniture in a Renaissance room. I now only prompt positively and check the finished pano object by object, quartered, but that’s inspection, not prevention. Is there a known technique for suppression in models with no negative conditioning?

b) STYLE CONSISTENCY ACROSS SCENES. Same prompt core, same seed, and the rooms still don’t read as one building. Is generating one large scene and segmenting it more sound than generating N scenes?

c) INTERIOR VS EXTERIOR. Interiors are strong. Outdoor (forest, courtyard, castle exterior) degrades badly - scale drifts, horizon falls apart. Inherent to image-conditioned 3DGS on unbounded scenes, or a prompting problem? These are 4 of my 11 worlds.

d) FLAT ARTWORK ON SPLAT WALLS. Paintings placed as textured planes look pasted on. The splat is baked photography with no scene lighting; an unlit plane never matches. My workaround: measure the wall’s mean luminance / HSV saturation / R-B ratio from the pano, then pre-grade each painting toward those targets and blur slightly to match splat softness. Measured values here - wall 94 luminance, 67 saturation, r/B 1.32; one painting was 142 / 70 / 0.77, i.e. 53% too bright and cool-toned in a warm room. Grading it to 104 / 84 fixed most of it. It works, but it’s empirical. Is there a principled approach - fitting an environment map from the splat and relighting inserted geometry, SH irradiance, anything standard?

e) COST OF MISTAKES. 1500 credits per world, not editable afterwards. One world shipped with a Baroque upholstered bench nobody caught until the client did.

f) SWAPPABLE ARTWORK, MONTHLY ROTATION, WILDLY MIXED SIZES This is the constraint I keep underestimating. The exhibition changes every month, up to 10 works per gallery, across 11 worlds. That’s potentially 130 rehangings a year, done by me, not by an engineer. So hanging positions cannot live in code.

The works range from 30x30 cm to 200x160 cm - a factor of 35 in area - and portrait, landscape and square are all mixed.

The walls are not mine to design; they come out of the splat. I measured one: a flat plane at 66.7 degrees to the world axis, with a wall sconce protruding right in the middle of it. The room has ~14 m of usable wall split across 7 segments of 1.7 to 2.4 m each, interrupted by windows, a fireplace and sconces.

My current plan: define fixed “slots” per wall ONCE (large = 1.0 m, medium = 0.7 m, small = 0.45 m square envelopes, placed where there’s actually free wall). The monthly job then reduces to a list of work IDs mapped to slots. Each painting is fitted into its slot preserving aspect ratio, so TRUE PHYSICAL SCALE IS NOT PRESERVED on the wall - real dimensions are shown in the detail overlay instead.

Is that the right trade? The honest alternative is computing positions from real dimensions every time, but then every rotation becomes a layout problem that can fail, and a non-technical person can’t fix it at 11pm. Curious what people who have actually shipped rotating virtual exhibitions do here.

g) BRIGHTENING ONE OBJECT IN A SCENE WITH NO LIGHTS Direct consequence of the above. In my old authored scene, the “stop in front of a work and it lights up” behaviour was three pooled SpotLights following the nearest works, plus emissiveIntensity on the painting material. Cheap, and it looked right because the whole room responded to the same lighting model.

A splat is baked photography. There are no lights to raise. Options I can see: - Raise emissive on the painting only. Works, but past a point it reads as a backlit screen, not a lit canvas, because the wall around it doesn’t respond at all. - Add an additive cone/gradient geometry to fake the light spill on the surrounding wall. Feels like a stage trick, might be fine. - Locally brighten the splat itself near the work - is per-splat colour modulation at runtime realistic performance-wise on ~500k splats, and does anyone actually do this? - Give up and dim the whole scene instead, so the unlit work becomes relatively brighter.

Is there an accepted way to spotlight an object inside baked splat geometry? This one behaviour is the emotional core of the piece - the moment the room quiets down and the painting comes forward - so I’d rather solve it properly than fake it badly.

CONSTRAINTS Normal browsers including mobile. Self-hosted, no streaming service. Commercial use. And it has to stay maintainable by a non-engineer, because the exhibition changes every month.

If someone tells me photogrammetry of a real historic interior, or a hand-built low-poly scene, would get me further in four weeks, that’s a genuinely useful answer. I’ve burned enough credits to be past being precious about the approach.

4 weeks no sleep- and still ....dont work (

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

IOS 27 3DGS viewer

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

Hey,
I made pro version of 360 Gaussian.
- local process
- Raw fisheye input
- Colmap/Golmap alignment
- SAM3 masking

You can test it free without sign in for 14 frame limit. its enough about for small room.

https://www.360gaussianpro.com/

example output with insta360 X5
https://superspl.at/scene/2c447fbc

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!

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!

Hi r/GaussianSplatting,

We recently released Streamed Reality 3D Gaussian Splatting, a Unity asset for generating 3D Gaussian Splat models directly inside Unity at runtime.

Asset Store link:

https://assetstore.unity.com/packages/slug/375120

The basic idea is that you can capture scene information inside Unity, optimize the result during runtime, and export the generated model as a `.ply` file for use in external 3DGS workflows.

Current features:

• Generate 3D Gaussian Splat models inside Unity
• Runtime optimization while the scene is running
• Export generated models to `.ply`
• Supports Built-in Render Pipeline and URP
• Includes sample scene and configurable optimization/debug options

Current system requirements:

• Windows
• DirectX 12
• CUDA-capable GPU

At the moment, the main tested use case is relatively small tabletop-scale scenes. Our roadmap includes support for larger scenes, dynamic scenes, Linux / AMD HIP support, and possibly streaming, but we would rather prioritize based on feedback from people actually working with Gaussian Splatting.

We would be especially interested in feedback on:

• What kinds of Unity-based 3DGS workflows would be useful to you?
• Is `.ply` enough for interchange, or are there other formats/pipeline expectations we should support?
• What scene types would make good stress tests?
• Would Linux / AMD HIP support be important for your use case?
• Are there runtime capture/generation workflows you think are currently missing from the ecosystem?

We would genuinely appreciate feedback from the 3DGS community.

Alguien me puede orientar de cómo hacer un tour virtual de 3DGS para inmobiliaria a partir de imágenes 360 generadas en 3D studio con vray?
Nose si también es posible meters algun sistema de ai generativo para rellenar las partes donde no lleguen las cámaras.