u/MayorOfMonkeys

I'm adding support for world rotation/scaling to the PlayCanvas Engine. But I wan't quite expecting this!

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!)

Here is a preview of an upcoming feature in the free and open source SuperSplat Editor: collision/proxy mesh generation! It uses splat-transform under the hood to generate the mesh and you can visualize the mesh in the viewport to get it 'just right'. You can then export the mesh to the glTF GLB format.

What do you think?

St. Stephan's Church in Bamberg, Germany — over 1,000 years old, with a Baroque interior dating to the 17th century.

Captured as a 3D Gaussian splat by majomedia. It's ~173 MB of SOG and runs free-roam right in the browser — you can wander the whole nave, choir and side altars:
https://superspl.at/scene/bc0984bf

The detail holds up really well, especially the light on the stucco and the gilded carvings.

Disclosure: I work on SuperSplat, the free Gaussian splatting platform from PlayCanvas. The capture itself is majomedia's, not mine — full credit to them.

Curious what people think of the quality. I suspect it's a PortalCam scan!

Back in August 2011, Evan Wallace (who later co-founded Figma and wrote esbuild) released WebGL Water - the raytraced pool with real-time caustics that pretty much every web-graphics enthusiast remembers. ~15 years on, I figured it deserved a WebGPU version, so I ported the whole thing.

Live demo (WebGPU, falls back to WebGL2): https://willeastcott.github.io/webgpu-water-playcanvas/

Source: https://github.com/willeastcott/webgpu-water-playcanvas

The 2011 original: https://madebyevan.com/webgl-water/

The bit that's interesting for this sub: rather than transpiling GLSL → WGSL at runtime, every shader is authored in both languages side by side (LLMs are great and managing both versions and keeping them in sync). On WebGPU it runs native WGSL - no transpiler, no WASM - and still falls back to WebGL2 with the original GLSL.

It's a faithful port of the original rendering + sim:

• GPU heightfield water sim on ping-pong float render targets (RGBA32F, half-float fallback)
• Real-time caustics via the differential-area method (the projected-mesh trick from Evan's writeup)
• Raytraced reflection + refraction off the pool and a draggable, buoyant sphere
• Analytic ambient occlusion, soft blob shadow, sky cubemap
• Built on the PlayCanvas engine (just the npm package - standalone Vite app)

I also added scroll-to-zoom and made click-drag paint a continuous ripple trail instead of a row of separate drops.

Disclosure: I work on PlayCanvas. This is just a fun open-source port, though - all the original genius is Evan's.

PlayCanvas is a free, open-source (MIT) real-time 3D engine that runs in the browser on both WebGL2 and WebGPU. We just shipped 2.20 — here's what's new.

Gaussian Splatting (the big one this release):

• Real-time relighting of splats
• Soft shadows
• Depth of field
• Clipping planes
• Billions of splats via streaming + LOD
• Shader effects (dissolve, rings)
• Gaussian Splatting in VR (with LOD)

WebXR on WebGPU 👇
WebXR (VR/AR) now runs on the WebGPU backend — not just WebGL2. So you can build immersive experiences on the modern graphics API, including the new Gaussian Splatting features in VR. That combo is still pretty rare in the wild — most WebXR today is WebGL-only.

Also new:

• Procedural sky
• Clustered light cookies
• Physics: joints + ragdolls
• Draco mesh decoding in Node (via worker_threads)

Links:

• Release notes: https://github.com/playcanvas/engine/releases/tag/v2.20.0
• Try every example live in your browser: https://playcanvas.com/examples
• Repo: https://github.com/playcanvas/engine
• npm install playcanvas

Quick montage of the new examples attached — happy to answer anything about what we're releasing today!

We just shipped two big upgrades to SuperSplat, your free and open-source platform for 3DGS. Sharing the technical details here since I think this crowd cares about the how, not just the what.

1. A compute-based WebGPU renderer

Instead of sorting splats on a CPU worker thread, the new renderer moves the heavy lifting onto compute shaders:

• cull invisible splats
• project the rest
• sort them with a fast GPU radix sort

Final rasterization still uses vertex/fragment shaders, but they're now lightweight — drawing from pre-projected data.

Measured against our existing WebGL 2 renderer:

• Desktop (M4 Max): up to ~5.7× faster at high splat counts
• Mobile (iPhone 13 Pro Max): ~2× faster

WebGPU is at ~85% of users (per caniuse). Everyone else automatically falls back to the WebGL 2 renderer, and both paths render identically. It ships in PlayCanvas Engine 2.19.0.

2. Automatic Streamed SOG (streamed LODs)

Every upload is now automatically processed into a streamed format. It's an extension of our compressed SOG (Spatially Ordered Gaussians) format, generated by our open-source splat-transform tool:

• it decimates the scene several times to build high-quality LODs
• then chunks those LODs into small, streamable pieces

The viewer downloads the lowest LODs first to get a stable, complete image almost instantly, then progressively refines by streaming higher LODs up to a per-device Gaussian budget (generous on desktop, leaner on mobile).

The payoff is near-instant load times and high frame rates even on older hardware. The demo scene below is a 24M-Gaussian scan — its top LOD is far more than a phone could hold in memory at once, yet it loads fast and stays smooth.

Try it / read more

• Walkable demo scene (a gorgeous scan of Lokwelt Freilassing by Guy Middleton): https://superspl.at/scene/71a8c8aa
• Full write-up with benchmark graphs: https://blog.playcanvas.com/new-in-supersplat-webgpu-and-streaming-bring-huge-performance-wins

Everything — SuperSplat, splat-transform, the PlayCanvas Engine — is MIT licensed:

• Engine: https://github.com/playcanvas/engine
• SuperSplat Editor: https://github.com/playcanvas/supersplat
• SuperSplat Viewer: https://github.com/playcanvas/supersplat-viewer
• splat-transform: https://github.com/playcanvas/splat-transform

Happy to answer questions about the renderer architecture, the LOD/streaming pipeline, or the SOG format. Feedback very welcome.

I wondered what it would feel like to find my way into The Backrooms.

So I took a movie still from Google Image Search and uploaded it to SpAItial AI's Echo-2. After about 5 minutes, it had generated a 3D Gaussian splat that I could download as a PLY file. I then uploaded the PLY to SuperSplat:

https://superspl.at/scene/55e5dcc3

Opus 4.8 is insanely good at vibe coding games using the PlayCanvas Engine. This was made conversationally over an hour. I didn't look at the code once. Every request carried out perfectly. Game size: 280KB.

Play Now: https://mini-soccer-game.netlify.app/

(I even casually asked Opus to apply a verlet solver to makes the goal nets physical!)

Come join the PlayCanvas Discord: https://discord.gg/RSaMRzg

I wanted to see if you could connect two Gaussian Splat scenes through a portal you can physically walk through — no teleport, no cut, just continuous motion between two captured environments. Turns out it works pretty cleanly.

Runs entirely in the browser (WebGL2 / WebGPU), built in PlayCanvas.

Try it live: https://engine-8q342hfzj-playcanvas.vercel.app/#/gaussian-splatting/splat-portal

A few things I liked about how it came together:

• Two LOD-streamed splat scenes (a Roman parish + a skatepark), seen through a stone archway acting as the portal.
• Crossing the portal plane swaps which world you're "in" — and the same physics works symmetrically from either side, so you can walk back the way you came.
• The world you're in stays fully visible around you; the other one only shows inside the portal opening, with a proper "window" feel (no peek-around clipping).
• Subtle translucent glass inside the opening picks up specular highlights from the environment.
• The skatepark side has its own weather — procedural snow that's only visible while you're actually there (or peeking through).

Source for the example (PlayCanvas engine repo): https://github.com/playcanvas/engine/pull/8738

I just landed two new examples in the PlayCanvas engine that let you walk around *inside* a real Gaussian Splat scan — both first-person and third-person, with proper collision against the scene.

### Try them yourself

- 🚶 First-person walk: https://engine-cmbu8r47z-playcanvas.vercel.app/#/gaussian-splatting/first-person

- 🕺 Third-person with animated character (press **Q** to dance): https://engine-cmbu8r47z-playcanvas.vercel.app/#/gaussian-splatting/third-person

Controls: **WASD** to move, **Shift** to sprint, **Space** to jump, **Mouse** to look / orbit, **Scroll wheel** to zoom (third-person only).

### What's in it

- A new reusable **third-person camera controller** (`scripts/esm/third-person-controller.mjs`) modelled after the existing FPS controller. Handles:

- Orbit camera with mouse + gamepad + touch

- Wall-collision avoidance via raycast, smoothed so it doesn't pop

- Scroll-wheel zoom (smoothed, clamped)

- Configurable initial pitch, min height above character, look invert, sensitivity, damping for every axis

- Fires `speed` (0/1/2 → idle/walk/jog) and `jump` events that consumers wire into an anim state graph — no coupling to the anim system

- First-person example: capsule character + `FirstPersonController`, jumps, sprints, walks the gsplat

- Third-person example: bitmoji character, full anim state machine (idle / walk / jog / jump / dance) driven by the controller events, env-atlas IBL ambient (skybox layer disabled so the splat is the visible background), shadow catcher that follows the character on the ground via a downward raycast

### How the collision works

The "ground" is the Gaussian Splat (visual only), and physics happens against a hidden mesh GLB loaded alongside it:

- The collision mesh was **generated directly from the splat** using **splat-transform**.

- Then simplified down to **~1 MB** with https://polyforge.xyz/optimize so Ammo's BVH builder can handle it (huge meshes will OOM the WASM heap).

### Credits

Huge thanks to **zeitgeistarchivescans** for the gorgeous *Sunnyvale Heritage Park Museum* scan (CC BY 4.0):

https://superspl.at/scene/d5d397aa

### Source / PR

https://github.com/playcanvas/engine/pull/8736

Hi everyone! Three big SuperSplat upgrades shipped today! 🚀

🧱 One-Click Collision Generation
We've wired the SplatTransform 2.0 collision pipeline directly into SuperSplat Studio's backend. Open your splat, head to the Assets panel and hit Generate. Pick from Indoor, Outdoor or Object presets and Studio takes care of the rest. Walk-ready splats in seconds, no command line required.

🛠️ Software Attribution
You can now tag your splats with the software you used to make them, choosing from a curated catalog including Brush, Postshot, LichtFeld Studio, RealityScan, KIRI Engine, Luma, Polycam and more. Click any logo chip on a scene page to discover other splats made with the same tool - a great way to find new creators and learn techniques.

📊 GPU-Powered Histogram
The SuperSplat Editor's Data Panel just got faster and smarter. The histogram is now GPU-driven, computing per-property statistics across millions of Gaussians in milliseconds, even on modest hardware. You can also drag a range directly on the histogram to select splats by position, color, scale, depth, opacity, surface area, orientation and more - isolating the splats you care about with a single drag instead of nudging sliders.

Try SuperSplat → https://superspl.at/
Read the full announcement → https://blog.playcanvas.com/new-in-supersplat-software-attribution-collision-generation-and-histogram/
Join the SuperSplat community on Discord → https://discord.gg/RSaMRzg

Thanks to the awesome Stéphane Agullo for the splat used in the video!

Videogame technology is starting to disrupt real estate 🏡

The workflow is getting surprisingly simple:

📷 Scan a house (LiDAR scanners in particular make this a smooth experience)
🪄 Train a 3D Gaussian Splat
🌐 Publish it to the web with PlayCanvas / SuperSplat

Instead of clicking through static photos or watching a fixed video tour, buyers can explore a property like a videogame level - directly in the browser.

Here’s the house from the video by Camera Cone on SuperSplat:

https://superspl.at/scene/91c1e47e

What do you think: will splat-based property walkthroughs enter the mainstream this year?

PlayCanvas just released SplatTransform 2.0!

For anyone working with 3D Gaussian Splats, SplatTransform is an open source CLI tool and library for processing splats.

The big new feature in 2.0 is fully automated, fast generation of high-quality collision for splats. It outputs collision in two formats:

🧊 Voxel format
🔼 Mesh format

This should be useful for anyone experimenting with splat-based games, interactive scenes, or navigable splat-based environments at scale.

Release notes:
https://github.com/playcanvas/splat-transform/releases/tag/v2.0.0

Example splat used in the video, with thanks to Paolo Tosolini:
https://superspl.at/scene/b0703bc1

Would love to hear your feedback - what does this unlock for you?

PlayCanvas v2.18.0 is officially live, and we’re pushing Gaussian Splatting into the WebGPU era. 🚀

• ⚡️ WebGPU Compute Splatting: We’ve launched a prototype Compute-based renderer for splats. This is the future of performance - up to 3x faster than our WebGL2 renderer depending on hardware.
• 🌦️ Splat-Based Weather: You can now generate procedural weather effects (rain, snow, etc.) using splats. It’s an incredibly lightweight way to add heavy atmosphere to your scenes.
• 🌫️ Volumetric Fog: Splats now natively respect engine fog - everything composites together perfectly.
• 👁️ Fish-eye Projection: New support for fish-eye camera projections for 3DGS - turn your splats into tiny planets!

PlayCanvas is free and open source. If you’re building for the web, this is for you.

GitHub Release & Source: 🔗https://github.com/playcanvas/engine/releases/tag/v2.18.0

I'm part of the team - if you have questions about the WebGPU implementation or the new weather effects, drop them below! 👾

SuperSplat is evolving - it's now a hub for the Gaussian Splatting community. 🚀

We just dropped a major update to help you share your work and get the credit you deserve. Here’s the rundown:

• 📥 Downloadable Splats: Owners can now toggle a "Downloadable" flag on their scenes. Make your raw data available to the community with one click.
• 📜 CC Licenses & Easy Attribution: Assign any of the six Creative Commons 4.0 licenses to your splats. The download dialog now includes a ready-to-copy credit line to make attribution effortless.
• 🔗 Social Profiles: Link your Website, X, LinkedIn, and YouTube to your user page. Turn your published splats into a professional 3D portfolio.

Whether you're using these for research, creative tools, or dropping them into the PlayCanvas Engine, it's now easier than ever to move your data where you need it.

SuperSplat is free and open source.

Check it out: 👉 https://superspl.at/?features=downloadable&time=all

Full breakdown on the blog: 🔗https://blog.playcanvas.com/new-in-supersplat-downloadable-splats-licenses-and-social-links/

Join the Discord to meet other splat creators: https://discord.com/invite/qcydPEtn65

I’m part of the team, so if you have any feedback or feature requests, let’s chat in the comments! 👾