u/MayorOfMonkeys

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

The PlayCanvas Engine finally has a physics joint component. So you can now make ropes, chains, articulated vehicles and, yes, ragdolls! This little demonstration shows a poor (deactivated) robot suspended from a crossbar.

Is anything more fun than rigid body dynamics?

The new component is in the Engine of course. The next step is to expose it in the PlayCanvas Editor too.

Scanned by Daniel Dworschak (using an XGRIDS device). The capture covers three separate structures on Vyšehrad hill in a single scene - Leopoldova brána (the Baroque gate), Rotunda sv. Martina (an 11th-century Romanesque rotunda, one of the oldest buildings still standing in Prague), and Kaple Panny Marie Šancovské, the small hilltop chapel.

SuperSplat link: https://superspl.at/scene/11d081f5

It's running in the SuperSplat viewer on the PlayCanvas engine, which is doing a few things worth mentioning for a scene this size:

• High-performance WebGPU splat rendering, which is what keeps it smooth at this scale
• Over 1GB of compressed level-of-detail streaming using the Streamed SOG format, so the whole hill loads progressively rather than as one enormous download
• Automatically generated voxel collision, which is what makes it walkable in first person rather than just an orbit target

I'm a member of the SuperSplat team if you have questions on the rendering side.

The webcam tracks my head with MediaPipe's face landmarker, and the PlayCanvas Engine renders the splat (with it's shiny new high-performance WebGPU-renderer) through an off-axis projection - a frustum whose apex is my eye and whose cross-section is the screen rectangle. The screen stops being a 2D image and becomes a 3D opening. Her gun barrel is placed in front of the screen plane, so it feels like it is sticking out of the display.

I'll hopefully release this as a PlayCanvas example soon so stay tuned for that.

Splat by Dymensium.

A quiet residential street in Sopot on the Polish Baltic coast - cobbles, art nouveau townhouses, a red brick church at the end of the road. Captured as a 3D Gaussian splat by Iris Digital and published to SuperSplat.

The interesting thing is that Iris published this splat without streamed LOD enabled. And this scene is 18 million Gaussians. But thanks to PlayCanvas' high performance WebGPU renderer, it can handle the load very well.

Walk it yourself: https://superspl.at/scene/7337b0e4

Not my capture - but happy to answer questions about the streaming/rendering side if anyone's curious (I'm on the SuperSplat team!).

An abandoned textile factory in Krásná Lípa, Czech Republic - captured as a 3D Gaussian splat by Daniel Dworschak.

This scene is around 600MB, but it starts rendering within a couple of seconds. The viewer streams splat data progressively and refines as you move, rather than blocking on the full download - so a gigabyte-scale capture is genuinely usable on a web page (even on mobile). Rendering is handled by the PlayCanvas engine (WebGPU with WebGL2 fallback).

Empty mill floors, cast-iron columns, peeling plaster and grid windows — the kind of space that's a pain to photograph well and works beautifully as a splat.

Explore it in your browser: https://superspl.at/scene/dc84c1da

Not my capture - but happy to talk about the streaming/rendering SuperSplat side if anyone's curious (that's what I work on).

A bird hatchling captured as a 3D Gaussian splat - impressive work by the world's foremost macro-splat creator Dany Bittel (https://danybittel.ch/).

The capture: 139 perspectives, 55 focus-stacked images each - 7,645 photographs in total. Shot on a Nikon Z8 (full frame) with a Nikkor 105mm macro, f/6.3, 1/50s, ISO 100, lit with a single LED and a green chroma key.

The focus stacking is what makes it work: at 105mm macro the depth of field is paper-thin, so each of the 139 viewpoints has to be stacked into one fully-sharp frame before training. You can see the payoff in the pin feathers and the translucency of the skin.

Hosted on SuperSplat, runs in the browser: https://superspl.at/scene/568b68ed

Not my capture - I work on SuperSplat so I was excited to share this fantastic splat with the community!

This was built using Claude Fable 5, the PlayCanvas Engine and MediaPipe.

Hand tracking is used to determine when you are activating the visor.

Head tracking is use to position the visor.

Should run in any browser.

TRY IT: https://playcanvas.github.io/web-components/examples/#ar-optic-blast.html

A walk up the Calico Tanks Trail in Red Rock Canyon, Nevada - captured as a 3D Gaussian splat and running in the browser.

Scanned by Paolo Tosolini with an XGRIDS PortalCam, hosted on SuperSplat.

What I find impressive here: the scene is 410MB, but it loads in a few seconds and holds a steady framerate - the viewer streams the splat data progressively (using the Streamed SOG format) rather than waiting on the whole file. Rendering is handled by the PlayCanvas engine (which has a high-performance WebGPU-based renderer).

Explore it yourself: https://superspl.at/scene/19312f07

Live demo (WebGL 2 and WebGPU, switchable in the panel): https://engine-a1lytf69q-playcanvas.vercel.app/#/animation/vat-characters

We just added a vertex animation texture (VAT) implementation to the PlayCanvas engine as a reusable script plus an example. The idea isn't new — it's been used in games for years — but I hadn't seen a complete, copy-pasteable web implementation with an authoring path, so here's one.

How it works

Instead of animating a skeleton per character, every vertex's skinned position and normal is evaluated offline for each sampled frame and baked into a texture. At runtime the vertex shader reads two neighbouring frames and interpolates. Skeletons, bone matrices and per-character animation evaluation disappear entirely.

What's left per character is a world matrix and a fractional frame index — 52 bytes — so the whole crowd is one instanced draw call.

Some details that turned out to matter

• One texel per vertex per frame in RGBA16U: position quantised to 16 bits per axis over the animation's bounds in xyz, octahedral normal packed into w. One fetch gives you a whole vertex.
• Quantising over the bounds is actually more accurate than fp16 where it counts. Near the top of a character fp16 has a step of ~1.8 mm at human scale; 16-bit quantised is ~28 µm. fp16 wastes its mantissa near the origin, which for a character standing at y=0 is between its feet.
• Texels are addressed by a flat vertex * frameCount + frame index wrapped at the texture width, rather than one vertex per row. Otherwise your vertex count is capped by texture height (4096). Flattened, the limit is total texels, so ~218k vertices at 77 frames.
• The vertex row comes from gl_VertexID / @builtin(vertex_index), so no extra per-vertex attribute is needed at all.

Authoring

The converter runs in the browser — there's a "Convert GLB" panel in the demo, so you can drop in your own skinned glb and watch it become a crowd without installing anything. Output is a single glb-style binary container. Like a glb it's stored uncompressed and leaves compression to the transport; brotli over the raw payload beats gzip baked into the file by about 40%.

Where it's a bad idea

Worth being clear, because it's a real trade:

• Your character must be a single skinned mesh with one material.
• Every animation is assumed to loop.
• No blending, no IK, no procedural aiming — it's a fixed table of vertex positions. Terrible for a hero character, great for the 500 NPCs behind them.
• One mesh instance means no per-character frustum culling.
• Only the base colour texture comes across; no normal/roughness maps.

Numbers

At 10,000 characters (~31M vertices/frame): 6 draw calls for the whole scene, 2.1 ms CPU. The VAT texture is 1.8 MiB and is independent of the character count — one character and ten thousand share it.

Happy to answer questions about the format or the shader side.

Two days ago, the Grace Cathedral browser experience was launched.

This was a joint collaboration between Vincent Woo and PlayCanvas. Vincent scanned the location in exquisite detail and Donovan Hutchence from the PlayCanvas team built the browser app.

This represents 3 years of technology development by PlayCanvas:

• Streamed SOG with LOD
• High performance WebGPU-powered splat renderer
• Custom shader system

...and much more. The best part? It's all free and open source.

We wanted to follow up the launch with a write up explaining how the app was built:

https://blog.playcanvas.com/building-the-grace-cathedral-experience

Let us know what bits you liked best...and what we missed that we could have added! And if you have any further questions about the 'how' of the experience, just ask.

Scene by Architectural Visualisation Studio (https://www.nbv.studio/) - an experiment converting their Unreal Engine archviz project into a 3D Gaussian Splat, including voxel-based collision generation so the result is a walkable 3D environment, not just an orbit-around scene.

A couple of things I think are neat here:

• Taking a full UE architectural scene and baking it down to a splat that's light enough to stream straight to a web page - no install, no heavy download.
• The voxel collision is auto-generated from the splat, so you can actually move through the space in the browser.

Hosted on SuperSplat and rendered with PlayCanvas using WebGPU.

Explore it live here: https://superspl.at/scene/b7c8d8c5

Last year I had the idea to scan San Francisco's famous Grace Cathedral in very high quality, both inside and out, and build an interactive experience that anyone can use. It's all on the web and anyone can try it out right now: https://vincentwoo.com/3d/grace_cathedral

Also a ton of credit to Donovan Hutchence of PlayCanvas, who built out the entire frontend web experience! Lots of beautiful flourishes, like the cars, the glowing outlines of the peek cutouts, and the thoughtful orbit tracking are all his own designs! True love of the game.

I’ve opened a PR adding volumetric fog to the PlayCanvas Engine’s CameraFrame pipeline.

The effect raymarches exponential height fog at reduced resolution, with directional-light shadows producing visible light shafts—or “god rays.” A depth-aware upsample prevents fog from leaking across geometry edges.

It also supports:

• WebGL2 and WebGPU
• Cascaded shadow maps, including PCF, PCSS and VSM
• Temporal smoothing through TAA
• Bloom contribution from bright light shafts
• Adjustable density, height falloff, anisotropy, distance, quality and resolution

The default configuration renders at half resolution with 24 raymarching steps, keeping the effect practical for real-time scenes.

There are still a couple of limitations: it currently supports perspective cameras only, and transparent objects use the opaque scene depth for fogging.

🎮 Try the interactive demo
🎥 Watch the video
🛠️ View the implementation and PR

I’d love to hear how it performs on your hardware and what controls or features you’d find useful.

This is "Collectables Cafe," an antiques shop in Fish Hoek, Cape Town, captured as a Gaussian splat. You can walk through it yourself here: https://superspl.at/scene/e4bfb4b5

Some details on the tech under the hood:

• Runs in the PlayCanvas Engine using WebGPU.
• The scene streams in dynamically using a supercompressed Streamed SOG (SSOG) format, so it starts fast and fills in detail as you explore.
• It has highly accurate voxel-based collision, so you can freely walk around and explore every corner of the store from a first-person viewport instead of just orbiting it. Throughout the video I toggle the collision voxels on and off so you can see how the collision geometry is actually structured behind the visuals.

Scan made by Splatt3D (EK Haussmann) - presumably with an XGRIDS PortalCam.

SuperSplat, your free and open source platform for 3D Gaussian splatting, just got another big upgrade!

What shipped today:

One-click starter projects for vibe coding. For any downloadable splat, you can now grab a complete, ready-to-run PlayCanvas + Vite + TypeScript project with the splat baked in and the camera pose preserved. It's deliberately minimal and fully typed, so it's an easy base to build on (or hand to an AI coding assistant). Here's one we made — an interactive snow globe from a single splat by Mykhailo Moroz: live app · source

SPZ export. You can now export scenes to Niantic's SPZ format — roughly 10x smaller than the equivalent PLY with no visible quality loss — so scenes move cleanly into Scaniverse and other SPZ-compatible tools.

360° video + image export. Render a scene straight to equirectangular 360° video (and 360° stills; image export is now WebP). Put the video on YouTube and you can look around it in a headset. Example: https://www.youtube.com/watch?v=6oGjT8eubMc

splat-transform 3.0. The big one under the hood. Our open-source CLI/library got a ground-up streaming rewrite: resident memory is now bounded by chunk size rather than scene size, so you can process 100M+ Gaussian scenes on a normal machine. On a representative job it's ~7x faster at ~1/5 the peak memory vs the 2.x line. New source-based API (readFile → ChunkSource, processSource/writeSource), needs Node 22+, and there are some breaking API/CLI changes. Release notes: https://github.com/playcanvas/splat-transform/releases/tag/v3.0.0

Full write-up with demos: https://blog.playcanvas.com/new-in-supersplat-vibe-code-splat-apps/

Everything (SuperSplat, splat-transform, the PlayCanvas engine and viewer) is MIT-licensed and on GitHub. Happy to answer questions or take feedback here — and if splat-transform 3.0 chokes on any of your scenes, I'd genuinely like to hear about it.

Found this super-cool splat on SuperSplat today by Spike Jackson:

https://superspl.at/scene/fe883e6a

There are several other examples of this on SuperSplat:

https://superspl.at/scene/992479a1
https://superspl.at/scene/cdb8bc00
https://superspl.at/scene/29f9b77d

But this one's the best so far IMHO. Can you make a better one?

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