⚡ The Editor, Rebuilt on WebGPU​

Back in June, the SuperSplat Viewer got a compute-based WebGPU renderer and a big jump in frame rate. SuperSplat 3.0 brings that same philosophy to the editor and goes a lot further. It's a ground-up rewrite of both the renderer and the editor's data model, and the editor is now WebGPU only:

• Projection, frustum culling, compaction, depth sorting and draw submission for every Gaussian in the scene run on the GPU every frame — a compute projector, a GPU radix sort and indirect drawing. The CPU sort worker is gone.
• Splat data lives in chunked GPU storage, with a small per-Gaussian instance list holding the editable state. The editor no longer keeps full copies of the scene in JavaScript.
• Histograms, range selection, color matching, bounds and every selection pass run as GPU compute, so the tools keep up with scenes of any size.
• Exports are streamed chunk by chunk through splat-transform, so PLY, compressed PLY, SOG, SPZ, .ssproj and Publish no longer materialize the whole scene before writing.

The payoff is a dramatic drop in memory use. Here's peak JavaScript heap on a 4.4 million splat scene (a 990 MB PLY), 2.x against 3.0:

Scenes that used to exhaust the browser now load and edit comfortably. And because the whole scene is projected and sorted as one on the GPU, you can drop one capture into another and work on them together:

🎲 Stochastic Alpha: Responsive at Any Scale​

Sorting tens of millions of Gaussians every frame is the expensive part of rendering a splat. With 3.0, you don't have to pay for it while you're interacting. The new Stochastic Alpha mode renders Gaussians opaque and depth-tested with per-fragment coverage — a sort-free, order-independent technique — so orbiting, flying and editing stay fluid no matter how heavy the scene. The moment the scene settles, a fully sorted, blended frame is drawn, so what you see at rest is exact.

You'll find it under Preferences > Rendering > Stochastic Alpha, with four options: Disabled, Enabled, Movement and the new default, Auto. In Auto, the editor keeps rendering fully sorted frames until a sorted frame proves slow on your GPU. Only then does it switch to stochastic rendering during movement, and it drops straight back to sorted rendering when the view gets lighter again. Light scenes never see a difference. Heavy scenes stay responsive. Rings mode works in stochastic frames too.

Here it is on a botanical garden scan of around 20 million Gaussians:

🖌️ Sphere Brush Selection​

Selecting the parts of a scene you care about is most of the work of editing a splat, so 3.0 adds a new tool for it. The Sphere Brush (Shift+B) lets you paint a selection directly onto surfaces in 3D. Every point of your stroke is depth-picked to a world position, forming a path that Gaussians are tested against on the GPU. The brush radius maps to a real-world size at the surface you're painting, and strokes split automatically across depth discontinuities — so the brush follows the surface rather than selecting straight through the scene. You get the object you painted, not everything behind it.

Brush size is shared with the 2D brush ([ and ], or Alt + mouse wheel) and the usual add, remove and intersect modifiers apply. The rest of selection has been redesigned around it. The old surface/through toggle is replaced by two independent switches on the bottom toolbar: Selection Depth (N) picks only splats on the visible surface, and Selection Footprint (M) tests whole Gaussian footprints instead of centers. Every 2D and 3D selection tool honors both, and footprint selection runs on a GPU intersect pass. Zero-alpha splats are now selectable too. Lasso and polygon, and flood and eyedropper, are grouped into press-and-hold buttons that remember the last tool you used, with refreshed icons for the brush, box and sphere tools.

🎨 Color Adjustments on Selections​

Color grading has moved home. The Colors section now lives in the Scene Manager on the left, right under Transform, because that's where the rest of your current splat's state is. More importantly, color edits now apply to your selection — not just the whole scene. Select the part you want to change, adjust Tint, Temperature, Saturation, Brightness, Black Point, White Point or Transparency, and watch the result preview live in the viewport. When you're happy, hit Apply to bake it in, or Reset to start over. With nothing selected, the grade applies to the whole splat as before.

👁️ The New Appearance Panel​

How you see a splat while editing it matters as much as how you edit it. The new Appearance panel in the right toolbar puts all of that in one place. Under Display, toggle Gaussians, Centers and Rings on and off, set the center size and ring thickness, and choose how strongly unselected and selected Gaussians are tinted on each surface. Under Selection, pick the selection color and choose whether selected Gaussians show centers, rings and an outline. Every option has a help tooltip with its shortcut.

One behavior change to know about: display overlays are now off by default, so a freshly loaded scene shows the real render. Press Tab to toggle every overlay on and off without touching your settings, or turn on any Display toggle to bring them back. This replaces the old Centers/Rings mode switch and the Show/Hide Splats button.

Viewport state has a new home too. The eye button in the right toolbar opens Overlays — grid and planes, bounding box and dimensions, camera poses, camera info and a Frame Timings diagnostic that graphs live GPU frame time with min, median and p95 over the last second. That leaves Preferences (formerly Settings) for what it should be: application preferences.

🧰 And More​

3.0 is a big release and there's plenty more in it:

• A reworked grid. Each grid plane (XZ, XY and YZ) can be toggled independently and the choice is saved with your preferences and your document. Grid levels adapt to the view — large scenes get 100 m and 1000 m lines, close-ups never flood with sub-pixel ones — and analytic antialiasing removes the horizon artifacts and the dither where the grid crossed splats.
• A faster orient tool. Points are now picked on the GPU, like the measure tool. On a 2.4 million Gaussian scene a click dropped from about 8.5 seconds of frozen UI to under 25 ms. F now frames the active sphere, box, measure or orient tool.
• Logarithmic histogram controls in the data panel — separate Log Counts and Log Bins with signed logarithmic binning and accurate raw-value labels.
• Faster camera pose imports from JSON and COLMAP, batched so the spline and timeline rebuild once.
• Orthographic rendering and depth picking are now correct when the camera is inside the scene bounds.
• An installable app that opens your files. The manifest registers file handlers for .ply, .splat, .sog, .spz, .ksplat and .ssproj.
• A complete keyboard shortcuts popup, a refreshed set of toolbar icons and a long list of stability fixes across selection, drag tools, the data panel and publishing.
• Built on PlayCanvas Engine 2.22.0 and splat-transform 3.3.3.

The full list is in the 3.0.0 release notes.

💚 Free and Open Source​

SuperSplat and the PlayCanvas Engine are free and open source under the MIT license. We believe the best tools for 3D on the web should be accessible to everyone — and the best way to make them better is together. Report an issue, open a pull request or just star the repo to show your support. ⭐

• SuperSplat Editor
• SuperSplat Viewer
• PlayCanvas Engine
• SplatTransform

New to Gaussian splatting on PlayCanvas? Our Gaussian Splatting documentation is the best place to get started, and the SuperSplat user guide covers every tool in the editor.

👂 We Want to Hear from You​

Open superspl.at/editor, drop in your heaviest scene and tell us how it feels. What should 3.1 bring? Come and find us on the PlayCanvas Discord or ping us on X — it's where the world's best splat creators hang out and we'd love to have you there.

See you in there!

Teleport by VarjoXGRIDS LCC StudioLichtFeld Studio

🔌 The Publishing API​

Until now, getting a splat onto SuperSplat meant exporting a file from whatever tool you trained it in, then uploading it by hand. For a large scene that's a multi-gigabyte round trip — and it's the least interesting part of anyone's workflow.

The SuperSplat API removes that step entirely. It's a REST API that lets an application publish a splat directly to superspl.at on behalf of a signed-in user, and inspect the scenes they already own. A few things worth knowing:

• Authentication uses a PlayCanvas access token, sent as a bearer token. Users generate one from the API Tokens section of their account page and paste it into the integration once. Some apps label the field "API key" or "API token" — it's the same thing.
• Uploads are resumable. The API uses multipart uploads — a client opens a session, requests signed URLs for each part, pushes those parts straight to storage and then completes the upload. A dropped connection halfway through a 2 GB scene is no longer fatal.
• Scenes arrive unlisted by default, so nothing goes public until the creator decides it should.
• Metadata comes along for the ride — title, description and the softwareTools field that records which tools made the scene. Integrations can identify themselves separately through the optional uploadClient field.

It's all documented in the new API & Integrations guide, with complete endpoint and schema detail in the SuperSplat API reference.

Now for the fun part — three tools that already use it.

🥽 Teleport by Varjo​

Teleport is Varjo's 3D reconstruction platform. It takes phone images, 360 video or up to 10,000 drone images, and trains georeferenced Gaussian splats up to 100 million splats. It's API-first, so teams wire it into their own pipelines. Finished scenes publish directly to SuperSplat.

You connect the integration once, under Settings → Integrations: paste in your access token and hit Save. From then on, every capture gets a Publish capture option — pick SuperSplat as the destination, give the scene a title and description, and hit publish.

And here's what Teleport manages with nothing but an iPhone. This is Turun Ekotori, a large second-hand and recycling center in Turku, Finland — captured with the Teleport iOS app and published straight to SuperSplat:

Browse everything the community is making with it in the Teleport by Varjo collection.

📡 XGRIDS LCC Studio​

XGRIDS builds handheld lidar scanners, and Lixel CyberColor Studio — LCC Studio — is the desktop software that turns those scans into splats. Publishing is now built right in.

Open My Models, pick a model and publish it to SuperSplat. Paste your access token, choose a format and hit Share. LCC2 (SOG) is the recommended option, which hands you SuperSplat's compressed streaming format straight out of the box. When the upload finishes, a dialog gives you the live viewer link.

See what LCC Studio users are publishing in the LCC Studio collection.

💡 LichtFeld Studio​

LichtFeld Studio is a fast, open source Gaussian splat trainer — and this integration is one we built ourselves. The SuperSplat plugin for LichtFeld Studio is developed and maintained by the PlayCanvas team, MIT licensed and open source like everything else we ship.

The plugin adds a SuperSplat tab alongside Rendering and Training. Sign in once — your credentials are stored securely — then pick which splats to upload, set a title and description and hit Upload to SuperSplat. It exports to PLY or SOG, reports live progress and resumes if the connection drops.

Have a look at the LichtFeld Studio collection to see what it's producing. And because we wrote it, the plugin doubles as the reference implementation of the API — if you're building your own integration, that repo is the fastest way to see the entire flow working end to end.

🤝 Why Build a SuperSplat Integration?​

If you make a capture app, a scanner, a trainer or a reconstruction pipeline, here's the case for wiring SuperSplat publishing into it.

• You don't have to build a viewer. Your users get a hosted, production-grade WebGPU splat renderer with shareable links and embeds. No renderer to write, no bandwidth to serve, no mobile GPU matrix to chase.
• You get a gallery that fills itself. Every scene published through your integration carries your tool in its softwareTools metadata, which puts your logo chip on the scene page and files the scene into your own collection. Our launch partners already have collections filling up — Teleport by Varjo, LCC Studio and LichtFeld Studio — and those pages grow every time one of your users hits publish.
• Permanent attribution in front of exactly the right audience. That logo chip is a clickable credit on every scene your users share, seen by the people already out looking for splat tools. See Software Attribution for how it works.
• You finish your users' workflow instead of dead-ending it. Capture, train, publish, share. Nobody has to export a multi-gigabyte PLY and re-upload it by hand.
• Your output inherits everything SuperSplat can do. SOG compression, streamed LOD, walk mode, Studio editing, 360° video and one-click starter projects all apply to scenes that arrive through the API.
• The integration itself is small. A REST API, a bearer token and a resumable upload — with our LichtFeld Studio plugin as a complete working example to crib from.

Start with the API & Integrations guide. And if you're building an integration, come and tell us about it on Discord — we'll help you get it shipped.

💚 Free and Open Source​

SuperSplat, SplatTransform and the PlayCanvas Engine are all free and open source under the MIT license. We believe the best tools for 3D on the web should be accessible to everyone.

If you're building a splat-based application, we'd love for you to build it on PlayCanvas. Check out our repos on GitHub:

• PlayCanvas Engine
• SuperSplat Editor
• SuperSplat Viewer
• SplatTransform

New to Gaussian splatting on PlayCanvas? Our Gaussian Splatting documentation is the best place to get started.

👂 We Want to Hear from You​

What do you think of the new features? What would you like to see next? Come and join us on the PlayCanvas Discord — it's where the world's best splat creators hang out and we'd love to have you there.

See you in there!

After seeing Vincent Woo's high-quality capture of the cathedral and its surrounding streets as 3D Gaussian splats, we jumped at the chance to collaborate with him. Together, we turned his splats into a browser-based, interactive experience. You can see the finished app below:

This article explores how I built this app. Let's dive in.

Under the Hood​

The PlayCanvas Engine was the perfect runtime on which to build, thanks to its WebGPU hybrid renderer and streamed SOG format.

WebGPU Hybrid Renderer​

The exterior view renders around 3.5 million Gaussian splats at a time. Because they must be sorted back to front, moving the camera means repeatedly sorting millions of splats in real time.

Our first-generation Gaussian splat renderer used WebGL 2, which only provides vertex and fragment shaders. They are well suited to drawing the splats but not to sorting them, so a worker sorted the Gaussians on the CPU and uploaded the results to the GPU. Sorting and uploading could fall behind rendering, making artifacts visible as the camera moved.

WebGPU lets us divide that work more effectively. Compute shaders cull, project and sort the active splat set on the GPU every frame, then vertex and fragment shaders render the result. Keeping the data on the GPU avoids the transfer bottleneck and makes the pipeline dramatically faster than the worker-based WebGL 2 renderer.

The experience uses this WebGPU pipeline whenever the browser supports it and falls back to the WebGL 2 renderer automatically. To support both rendering paths, the cutout, flag animation and transition shaders each have WGSL and GLSL implementations so the experience looks the same on both backends.

Streamed SOG​

The splat data is delivered as streamed SOG — our open compressed splat format, extended with chunked levels of detail that the engine fetches on demand.

The experience contains separate splat sets for the exterior and interior. The exterior combines a streamed LOD set covering everything within 400 meters with a static, low-detail set for the landscape beyond it. Each mode loads only its own set and evicts the other, so device memory holds one view at a time.

Startup is tuned for time-to-first-pixel. On load, each streamed splat set starts at a single coarse LOD, so only a small fraction of the data needs to arrive before the loading screen lifts. From there, the engine streams in detail progressively within a per-device budget: 3.5 million rendered splats on desktop and 1.4 million on mobile. Mode switches are covered by a short freeze-fade: the last frame is held and faded down while the next splat set loads its coarse LOD, then the new view fades in and refines.

Optimized to Run Everywhere​

Beyond streaming and per-device splat budgets, a few things keep the experience smooth on modest hardware — and cool and quiet on phones:

• On-demand rendering. The app only renders when something changes: camera movement, LOD chunks arriving, a cutout animating, cars driving by. When you stop moving, it stops drawing.
• Resolution caps. Device pixel ratio is capped on high-DPI displays, with a further render-scale reduction on mobile, where the extra pixels cost more than they show.
• Depth pre-pass occlusion. The interior collision mesh doubles as an occluder: rendered depth-only before the splats, it lets early-Z reject splat fragments hidden behind walls.

Bringing the Scene to Life​

The Peek Effect​

While orbiting outside, the Peek toggle carves away the section of wall nearest the camera so you can look inside. A thin, glowing rim outlines the cut edge.

It is built on the engine's gsplat shader chunk system, which lets a project replace the gsplatModifyVS and gsplatModifyPS chunks to modify every splat and every fragment. The cutouts themselves are just box entities in the Editor, grouped under trigger volumes. As the camera moves, the trigger closest to it eases its cutout open while the others ease closed.

The shader works in two stages to keep it cheap. A per-splat stage — a compute pass on WebGPU — tests each splat's center against the cutout boxes with a signed distance function. Splats fully inside an open box are culled outright and only those near a cut surface are flagged for further processing. The fragment stage then runs a pixel-exact version of the same test for flagged splats. It reconstructs each fragment's world position from depth, fades alpha inside the box and draws a rim that maintains a constant on-screen width at any distance. The rim color is written as an HDR value so bloom picks it up. The chunks are installed only while the exterior view is active, so walk mode pays nothing for the effect.

A Hidden Flag​

The same chunk also animates a flag hidden somewhere in the scene. Splats inside an authored box ride a traveling wave, with amplitude ramping up from the pole edge and each splat tilting to follow the displaced cloth surface. Can you find it? 🔍

Cars​

We created the moving traffic by isolating and duplicating parked cars from the original capture in the SuperSplat Editor:

Three car splats spawn at randomized intervals and travel past the cathedral at slightly different speeds. They are disabled indoors, returning their splats to the interior's rendering budget.

Camera Navigation​

Exterior Orbit Controller​

The exterior orbit controller moves around a rounded-box envelope fitted to the cathedral. Horizontal and vertical motion are parameterized by arc length along the walls, corners and roof, producing uniform camera speed without discontinuities. Zoom adjusts the camera's standoff from the surface, while damped input adds momentum after release.

Camera Flights​

Camera flights use authored waypoint graphs to route around the cathedral's architecture. Inside, routing uses the collision mesh to select visible nodes; outside, it tests clearance against the cathedral's orbit envelope. A shortest-path search produces a route that is converted into a cubic spline, interpolating position, orientation, focus distance and field of view. Closing the annotation rewinds the flight to the previous camera state.

Sound and Other Touches​

A layered soundscape follows the camera. Outside, two city loops crossfade based on altitude. Inside, cathedral ambience takes over, with footsteps playing only while you walk. Even the loading screen follows the theme with a rose window drawn in CSS.

Together, these details turn the cathedral capture into a living, explorable place.

Open Source Foundations​

Everything beneath the Grace Cathedral experience is built on open source foundations. The PlayCanvas Engine renders the scene in the browser, SuperSplat provides the tools to edit and optimize the captures and the open SOG format makes them compact enough to stream. These are the same technologies we develop in the open for anyone to use, inspect and improve.

Want to build an experience of your own? Start with our Gaussian splatting guide for the complete workflow from capture to delivery. You can prepare your capture in the SuperSplat Editor, then follow the Your First Splat App tutorial to choose the approach that best fits you, whether that is the Engine API, the PlayCanvas Editor, React or Web Components. 🚀

If you have questions, want to share what you build or simply want to meet other creators, join the PlayCanvas and SuperSplat community on Discord. We'd love to see you there! 👋

Experience Grace Cathedral for yourself and see what the open web can do.

🤖 Vibe Code Splat Apps​

Turning a Gaussian splat into a real, interactive web app used to mean wiring up an engine, a build tool and a viewer by hand. Not any more. Every downloadable splat on SuperSplat now comes with a one‑click starter project download.

Open any downloadable scene, hit Download and choose the Vite project option. You'll get a complete, ready‑to‑run web app — PlayCanvas Engine + Vite + TypeScript — with the splat itself bundled in and the camera pose you set in SuperSplat preserved. Unzip it, run npm install and npm run dev, and you're looking at your splat running live in the browser.

Here's the fun part. The project is deliberately minimal and fully typed: the viewer logic lives in a single src/main.ts, and everything you'd want to change sits in one clearly named src/splat-config.ts. That makes it the perfect thing to hand to your favorite AI coding assistant — Cursor, Claude Code, whatever you like — and vibe code the app you actually want. Add hotspots, build a product configurator, drop in a character controller… it's the fastest path we've found from a raw scan to a shippable web app.

Here's one we vibe-coded earlier: an interactive snow globe built from a single Le Mont Saint-Michel splat by Mykhailo Moroz. Hit play to launch the live app — it's a hefty splat, so it only loads when you ask:

The whole thing is a small Vite + TypeScript project — browse the source on GitHub to see exactly how it's put together.

🎬 360° Video Rendering​

Today also brings SuperSplat Editor 2.29.0, and its headline feature is 360° video rendering. You can now render your animated splat scenes straight to equirectangular 360° video — ready to upload to YouTube 360, view in a VR headset or share as immersive social content. Here's how it works:

And here's the payoff — a 360° video rendered straight out of SuperSplat and uploaded to YouTube. Open it there and drag to look around, or view it on your phone or in a headset for the full immersive effect:

And we didn't stop at video. SuperSplat can now also export 360° equirectangular images, and regular image export has switched to WebP for smaller files at higher quality.

📦 SPZ Export​

SuperSplat Editor 2.29.0 also adds export to SPZ, the open, compressed splat format created by Niantic Labs for Scaniverse. SPZ files are roughly 10× smaller than the equivalent PLY with virtually no perceptible loss in quality.

With SPZ export, your SuperSplat scenes drop straight into Scaniverse and any other SPZ‑compatible app or pipeline.

⚡ splat-transform 3.0​

splat-transform is our open source command‑line tool and library for converting and optimizing Gaussian splats — it's the same tool that produces SuperSplat's super‑compressed SOG and Streamed SOG output. Today it gets its biggest upgrade yet: version 3.0.

The 3.0 release is a ground‑up streaming rewrite. Instead of loading an entire scene into memory, splat-transform now streams data through in bounded chunks, so memory use scales with chunk size, not scene size. In practice that means you can process scenes of 100M+ Gaussians on standard hardware — and it's dramatically faster too: a 10M‑Gaussian filter pass runs about 7× faster while using roughly a fifth of the peak memory of the 2.x line.

Because so much changed under the hood, 3.0 is a major release with some breaking API and CLI changes, and it targets Node.js 22+. Give it a spin with npx @playcanvas/splat-transform; the 3.0 release notes and this pull request have the full details and migration notes.

💚 Free and Open Source​

SuperSplat, SplatTransform and the PlayCanvas Engine are all free and open source under the MIT license. We believe the best tools for 3D on the web should be accessible to everyone.

If you're building a splat-based application, we'd love for you to build it on PlayCanvas. Check out our repos on GitHub:

• PlayCanvas Engine
• SuperSplat Editor
• SuperSplat Viewer
• SplatTransform

New to Gaussian splatting on PlayCanvas? Our Gaussian Splatting documentation is the best place to get started.

👂 We Want to Hear from You​

What do you think of the new features? What would you like to see next? Come and join us on the PlayCanvas Discord — it's where the world's best splat creators hang out and we'd love to have you there.

See you in there!

The scene below (a stunning scan of Lokwelt Freilassing, a Bavarian railway museum) shows both upgrades in action — explore it right here in your browser.

🚀 A Turbo-Charged WebGPU Renderer​

Today marks the release of version 2.19.0 of the open source PlayCanvas Engine — also rolling out now in the PlayCanvas Editor — and it's a landmark release for Gaussian splatting. It ships a brand new compute-based WebGPU renderer for 3D Gaussian splats.

Instead of sorting splats on a worker thread, the new WebGPU renderer hands the heavy lifting to compute shaders — culling invisible splats, projecting the rest, and sorting them with a fast GPU radix sort. The final rasterization still uses vertex and fragment shaders, but they're now lightweight, drawing from pre-projected data. The payoff is a dramatic jump in frame rates.

How dramatic? Here's the new WebGPU renderer measured against our existing WebGL 2 renderer on desktop:

And on mobile:

WebGPU is now available to roughly 85% of end users according to caniuse.com, and that number keeps climbing. For everyone else, SuperSplat automatically falls back to the WebGL 2 renderer — and because both paths are built to render identically, your scene looks exactly the same either way. No configuration, no compromises.

📡 Automatic Streaming for Near-Instant Load Times​

Big scenes deserve to load fast. SuperSplat now automatically processes every upload into a streamed format the moment it lands — no extra steps and no command line. The payoff is near-instant load times and high frame rates, even on older devices.

We call this format Streamed SOG — an extension of our super-compressed SOG (Spatially Ordered Gaussians) format. It's generated by our open source splat-transform tool, which does two things. First, it decimates the scene several times over to produce a series of high-quality levels of detail (LODs). Then it chunks those LODs into small, streamable pieces the viewer can fetch on demand.

Here's the clever part. The SuperSplat Viewer starts by downloading the lowest LODs first, putting a stable, complete image on screen almost immediately. From there it progressively refines the scene, streaming in higher levels of detail according to an overall Gaussian budget tuned to your device — a generous budget on desktop, a leaner one on mobile. You get the best your hardware can handle, automatically, and you start seeing the scene right away instead of watching a loading bar.

The Bavarian railway museum scene at the top of this post is a perfect example: its top level of detail packs a staggering 24 million Gaussians — far more than any phone could hold in memory at once — yet it appears almost instantly and sharpens as you explore.

This pairs perfectly with the new WebGPU renderer: streaming keeps the Gaussian count right-sized for your device, and WebGPU renders what's on screen faster than ever.

💚 Free and Open Source​

SuperSplat, SplatTransform and the PlayCanvas Engine are all free and open source under the MIT license. We believe the best tools for 3D on the web should be accessible to everyone.

If you're building a splat-based application, we'd love for you to build it on PlayCanvas. Check out our repos on GitHub:

• PlayCanvas Engine
• SuperSplat Editor
• SuperSplat Viewer
• SplatTransform

New to Gaussian splatting on PlayCanvas? Our Gaussian Splatting documentation is the best place to get started.

👂 We Want to Hear from You​

What do you think of the new features? What would you like to see next? Come and join us on the PlayCanvas Discord — it's where the world's best splat creators hang out and we'd love to have you there.

See you in there!

🛠️ Software Attribution​

No two splat creators work quite the same way — our community draws on an ever-growing ecosystem of capture rigs, reconstruction pipelines and post-processing tools, each leaving its own fingerprint on the final scene. With Software Attribution, you can now tag your splats with the tools you used to make them, so other creators can learn from your workflow and discover the tools shaping the field.

Open the Manage page for any of your splats and head to the new Software Used card. Search the curated catalog — including Brush, Postshot, LichtFeld Studio, RealityScan, KIRI Engine, COLMAP, Luma, Nerfstudio, Scaniverse, Polycam, Agisoft Metashape and more — and add up to six entries. Drag to reorder them. Don't see your favorite tool? Search for it and the picker will offer a quick way to request it — or just give us a shout on Discord.

Once tagged, the software you used appears as a row of logo chips on your scene page. Click any chip to browse other splats made with the same tool — a great way to find new creators, learn techniques and see how each tool shines in different hands.

🧱 Collision Generation​

Last month we launched Walk Mode, which relies on voxel collision data generated by SplatTransform 2.0. Until now, producing that collision data meant running SplatTransform locally on your splat. Today we've wired the SplatTransform 2.0 pipeline directly into the SuperSplat Studio backend — so you can generate collision for any of your splats with a single click, no command line required.

Open your splat in SuperSplat Studio, head to the Assets panel and hit Generate in the Collision section. Three simple presets — Indoor, Outdoor and Object — tune the generation for the kind of scene you have. The algorithm also needs a seed position to know where the navigable space begins, and Studio takes that automatically from your initial camera position — so as long as you're framing the scene from inside the walkable area, you're good to go.

Browse the walkable gallery to see what the community has been building.

📊 GPU-Powered Histogram​

The SuperSplat Editor's Data Panel has had a major upgrade. The histogram is now GPU-driven, computing per-property statistics across millions of Gaussians in milliseconds — even on modest hardware.

Even better, you can now select splats by dragging a range directly on the histogram. Drag to set a selection, hold Shift to add to the current selection or Ctrl to subtract from it. Locked and deleted splats are protected automatically.

The list of properties you can analyze and select against has grown too. Slice your data by:

• Position — world coordinates and distance from the origin
• Depth — distance from the active camera
• Color — R / G / B and H / S / V (with a fix for HDR scenes pushing values out of range)
• Geometry — scale, volume and surface area
• Orientation — quaternion components
• Raw values — f_dc and per-coefficient f_rest spherical harmonics

New Visible Splats Only, Log Scale and All Properties toggles let you focus the histogram on exactly what you care about.

This makes editing huge scenes dramatically faster — isolate the splats you care about with a single drag instead of nudging sliders.

💚 Free and Open Source​

SuperSplat, SplatTransform and the PlayCanvas Engine are all free and open source under the MIT license. We believe the best tools for 3D on the web should be accessible to everyone.

If you're building a splat-based application, we'd love for you to build it on PlayCanvas. Check out our repos on GitHub:

• PlayCanvas Engine
• SuperSplat Editor
• SuperSplat Viewer
• SplatTransform

👂 We Want to Hear from You​

What do you think of the new features? What would you like to see next? Come and join us on the PlayCanvas Discord — it's where the world's best splat creators hang out and we'd love to have you there.

See you in there!

This post walks through the demo I built to fix all of that:

• 👉 Play it in your browser - WASD, mouse to aim, left-click to fire.
• 👉 Check the project - the full PlayCanvas project is public. Every script mentioned in this post lives inside it, ready to read, fork, or remix.

The scene is a gorgeous indoor scan of a real abandoned place by Christoph Schindelar. Christoph is one of the best artists working with Gaussian Splats out there, so when he proposed to scan a real place for me, I jumped at the opportunity. On top of that splat I bolted a physics collider, a grid of baked lighting probes, a Recast navmesh, eight personality-driven NPCs and a classic FPS loop. Everything runs in a browser tab.

🏗️ The Build​

Here's how I built it, step by step.

📥 Step 1: Download a Splat from SuperSplat​

Before any code, you need a scene. Any splat on SuperSplat tagged Downloadable has been published under Creative Commons by its author - grab the .ply or .sog and drop it straight into your own PlayCanvas project. The lighting, clutter and scale of the scan I picked were already cinematic, so I didn't have to art-direct anything.

📡 Step 2: Convert the Splat to Streamed SOG Format​

The Swiss Army knife for everything that follows is splat-transform - PlayCanvas's open-source CLI for converting splats. We'll lean on it for streamed LOD here and for a collision mesh in the next step.

My scene is a few million Gaussians - big enough that shipping it as a single .sog asset would punish anyone on a phone or a slow connection. The fix is Streamed LOD: instead of one monolithic file, splat-transform writes out a folder of SOG chunks plus a lod-meta.json manifest. The runtime loads chunks on demand based on the camera's viewpoint and the device's capability - high-end desktop pulls full detail around the player, a phone pulls a lighter subset, and neither of them stalls waiting for the whole file.

Scripts/streaming-lod.mjs hooks into the camera and asks the runtime to keep the chunks around the player fully loaded before the game starts - so you never see pop-in mid-firefight.

🧱 Step 3: Generate a Collision Mesh​

This used to be the hard part. A splat has no surfaces, so physics is blind to it. You can't walk on it, shoot through it, or path around it. That's where splat-transform earns its keep again - the flag you want is --collision-mesh. Aim the output at a .voxel.json file and it voxelizes the splat, seals the shell, flood-fills the navigable interior from a seed position, and writes out a .collision.glb that you can import straight into PlayCanvas as a mesh collider.

splat-transform scene.ply \
  --seed-pos 0,1,0 \
  --voxel-size 0.05 \
  --voxel-opacity 0.1 \
  --voxel-external-fill \
  --voxel-carve 1.6,0.2 \
  --collision-mesh \
  scene.voxel.json

That's a separate run from the SOG conversion in Step 2 - splat-transform writes one output file per invocation, and the collision mesh only comes out of a .voxel.json output. It gives me:

• scene.voxel.json + scene.voxel.bin - a sparse voxel octree of the scene, handy for raycasts.
• scene.collision.glb - a voxel-derived mesh that hugs the real geometry.

Two knobs worth knowing: --voxel-external-fill is the one for interior scans like mine (use --voxel-floor-fill for outdoor scenes instead), and --collision-mesh defaults to a smoothed marching-cubes mesh - pass --collision-mesh faces if you'd rather have a watertight mesh that matches the voxel volume exactly. The Collision Mesh Generation guide walks through every stage and stays current with the CLI.

I dropped the GLB into the PlayCanvas project and attached it to an invisible entity with a Collision component (mesh) and a Rigid Body component (static). Suddenly the player has a floor, the bullets can collide with walls, and the NPCs have something to walk on. No modeling, no clean-up.

💡 Step 4: Bake a Lightness Grid from the Splat​

Splats carry their lighting baked into every Gaussian. That means the scene looks amazing and unchanging. But my player's weapon model, the NPC soldiers and the pickups are ordinary lit PBR meshes - they'd stand out like cardboard cutouts under gym lighting unless they somehow inherited the splat's lighting.

I didn't want to re-light the splat. I wanted a cheap way to ask "how bright is it here?" at any point in the map, at runtime, for my regular meshes.

How Scripts/probes.js works:

1. Grab the AABB of a designated floor entity and build a 1-metre grid of probe positions 1 metre above the ground.

2. Create a tiny 16×16 offscreen RenderTarget and a 90° FOV camera that renders only the World layer (i.e. the splat - no characters, no HUD, no viewmodel).

3. For each probe, render 6 faces of a cube (+X, -X, +Y, -Y, +Z, -Z), readPixels the 16×16 RGBA output, and compute luminance using the standard Rec. 601 weights:

   this._faceLuminance += 0.299 * r + 0.587 * g + 0.114 * b;
   // ... after all 6 faces:
   var lightness = this._faceLuminance / 1536; // 6 faces * 256 pixels
   

4. Stash the value in a gridDepth × gridWidth 2D array and spawn a tiny debug sphere at the probe position with emissive = lightness so you can see the light field floating in the scene.

5. When all probes are done, console.log(JSON.stringify(this.probeJSON)). I copy that out once, save it as lightness.json, attach it as a JSON asset, and delete the probes entity.

Here's the bake in action - each debug sphere pops in as its cube of faces is rendered and its luminance is averaged. Bright spheres mark a well-lit spot on the floor; dim ones sit in corners and under cover. By the end you can read the scene's lighting as a dotted heatmap before a single byte of JSON is written.

At runtime, every dynamic character script (weapon, NPC, pickup) loads lightness.json, bilinearly samples the grid at its world position, remaps it to a sensible exposure range and calls meshInstance.setParameter('exposure', value). Step from a bright atrium into a dim corridor and your hands darken smoothly. Fire your weapon and the pulsating omni-light bounces off the splat around you.

─── Probes: baking 392 probes (28 x 14) ───
Probe 1/392   lightness: 0.4821
Probe 2/392   lightness: 0.4733
...

The whole bake takes ~15 seconds once, then the JSON is ~40 KB. No expensive runtime probes, no deferred relighting, just a lookup table.

🛠️ Step 5: Vibe Code with the PlayCanvas VS Code Extension​

I didn't write any of this in the PlayCanvas web editor's code panel. I used the PlayCanvas extension for VS Code - which also works inside Cursor, so I could pair-program with Claude while editing.

Save the file → the editor picks up the change → reload the launch tab → test. That round-trip is measured in seconds.

Most of the gameplay logic in this demo - character-controller.js, anim-states.js, npc-ai.js, probes.js - was iterated on entirely from Cursor.

🔄 Step 6: Version Your Project with PlayCanvas + GitHub​

"What did I change yesterday, and how do I roll back?" PlayCanvas ships a first-party version control that answers exactly that. You can also use GitHub at the root of your locally synced PlayCanvas project (via the VS Code extension). Don't forget to add a .pcignore so the .git folder isn't synced to the cloud.

Combined with the VS Code extension, this is about as close to "I'm working in a normal repo" as I've ever had in a browser-first engine. If I break the NPC AI, I'm one git revert away from last night's working build.

🧭 Step 7: Generate a Navmesh from the Collision Mesh​

NPCs can't path on a splat either - they need a navmesh. For the runtime, I use recast-navigation, loaded straight from esm.sh with dynamic import - zero bundler, just:

const recast = await import('https://esm.sh/recast-navigation');
await recast.init();
const imported = recast.importNavMesh(new Uint8Array(navmeshBuffer));

To produce the navmesh.bin binary, I feed the same scene.collision.glb from Step 3 into a small offline Recast-based generator. The collision mesh already represents "solid floor you can walk on", so Recast just has to rasterize it, filter walkable spans and build the nav polygons - takes a few seconds.

I'm cleaning up the generator into a standalone library and will publish it on GitHub shortly - drop-in collision-GLB-to-navmesh-binary for any PlayCanvas project. Follow my X account if you want the drop.

Want to see the navmesh in-game? Press N in the demo to toggle the debug overlay - the walkable polygons, agent positions and current paths all light up on top of the splat.

🧠 Step 8: Give NPCs a Brain with Behavior Trees and Personalities​

The NPCs are the part I had the most fun with. Every soldier in the demo is driven by a classic behavior tree - the same abstraction Halo 2 popularized two decades ago and that's still the default for AAA AI in 2026.

Scripts/npc-ai.js exposes four primitives:

sequence(...children)   // all must succeed
selector(...children)   // first non-failure wins
condition(pred)         // leaf: true/false
action(fn)              // leaf: 'success' | 'failure' | 'running'

…and then every NPC's brain is built by composing those, parameterised by a personality:

return selector(
    sequence(isDead, autoRespawn),
    sequence(
        isAlive,
        selector(
            sequence(isReloading, stopShooting),
            sequence(ammoEmpty, doReload),
            ...(traits.healPriority > 0.4   ? [sequence(hpBelow(hpRetreatPct), hasPickupsNearby, goToPickup)] : []),
            ...(traits.lootPriority > 0.7   ? [sequence(hasPickupsNearby, goToPickup)] : []),
            ...(traits.retreatThreshold > 0.3 ? [sequence(hpBelow(hpRetreatPct), retreat)] : []),
            ...(traits.aggression > 0.2     ? [sequence(hasEnemiesInRange(attackRange), engageEnemy)] : []),
            guard
        )
    )
);

Spawn eight NPCs with eight different personalities - Sgt. Havoc (aggressive, pushes), Ghost (cautious, heals), Captain Valor (heroic), Strategist (tactical), Chaos (randomness 0.8, impossible to read), Loot Goblin (greedy, will run across the map for a pickup), Chicken (cowardly, retreats at 80% HP), Grumps (grumpy) - and they already feel distinct, because the same tree collapses to wildly different priority orders based on traits.

Each agent's position, aimAngle, animBits is updated every tick. The PlayCanvas side - npc-controller.js - is just a dumb bridge that reads those fields, sets the entity transform, picks an anim state, fires a muzzle-flash ray, triggers sounds. The AI itself has zero PlayCanvas dependencies except pc.Vec3; it could be lifted into Three.js, Babylon, a headless sim, whatever.

🎮 What You Need to Build One of These​

To recap the full stack:

• 📥 Environment - any downloadable splat from SuperSplat, or your own capture.
• 📡 Streaming - convert with splat-transform to a streamed SOG folder so phones and slow connections don't stall.
• 🧱 Collider - splat-transform --collision-mesh → .collision.glb, dropped into PlayCanvas as a static mesh rigidbody.
• 💡 Lighting - bake a lightness.json grid with probes.js, sample it per-mesh-instance at runtime.
• 🛠️ Authoring - PlayCanvas VS Code extension for a normal save-and-reload dev loop.
• 🔄 Versioning - PlayCanvas version control and/or GitHub via the VS Code extension.
• 🧭 Pathfinding - recast-navigation from esm.sh, fed a pre-baked navmesh.bin (generator library coming soon).
• 🧠 AI - behavior trees + personality-driven traits.

Every one of those pieces is free and open source. The whole thing ships as static files to a CDN. My build is 68 MB (splats environment streamed separately from AWS S3) and cold-loads in a few seconds.

💚 Free and Open Source​

SuperSplat, splat-transform, recast-navigation and the PlayCanvas Engine are all open source. And so is this demo - the whole PlayCanvas project is public. Sign up for a free PlayCanvas account, fork the project, and every script mentioned above (probes.js, npc-ai.js, npc-controller.js, the navmesh wrapper, and the rest) is yours to read or remix. If you take them somewhere cool, I want to see it.

👂 Try It, Break It, Tell Me​

Play the demo. Stand in a bright room and watch an NPC walk into the shadow. Fire your weapon next to a wall and watch the splat flash. Crouch into a corner and notice the footsteps go quiet.

Then go build your own. If you have questions, find me and the rest of the splat-creator community on the PlayCanvas Discord - that's where all the interesting splats-into-games conversations are happening right now.

See you in there.

📥 Downloadable Splats​

Splat owners can now make their scenes downloadable. Open the Manage page for any of your published splats, flip the toggle and your audience can grab the files directly from the scene page. You can download the source file we host or, when you need maximum compatibility with other software, download it as a PLY. Each scene tracks its download count so you can see how popular your work is.

Want to find downloadable splats? Head to the Explore page to browse scenes that are available for download.

Downloaded splats can be used anywhere — in your own apps, research projects or creative tools. A great option is to load them into your PlayCanvas projects via the PlayCanvas Engine or the PlayCanvas Editor.

📜 Creative Commons Licenses​

Sharing your splats is great — but you should be able to decide how they're used. You can now assign a Creative Commons license to any downloadable splat, choosing from six CC 4.0 variants:

• CC BY — Attribution
• CC BY-ND — Attribution, No Derivatives
• CC BY-SA — Attribution, ShareAlike
• CC BY-NC — Attribution, NonCommercial
• CC BY-NC-ND — Attribution, NonCommercial, No Derivatives
• CC BY-NC-SA — Attribution, NonCommercial, ShareAlike

The download dialog displays official CC icons alongside a ready-to-copy credit line, making it easy for anyone who downloads your work to give proper attribution. A machine-readable license link is also embedded in the published scene so tools and search engines can pick it up automatically.

🔗 Social Profile Links​

Let the community know who you are. You can now add social links to your profile — Website, X, LinkedIn and YouTube — from your PlayCanvas account settings.

Your social icons will appear on your SuperSplat user page right alongside your published splats, making it easy for visitors to follow your work across the web.

💚 Free and Open Source​

SuperSplat, SplatTransform and the PlayCanvas Engine are all free and open source under the MIT license. We believe the best tools for 3D on the web should be accessible to everyone.

If you're building a splat-based application, we'd love for you to build it on PlayCanvas. Check out our repos on GitHub:

• PlayCanvas Engine
• SuperSplat Editor
• SuperSplat Viewer
• SplatTransform

👂 We Want to Hear from You​

What do you think of the new features? What would you like to see next? Come and join us on the PlayCanvas Discord — it's where the world's best splat creators hang out and we'd love to have you there.

See you in there!

🚶 Walk Mode​

You can now explore splats from a first-person perspective with the all-new Walk Mode. Step inside your scenes and experience them the way they were meant to be seen.

The viewer defaults to a click-to-walk mode — just click or tap where you want to go and the camera will smoothly glide there. On desktop, press WASD at any time to switch to FPS-style controls. On mobile, open Settings to enable a pinch-to-move mode for full touchscreen navigation.

Check out the full gallery of walkable splats to explore many more scenes.

Walk Mode is powered by a new voxel-based collision system. When collision data is present in a scene, the viewer automatically enables first-person navigation.

SplatTransform has been updated to generate this new voxel collision format. Collision generation is currently in developer preview — we're working closely with a select group of splat creators to dial it in. Expect to see more and more walkable splats appear in the coming days and we'll open the feature up to everyone once it's stable.

📡 Streamed Level of Detail​

Ever since we enabled splat publishing on SuperSplat, we've noticed a trend: your splats are getting bigger. While a typical desktop machine handles around 4 million Gaussians at high frame rates, we're now regularly seeing scenes published with over 10 million. That's a lot of Gaussians.

To make sure any device can render even the most ambitious scenes, we've introduced streamed LOD. Built on the highly capable SOG (Spatially Ordered Gaussians) format, it slices scenes into small streamable chunks that load dynamically on demand. The viewer fetches only what's needed for the current viewpoint and device capability — so a phone and a high-end desktop both get the best experience they can handle.

LCC scenes captured on XGRIDS devices already ship with high-quality LODs built in. For everyone else, SplatTransform can generate streamed SOG from user-created PLYs representing different detail levels.

📤 Easy Upload​

Until now, the only way to publish a splat on SuperSplat was through the Editor. Today, we're introducing a brand new Easy Upload flow — just hit the Upload Splat button on the SuperSplat homepage, drag and drop a PLY, SOG, Streamed SOG or LCC file and go live in seconds.

We've also updated the existing Editor publishing flow to share the same new details dialog. When you publish from the SuperSplat Editor, you'll now be redirected to your Manage page to fill in your splat's details while it's being prepared to go live.

The new details dialog is just the beginning — expect more fields to appear soon covering license type, capture hardware and software and even geolocation. Stay tuned!

⚡ PlayCanvas Engine 2.17.0​

All of the above is powered by the open source PlayCanvas Engine, and this week sees the release of version 2.17.0. This release is laser-focused on splat rendering performance:

• Major frame rate gains for both WebGL2 and WebGPU
• Refined LOD selection that dramatically improves visual quality
• Device-aware optimizations carefully tuned for everything from phones to high-end desktops

Check out the full release notes on GitHub.

💚 Free and Open Source​

SuperSplat, SplatTransform and the PlayCanvas Engine are all free and open source under the MIT license. We believe the best tools for 3D on the web should be accessible to everyone.

If you're building a splat-based application, we'd love for you to build it on PlayCanvas. Check out our repos on GitHub:

• PlayCanvas Engine
• SuperSplat Editor
• SuperSplat Viewer
• SplatTransform

👂 We Want to Hear from You​

What do you think of the new features? What would you like to see next? Come and join us on the PlayCanvas Discord — it's where the world's best splat creators hang out and we'd love to have you there.

See you in there!

📌 Annotations and Hotspots​

SuperSplat Studio lets you place informational hotspots directly onto your splat. Each annotation consists of a title, a description and a camera viewpoint. When a viewer clicks a hotspot, the camera smoothly transitions to the saved viewpoint and reveals the annotation content.

This makes it easy to build educational walkthroughs, product showcases or guided tours of your 3D scenes. Simply position your camera, click to place a hotspot and fill in the details. You can add up to 25 annotations per scene and reorder them however you like.

The SuperSplat Viewer features a new annotation navigation bar that lets viewers cycle through all annotations in sequence. It's a great way to guide your audience through the key points of interest in your scene.

Check out this interactive honeybee by SuperSplat community member Dany Bittel to see the new annotations in action:

✨ Post Effects​

Want your splats to really pop? SuperSplat Studio gives you access to a comprehensive set of post effects powered by the PlayCanvas Engine. Apply cinematic polish to your scenes with just a few clicks:

• Bloom — Add a soft glow to bright areas for a dreamy, cinematic look.
• Sharpen — Crisp up fine details and make your splats look razor sharp.
• Vignette — Darken the edges of the frame to draw the viewer's eye to the center.
• Color Grading — Fine-tune brightness, contrast, saturation and tint.
• Chromatic Fringing — Add a subtle lens fringing effect for extra realism.

All effects update in real time as you tweak the sliders, so you can dial in the perfect look instantly.

🎨 Tonemapping and Background​

SuperSplat Studio also gives you control over tonemapping and background color. Choose from a range of tonemapping operators including Linear, Filmic, ACES, ACES 2.0, Hejl and Neutral to get the tonal response you want. And set a custom background color to complement your scene or match your brand.

🚀 Get Started​

Ready to create your first interactive splat experience? Upload and publish your splat via the SuperSplat Editor, then visit your Manage page and select the Edit icon to open it in SuperSplat Studio. From there, add annotations, apply post effects and make your splat shine. It's never been easier to build compelling 3D content for the web.

👂 Your Feedback Matters​

We're incredibly excited to bring SuperSplat Studio to the community and we can't wait to see what you create with it!

What features would you like to see next? Let us know on the Discord or ping us on X!

Today, we are excited to be joined by Vladimir, Roman and Ben from Voxelo as they celebrate the beta release of Voxelo.ai 2.0.

Welcome to our Developer Spotlight! Tell us a bit about yourselves.

Vlad: We’re the team behind a new solution - Voxelo.ai - an ambitious group of engineers and product builders with backgrounds spanning 3D, AI, e-commerce and marketing. We’ve spent years working across web-based 3D, product visualization, and content production, and Voxelo.ai grew out of a shared frustration: e-commerce product experiences haven’t evolved nearly enough, and traditional 3D production is still too slow, expensive, and specialist-heavy.

Left to right: Ben McKay, COO (ex-WPP agency and product leader); Vladimir Mulhem, CEO (ex-founder of 3D agency Creative Content Works); Roman Bromidge, CTO (ex-founder of Kaedim, a 3D AI start-up)

How did you first discover PlayCanvas?

Roman: PlayCanvas kept coming up whenever we looked at high-performance, production-grade 3D viewers. As soon as we started testing real-time viewers for high-fidelity 3D assets, it became clear that PlayCanvas was setting the benchmark for performance and advanced features.

Vlad: It wasn’t just about the technical merits of the platform today. Having met with Will Eastcott a few times, we were excited by the alignment in ambition and direction. That kind of shared mindset really matters when choosing long-term partners.

What made you choose PlayCanvas instead of other web technologies?

Ben: Customers are king. That’s always the starting point. Our customers are e-commerce businesses where CX and web performance directly impact sales, so we have to maximize visual fidelity without compromising performance. Anything less than industry-leading simply isn’t good enough.

Roman: We tested plenty of alternatives, but PlayCanvas consistently delivered better frame rates, lower memory usage, and a more robust engine-level architecture. For a commercial platform like Voxelo.ai, that reliability is critical. Add to that its open-source nature and flexibility - it fits perfectly with our ambitious roadmap and avoids locking us into rigid development models.

Let’s talk about Voxelo.ai. In your own words, what is Voxelo.ai and what problem does it solve?

Ben: Voxelo.ai is building a new type of AI content studio, with 3D at its heart. Our goal is to close the buyer confidence gap by bringing people closer to a product’s features and benefits through better product content.

We start by turning simple product videos and images into ultra-realistic 3D digital twins - optimised Gaussian splats. We listened closely to e-commerce businesses and designed a user-generated 3D workflow that lets them access the benefits of 3D without expensive equipment, specialist skills, long timelines, or big budgets. That’s a huge unlock for e-commerce. We refer to it as UG3D® to underline the accessibility of this new format.

This serves two major needs.

First, consumers consistently say they want 3D because it increases confidence when buying - which means businesses increasingly need 3D. We make that accessible.

Second, it’s about operational efficiency. Once you have a 3D digital twin, almost anything becomes possible in product content - and that’s what we’re rolling out now.

With a digital twin, customers can create interactive 3D models, AR experiences, lifestyle imagery, and on-brand product visuals - all within an end-to-end platform. With PlayCanvas’ help, Voxelo delivers this at high impact, high speed, and low cost.

3D and AI-driven 3D is evolving fast - what excites you most about this space?

Roman: The shift from handcrafted 3D to data-driven 3D is huge. AI makes it possible to generate rich spatial content from everyday inputs like video. That fundamentally changes who can create 3D, and how often it can evolve.

Vlad: There’s a real 3D wave coming. It’s been building for years, but falling compute costs and better infrastructure mean businesses can finally deliver truly immersive shopping experiences at scale. Voxelo is right at the forefront of this. With support from Innovate UK, we’re investing heavily in R&D to make 3D’s value accessible to far more people.

How does Voxelo.ai make 3D content more accessible for non-technical users?

Ben: We obsess over workflow simplicity. Users don’t need to understand meshes, textures, or rendering pipelines. They upload a 3–4 minute video, Voxelo processes it, and they get a web-ready 3D + AR experience straight out of the box.

Creation, processing, and publishing are all just a few clicks. We want solo entrepreneurs wearing multiple hats to feel just as comfortable as global retailers.

Could you walk us through the process of creating a 3D asset with Voxelo.ai?

Roman: The pipeline is intentionally simple:

• Shoot a 3–4 minute product video (most people use mobile phones, but DSLRs are great too)
• Upload it to Voxelo.ai
• Publish your product in 3D and AR

More advanced AI features are on the way. From there, we can also generate classic e-commerce imagery and lifestyle shots, all powered by the same 3D digital twin.

Can you give an example of how Voxelo.ai is being used effectively today?

Ben: We’re seeing strong traction in e-commerce product visualization, especially in categories where detail and realism matter—fashion, footwear, furniture, and homeware.

Early customers include major brands and retailers like Cosatto and SportShoes.com that are looking for scalability without compromising on the quality.

We see the greatest need, though, with mid-sized companies who are looking for a customer experience edge but haven’t had the budgets for costly 3D production previously. These have included emerging fashion designers like BEPO, who turn military parachutes into designer clothing, or Recondition, who make jeans for people with mobility challenges. Or manufacturers, like Eden Play, who need help showcasing the quality of their hand-crafted playground equipment. Each has a story to tell and 3D can help.

And the applications keep expanding. From cars to cushions, pottery to plants, sofas to shoes - when cost, complexity, and time drop this much, 3D is no longer reserved for only big-ticket items.

How did PlayCanvas help you deliver a smooth experience across desktop and mobile?

Roman: PlayCanvas gives us a consistent rendering layer across devices. The same asset works smoothly on desktop and mobile, with intelligent handling of performance constraints. That consistency is absolutely crucial for e-commerce customers.

Were there any technical challenges integrating PlayCanvas, and how did you overcome them?

Roman: The main challenge was integrating PlayCanvas effectively into our React application while still extracting maximum performance. The biggest surprise was how, once we embraced PlayCanvas as a web-based game engine, many of our integration hurdles dissolved. Initially, we started with PlayCanvas React for rapid prototyping, which was great for verifying our concepts. However, we sometimes struggled with mapping specific functionalities not directly exposed by the wrapper, requiring us to write custom scripts to interface with the underlying engine systems.

For some of the more involved functionalities, like our AR viewer and splat editor, we found building them as native PlayCanvas applications and then linking or embedding them within our existing React app significantly improved both performance and development speed. This approach helped us minimize dependencies and side effects, allowing us to get the most out of the engine.

Can you share any interesting performance optimizations you’ve implemented?

Roman: The greatest satisfaction came from the enormous performance gains we achieved over our previous 3D viewer implementation. We more than doubled the frame rate, and by leveraging PlayCanvas' SOG format, our 3D files are now a third of the size of our already compressed previous format. We've seen a 95%+ reduction in file size for the SOG file versus the raw PLY output from our 3D AI reconstruction process. It's amazing how a few simple, often overlooked things can dramatically improve performance; it just goes to show that thoroughly reading the documentation is always worthwhile. For instance, turning off anti-aliasing for our PlayCanvas app significantly boosts performance when rendering Gaussian splats—one little flag made a huge difference!

Voxelo.ai has recently launched - how has the feedback been so far?

Ben: The feedback has been really encouraging. We’ve been open and transparent with users from day one, building with them rather than just for them. That partnership approach has been invaluable - it’s helped us effectively map out the next three years of product features and value (on top of plenty of ideas we already had ourselves).

Some of the early feedback has been usability-focused - things like making the capture process more intuitive, or improving guidance and help resources. But the most exciting feedback has been around our direction and ambition: users are asking for even more features, recognizing the recent performance gains (especially since deploying PlayCanvas), and calling out the jump in visual fidelity - in many cases comparable to high-quality e-commerce product photography.

Who do you see as the ideal audience or customer for Voxelo.ai?

Ben: Our initial hypothesis was that SME retailers - particularly in footwear, fashion, furniture, and homeware - would benefit most from Voxelo.ai. That’s still very much true. But the biggest surprise has been the level of enterprise interest.

Large brands are wrestling with the same questions: How do we create gold-standard PDPs (product detail pages)? How do we elevate our product experience and give us a competitive edge?

We’re building a new type of AI content studio powered by 3D - but designed to be genuinely easy to use and ready to scale across existing and emerging AI-powered workflows.

What are your plans for upcoming features or improvements?

Roman: Tons! More to come, but as a teaser - yes, we’re leaning hard into AI (I mean, who isn’t?). The goal is to make the product as easy and scalable as possible. We're rolling out a wave of new features in Q1, and a key focus will be refining and streamlining the onboarding experience - it’s a critical area we don’t want to overlook.

More broadly, we're optimizing to become ultra-native to e-commerce teams - embedding more deeply into their workflows, tools, and day-to-day operations.

Vlad: Thanks in part to support from Innovate UK and our partnership with the University of Manchester, we’ve built a strong R&D pipeline. Some aspects of the roadmap are still exploratory, but we’re not flying blind - we’re backing our ideas with a strong team and grounded market insight. A big theme is reducing the inputs required to create 3D while expanding what customers can do creatively, especially with AI. There’s a lot of potential here, and we’re excited for both the team and our users to push into these next frontiers.

How can the PlayCanvas community try Voxelo.ai or get involved?

Ben: We’re actively onboarding early users and collaborators. The PlayCanvas community is ace, and we’re always keen to hear feedback from developers building real-world 3D products.

Whilst we’re building for non-technical users, we’re also hearing that technical specialists might well value simplified workflow. If any of the community want to create an account or partner in some way, please register here or email the team at hello@voxelo.ai.

Where do you see web-based photorealistic 3D content heading in the next few years?

Vlad: We believe 3D will become as standard as images and video, especially in commerce. AI will continue to reduce costs and friction, while engines like PlayCanvas make delivery seamless across devices.

Roman: In the future, I believe it will become standard to have a 3D digital twin of your products, available at any time for you to leverage to make new content and help understand your buyers. No more messy management of ten different content pipelines, no more figuring out which warehouse your stock is in so you can ship it to the photographer, no more lost sales because you couldn't quite realize your vision for how the product can be shown. Furthermore, with embedded 3D on your product page, you can understand your customer better than ever before: what exactly do customers look at on your product before they click buy? What do they spend the most time examining? With Voxelo.ai, we're really excited because having a realistic 3D representation of your product enables so many more opportunities to improve buyer confidence and gain deeper understanding of your customers.

Ben: I hope to see it across all web platforms...at least in the context of social commerce. It feels odd that the technology now exists, consumers want it and businesses need it. It has the potential to increase consumers' product comprehension, increase growth and reduce returns (and with it, reduce carbon footprint)...and yet. Surely, it’s just around the corner. Surely.

Any advice for developers looking to build commercial products on PlayCanvas?

Roman: Build with real users early. PlayCanvas is incredibly capable, but the biggest wins come from pairing strong performance with simple, opinionated, constructive and collaborative user experiences. Don't be afraid to ask questions, read the docs thoroughly, and think of it more like a game engine than a traditional web dependency.

What’s been the most rewarding part of building Voxelo.ai so far?

Vlad: I’ve spent the vast majority of my career obsessed with 3D, because in e-commerce the limitations of a flat, 2D screen are felt more acutely than anywhere else. We ask customers to make purchase decisions without touch, weight, scale, or presence - and then wonder why confidence drops and returns go up.

Turning a 2D screen into a 3D experience fundamentally changes that equation. 3D allows products to be explored rather than imagined. It gives shoppers clarity around form, proportion, detail, and quality - the same cues they rely on in the physical world. When done well, 3D doesn’t just look impressive; it reduces uncertainty, builds trust, and helps people buy with confidence.

What excites me most today is that 3D is finally becoming viable at e-commerce scale. Historically, it’s been too expensive, too slow, and too specialist-driven to deploy across large catalogues. With real-time web engines and AI-driven 3D creation, we’re reaching an inflection point where 3D can be produced as naturally as images or video.

That shift unlocks a future where 3D isn’t a novelty or a campaign asset, but a core layer of product content - helping every shopper better understand what they’re buying, and helping brands convert more confidently at scale.

Roman: The most rewarding part has been building all the exciting ways for users to leverage their 3D digital twin. From my background as co-founder of Kaedim, I understood that 3D is critical for so many industries, yet so underutilized because of its cost and difficulty. Now, I'm really excited to enable new generations of creatives to transform their products into 3D and from there into anything they can imagine.

Ben: Just to add…seeing users create compelling 3D experiences without needing to become 3D experts. That moment when something complex suddenly feels easy is exactly why we built Voxelo.ai…and will continue to build in a way that grows buyer confidence.

What’s one message you want to leave with our readers?

Ben: 3D has tried to break through before - but this time, it feels a little different. The tech is ready, costs are dropping dramatically and growing numbers of communities are rallying. And now, AI has blown the doors open on creative potential. Interactive, ultra-real 3D and AI is no longer coming - it’s here - and Voxelo is all in on re-imagining how this impacts new digital experiences. Huge thanks to the community for the support!

Thanks for chatting with us, Vlad, Roman and Ben!

The PlayCanvas VS Code Extension is a realtime editing environment for text-based assets from the PlayCanvas Editor platform.

🚀 Overview​

This release represents a major step forward from the previous version of the PlayCanvas VS Code Extension — bringing deeper integration, improved collaboration, and stronger developer tooling.

Here’s what’s new:

• Realtime Asset Syncing: Text-based assets now update instantly between VS Code and the PlayCanvas Editor, allowing seamless editing without manual uploads or refreshes.
• Live File Collaborators: See who’s working in the same file at any given time, helping teams avoid conflicts and improve coordination.
• Full Type Checking for Scripts: Enjoy comprehensive TypeScript support with inline error detection and autocomplete for all PlayCanvas script types.
• Disk-Mapped File System: The extension now mirrors your PlayCanvas project structure locally on disk, unlocking improved integration with external tools — including AI-powered agents and code assistants.

These upgrades make the extension faster, smarter, and better aligned with modern development workflows.

🧰 Getting Started​

1. Install the extension from the VS Code Marketplace.
2. Sign in with your PlayCanvas account when prompted.
3. Open the Command Palette (Ctrl/Cmd + P) and run PlayCanvas: Open Project.
4. Start editing — your changes appear instantly in the PlayCanvas Editor.

🛠️ Contribute​

We welcome contributions from the community! To set up your local development environment, check out the README for more information.

We’ve made major improvements for contributors, including:

• Clearer code organization
• Stronger TypeScript support
• Streamlined debugging
• Comprehensive testing suite

Be part of shaping the PlayCanvas VS Code Extension’s future — share feedback, contribute improvements, or show your support by starring our GitHub repository! ⭐

💬 Join the Community​

We’re incredibly excited about this new phase for the PlayCanvas ecosystem, and your feedback plays a vital role in shaping its future. Whether you’re contributing code, sharing ideas, or showcasing your projects, we’d love to hear from you.

Connect with the PlayCanvas community and be part of our open-source journey:

• 💬 Discord — Chat with other PlayCanvas developers in real time
• 🌐 Forum — Join in-depth technical discussions
• 🧵 Reddit — Share your projects and experiences
• 🐦 X (Twitter) — Follow for the latest updates and announcements

Your insights help us make PlayCanvas better for everyone. What features are you most excited about, or what would you love to see next? Join the conversation and help us define the future of web-based interactive development.

Back in May, PlayCanvas announced support for SOGS, a revolutionary super-compressed format for 3D Gaussian splats. While SOGS was a huge leap beyond other compression techniques, we were still not satisfied! So we set about designing a new and improved iteration of the format.

Today, we are proud to introduce SOG: Spatially Ordered Gaussians.

The Skate Park above is not a video! Navigate around the scene and explore! The splat was scanned by Christoph Schindelar. It has 4 million Gaussians but is compressed to a mere 42MB with SOG. The original PLY was 1GB, meaning a ~95% reduction in file size.

What is SOG​

SOG shares a great deal in common with its predecessor. It is still a meta.json file that references multiple .webp images. So what's new and why is it better?

📦 More convenient: Your SOG splats can now also be written to a single .sog file
⚡ Faster to load: SOG stores splat data in Morton order meaning it's 'GPU-ready' and doesn't require processing on load
🗜️ Easier to compress: SOGS compression required CUDA but SOG only needs WebGPU so it runs anywhere
🎯 More precision: SOG minimizes compression artifacts by making smarter use of the same number of bits

Converting to SOG with SplatTransform​

To create .sog files (or unbundled .json + .webp files), we provide the open source SplatTransform CLI tool. To install it, just issue this command:

npm install -g @playcanvas/splat-transform

And to convert, do:

splat-transform input.ply output.sog

What could be easier? 🎉

Engine Support for SOG​

As you might expect, the open source PlayCanvas Engine is the first graphics runtime to support SOG. Support was introduced in the 2.11.0 release and we have thoroughly tested and stabilized it with a number of subsequent patches.

PlayCanvas React and PlayCanvas Web Components have also been updated to support SOG.

Editor Support for SOG​

Bundled SOG files (.sog) are now natively supported in the PlayCanvas Editor! Simply drag and drop a .sog file into your ASSETS panel to create a new gsplat asset.

Dragging the gsplat asset into the viewport triggers the creation of a new Entity with the asset assigned to a GSplatComponent.

SuperSplat Support for SOG​

SuperSplat, the #1 platform for publishing 3D Gaussian Splats, has been updated to compress your scans with SOG. Since it provides around 2-3x the compression of Compressed PLY, your creations will load much faster and will load on more memory constrained devices.

Open Sourcing SOG​

Today, we are officially open sourcing the specification for SOG. SplatTransform provides a reference writer for the format. And the PlayCanvas Engine provides a reference implementation for loading and rendering SOG.

We encourage other engine and tools developers to integrate support for SOG into your products/projects. And we invite the open source community to join our open source effort and contribute to PlayCanvas' codebases in any way that you can.

Credits​

We would like to recognize the work of some incredible people from the open source community that made all of this possible:

• Wieland Morgenstern from Fraunhofer HHI who developed the original SOGS format.
• Vincent Woo who did the original integration of SOGS into PlayCanvas.

Let's continue this tradition and work together to keep 3DGS technology free and open source.

Come and Meet Us Today​

If you want to chat about SOG, SuperSplat or 3D Gaussian Splatting in general, then you have to join the PlayCanvas Discord Server. Some of the world's premier splat creators hang out there, so come and join the conversation!

Today, we are excited to be joined by In Ha and Willie from Reflct.

Welcome to our Developer Spotlight! Tell us a bit about yourselves.

Willie: I'm Willie, I co-founded Reflct with In Ha. I’ve been working in and around 3D and web development since my University days, where I dropped out to try my hand at a game development startup. It failed, but I learned a lot and developed a fixation with interactive tech. That first experience is what really drove my career, afterwards I worked for a few years in VR, and then into creative web and product development. I’m more of a creative technologist type, In Ha is the sole developer of the main Reflct application. I just work on our side things, like Sharp Frames, and handle the 3DGS production side for our direct clients.

In Ha: I'm In Ha, I studied computer graphics and have spent my career so far in web 3D and front-end development. I am a huge enthusiast of 3D graphics and rendering technologies on the web.

How did you first discover PlayCanvas?

Willie: It was through the 3DGS community, PlayCanvas really is the biggest name in the space, and you can’t be into 3DGS without hearing about PlayCanvas at some point.

In Ha: Yeah, that's about right. When I was quite new to 3DGS, Willie showed me there was a tool to modify the splats, and it worked very well. It was SuperSplat by PlayCanvas. It was the very first tool I heard of when I entered the realm of 3DGS.

What made you choose PlayCanvas for Reflct instead of other web technologies?

Willie: Well, we didn't at first. We were using Mark Kellogg’s three.js plugin for a long time. We made that decision early on when his project was the only one that had second-degree spherical harmonics. Over time, though, we saw what the PlayCanvas team was doing and ultimately made the decision to switch over. It’s open source, reliable, performant, and just really, really good. You guys are doing great work — I wish we had made the shift sooner.

In Ha: It's fast and simple to use.

Let’s talk about Reflct. In your own words, what is Reflct and what problem does it solve?

Willie: We built Reflct to enable commercial use cases for 3DGS assets. 3DGS is this amazing technology; photorealistic 3D at real-time frame rates in the browser. It’s as mind-blowing to me now as it was when the Inria paper first dropped. But most ‘normal’ people don’t know how to navigate a 3D space in the browser, particularly on mobile, and you can really get lost in a 3DGS scene. We let creators control what a user sees in their scene by setting specific viewpoints, with orbit limits that control how much the user is able to move around. Each viewpoint can carry metadata which can be used for commerce integrations or custom features. Rich tools and features for creators, with a super simple viewer that non-technical people can navigate.

In Ha: It is also important to mention that we provide tools to help users implement their 3DGS assets on their websites, with the same navigation configured in our dashboard. This makes the whole integration process a lot easier. Our React library is one, and our Shopify component is another. We aim to keep expanding those tools to increase coverage.

3D Gaussian Splatting (3DGS) is still a new technology — what excites you most about it?

In Ha: When I first heard what it is and saw some examples of it, it seemed to me that the way splats work resembles the idea of “pixels” on the screen. In this case, they are pixels in 3D, not 2D. Each splat in 3D space has color and other attributes, just like 2D pixels, which have coordinates and color.

I was amazed by the idea and concept behind the technique. I am very excited about what people could do with 3DGS in the future.

Willie: I'm excited for the future of the technology. There are a lot of smart people around the world pushing the boundaries, making it smaller, faster, more realistic. SOGs are a good example. And it’s so new, we’re only a couple of years in.

How does Reflct make navigating and exploring 3DGS content easier for non-technical users?

Willie: We just make it simple. We wanted something that we could give to our parents and they’d be able to figure out how it works. There are three big buttons at the bottom: left and right arrows, and a play button. If you drag the screen, the camera orbits a single point. No WASD, no free-roaming movement. Easy, but behind the scenes the creator has a bunch of features to help curate the experience for users.

The creator can manage ‘views’ in the Reflct dashboard. These are coordinates to which we move the camera when the user presses one of the arrow buttons. Each view has some data attached to it: position and focal point, as well as orbit limits, zoom, transition animation details, and product metadata. The orbit limits are important since they give the creator control over the movement of the camera, which means they can direct the user’s attention to the best parts of the scene without letting them see the ‘rough edges’ you get in 3DGS.

All these little bits add up to a powerful feature set for curating the experience of navigating the 3DGS space, but all the end user sees is three buttons.

Could you walk us through the process of curating a scene in the Reflct dashboard?

Willie: Sure, when you drag in your .ply we’ll automatically compress it, then you just move around like you would in any 3D viewer. Once you find a viewpoint you like, you click ‘Add view’. You can edit the details for that view, set the orbit limits, change the focal point, configure the transition animations. There are also features to add hotspots or annotations.

You just do that a few times to set all the points in your scene where you want to direct the user's attention. Then you create a shareable link, or integrate it with your site using our React library or Shopify app. If you’re using our Shopify app, you can add the productHandle to the view metadata and it will automatically pull the product details into the side panel.

Orbit limits and managed views sound like powerful tools — can you give an example of how they’ve been used effectively?

Willie: The Shopify app is a good example. Brands can capture a showroom or a staged space with their products, then each product can have its own set of views. Setting the views gives the creator a way to guide the user through the space, and the orbit limits ensure that they only see the products from the best angles.

When this is integrated with Shopify, the end user is able to explore a ‘shoppable’ 3DGS environment. Each time they move to a new product, the product details are displayed in the application. It’s quite exciting - we haven’t seen that type of e-commerce experience before. We’re working with a few different brands here in New Zealand to take this to the next level.

Let’s dive into some technical details. How did PlayCanvas help you deliver a smooth experience across desktop and mobile?

In Ha: We were using the GaussianSplats3D viewer by mkkellogg before we made the switch. We decided on the viewer very early on in our journey; at the time, we felt it was the best choice. Over time, though, we saw the PlayCanvas team releasing amazing features while the support for the viewer we were using slowly faded away. When PlayCanvas released the SOGs demo, it was the last nail in the coffin and we started the refactor.

The performance gains have been massive. If you load the same .ply in PlayCanvas versus our original viewer, the frame rate nearly doubles, and memory usage is reduced by 80%. If you compare SOGs to our previously most optimized format, the SOGs bundle is half the size with 3SH compared to 2SH and uses 88% less memory. Some critical resources consume over 95% less memory. So, yeah, we’re happy we made the switch.

Were there any technical challenges you faced integrating PlayCanvas with 3DGS, and how did you overcome them?

In Ha: Well, we had to refactor the core of the application. We were moving a three.js-based application to a PlayCanvas-based application. We essentially had to rebuild every feature that was related to the viewer since the previous application was based on three.js - which is a common library that is used for 3D rendering on the web, and because we were using open source libraries built on top of three.js, a lot of refactoring was needed to adapt functionality to PlayCanvas and remove those external dependencies.

But we realized that essentially, the fundamentals are the same. They provide 3D renderers, which means they have 3D spaces, a camera, and some 3D objects (in this case, splats). PlayCanvas provides simple ways to control cameras and assets, and if we can read and write them, it doesn’t make much difference.

So we first detached every piece of the UI and event listeners, then replaced the core renderers, then everything followed naturally.

Can you share any interesting performance optimizations you’ve implemented in Reflct?

In Ha: We had done a reasonable amount of optimization work with the previous viewer, but the impact of those changes was trivial compared to moving to PlayCanvas.

Willie: One thing that seems minor is the size of the viewer. A smaller viewer means fewer pixels to move around and less resource usage. People want big viewers, though, so we spent some time looking for the right balance between performance and visual impact.

Reflct just launched after being in open beta — how has the feedback been so far?

Willie: The feedback has been quite positive, which is validating. Now that we are using the PlayCanvas engine, I think it will be even better. The performance improvement makes the application far more accessible.

Who do you see as the ideal audience or customer for Reflct?

Willie: It's 3DGS capture pros who want to find a better way to commercialize their work, brands that want to elevate their product visualization, real-estate startups, or companies that are looking for an edge.

What are your plans for upcoming features or improvements?

Willie: First thing will be some improvements for mobile, just to improve consistency across devices. Then it’s integrations, viewer features, FTUX improvements, and building on our recent update for custom transition animations.

How can the PlayCanvas community try out Reflct or get involved?

Willie: It's free for up to 15 scenes on https://reflct.app, so just jump in and try it out. If you have any ideas for improving the platform or seeing what we’re cooking up next, join the Discord; we’d love to hear from the community.

Where do you see 3DGS and web-based photorealistic content heading in the next few years?

Willie: The pace of innovation in 3DGS and other similar technologies is wild, but the trends seem to be around increasing quality, decreasing file sizes, and making the capture process simpler. Generative AI will also start to play a more significant role I’m sure, some of the recent experiments with generating 3DGS scenes using outputs from world models like Genie have been very impressive. I’d like to see some progress towards solving some of the drawbacks, like reflective surfaces.

In Ha: I can see 3DGS becoming a general way of displaying rich, interactive, and impactful content.

Any advice for developers looking to build commercial products on PlayCanvas?

In Ha: It is always important to just try things out. See what works and what doesn’t. Gather metrics and list out pros and cons. See if it solves your problem. Eventually, you will learn what is possible with PlayCanvas.

Willie: Yeah, just get stuck in. PlayCanvas’ approach to open source is admirable.

What’s been the most rewarding part of building Reflct so far?

In Ha: As we've been rolling out Reflct to the world, the most rewarding part has been the users and the community. When I see a user’s strikingly realistic content on Reflct, that’s the most rewarding for me.

Willie: I'm just really proud of the product we’ve built together, it’s an awesome feeling.

Thanks for chatting with us, In Ha and Willie!

The PlayCanvas Editor is a powerful visual editing environment for building WebGL, WebGPU, and WebXR applications. It has been the cornerstone of countless incredible projects, many of which you can explore on the PlayCanvas website. While the PlayCanvas Engine has always been open source, the Editor Frontend, a key component of the PlayCanvas ecosystem, has not. That changes today!

✅ Why Open Source the Editor Frontend?​

Open sourcing the Editor Frontend brings a host of benefits, not just for us, but for the entire PlayCanvas community:

• Faster Feature Development: Community contributions will accelerate the development of new features and improvements.
• Enhanced Stability: With more eyes on the code, bugs can be identified and resolved more quickly, leading to a more stable and robust editor.
• Customization and Bespoke Use Cases: Developers can now create custom Editor Frontend versions, connecting them to our backend for highly specialized workflows and integrations.
• Improved Understanding: A more transparent codebase will allow developers to better understand how the Editor functions, making it easier to contribute and debug.

🛠️ Local Development & Contributing​

We've made it easier than ever to get started with local development and contribute to the Editor Frontend. For detailed setup instructions, please refer to the README in the repository.

Built on Open Source Foundations​

The PlayCanvas Editor is built upon a foundation of powerful open-source libraries:

We've focused on significant improvements to the codebase to make it more accessible for contributors, including:

• Code Reorganization: A clearer, more efficient file and code structure.
• Improved Typings: Enhanced TypeScript support for better type checking and code integrity.
• Optimized Debugging: Streamlined local debugging processes for a smoother development experience.
• Comprehensive Testing Suite: A new testing suite ensures stability and helps prevent regressions with new contributions.

👨‍💻 Join Our Open Source Mission​

We proudly provide the PlayCanvas Editor Frontend as an open-source project. This is just the beginning of a new chapter for the Editor, and we invite you to be a part of it. The PlayCanvas community has always been at the forefront of innovation, and we believe that this open-source initiative will further accelerate our collective progress.

Join us in shaping the future of the PlayCanvas Editor by submitting issues, creating pull requests, or simply starring our GitHub repo! ⭐

👂 Your Feedback Matters​

We're incredibly excited about this new phase for the PlayCanvas Editor. Your feedback is invaluable as we continue this open-source journey. What features are you most excited to contribute to, or what would you love to see next? Share your thoughts on our Forum or ping us on X!

When 3D Gaussian Splats began to revolutionize real-time rendering and photorealistic 3D content creation, we built SuperSplat, a visual editor for splats. But developers have continued to ask for better tools to manage, convert, and optimize their splat datasets. Our solution is to bring some of SuperSplat's most powerful features to the command line, courtesy of a new tool called SplatTransform. It's fast, flexible, and designed specifically for developers who need precise control over their Gaussian splat workflows.

Why use SplatTransform?​

SplatTransform solves important problems developers face when working with Gaussian splats:

🔄 Broad Format Support — seamlessly convert between PLY, SPLAT, KSPLAT, SOGS and even CSV
🛠️ Powerful Transformations — translate, rotate, and scale your splats with precision
🧹 Smart Filtering — remove NaN values, filter by properties, and strip unnecessary data
📦 Scene Merging — combine multiple splat files into a merged scene
⚡ Production Ready — optimized for maximum performance
🆓 Open Source — completely free and available on GitHub

What it Looks Like​

Instead of wrestling with format incompatibilities or writing custom scripts, you can now handle complex splat operations with simple, intuitive commands:

# Convert between commonly used splat formats
splat-transform input.ksplat converted.ply

# Apply transformations during conversion
splat-transform input.ply -s 0.5 -t 0,0,10 -r 0,90,0 transformed.ply

# Combine multiple files with different transforms
splat-transform inputA.ply -r 0,90,0 inputB.ply -s 2 merged.ply

# Filter and optimize for production
splat-transform input.ply --filterNaN -c opacity,gt,0.3 --filterBands 2 filtered.ply

The tool automatically handles the complexity of different splat formats while giving you granular control over every aspect of the transformation pipeline.

Unlock Data Science Workflows with CSV Export​

One of SplatTransform's most powerful features is its ability to export Gaussian splat data to CSV format, opening up entirely new possibilities for analysis and processing:

# Export your splat data for spreadsheet analysis
splat-transform scene.ply data.csv

# Pre-filter before analysis to focus on relevant data
splat-transform input.ply --filterNaN -c opacity,gt,0.1 analysis.csv

Why CSV matters for splats:

• Spreadsheet Analysis — Import directly into Excel, Google Sheets, or any data analysis tool
• Statistical Insights — Calculate distributions, correlations, and quality metrics across your splat dataset
• Custom Filtering — Use spreadsheet formulas to identify outliers, cluster data, or segment by properties
• Visualization — Create charts and graphs to understand your splat data patterns
• Integration — Feed splat data into machine learning pipelines or custom processing workflows

Whether you're optimizing splat quality, analyzing capture patterns, or preparing data for research, CSV export transforms your splats from opaque binary files into readable, analyzable datasets.

SplatTransform ❤️ PlayCanvas​

The open-source PlayCanvas Engine has the most advanced 3D Gaussian Splat renderer on the market! First, we released our Compressed PLY format. Then, we improved on it by adding support for SOGS, an even more optimal compressed format. SplatTransform can now target both formats with ease.

Get Started Today​

SplatTransform is available right now on npm and completely open source:

npm install -g @playcanvas/splat-transform

Check out the GitHub repository for full source, documentation and examples. If you find a bug or have a feature request, log an issue or better yet, submit a pull request! 🙌

We're excited to see what you build! 🚀

Back in 2016, we introduced what we now call Classic Scripts. At the time, this represented the state of the art in JavaScript. But things have evolved rapidly since then, and developers today expect modern tooling, clearer patterns, and better integration with the broader JavaScript ecosystem.

If you’ve ever struggled with managing classic scripts, wondered why your auto-complete didn’t work, or wished you could reuse code across projects more easily — this is for you.

ESM (ECMAScript Modules) brings modern JavaScript development to the heart of PlayCanvas. It’s faster to get started, easier to scale your project, and way more fun to work with. No more hidden globals. No more messy script loading order. Just well-structured, maintainable, and modular code — exactly how modern web development should be.

Why use ESM Scripts?​

ESM Scripts offer major improvements across the board:

💡 Modern JavaScript — use import, export class based module syntax
🧠 Smarter Editor — better auto-complete and inline docs
🧱 Modular Codebase — structure large projects cleanly with reusable modules
⚙️ No Global Scope Issues — each script has its own context
📦 Import Maps — define aliases and pull in libraries from CDNs
🚀 Optimized for Production — static imports enable bundling and future support for tree-shaking

What it looks like​

Instead of attaching scripts to an entity and hoping things load in the right order, you now write self-contained, class-based modules like this:

import { Script } from 'playcanvas';

export class Rotator extends Script {
    static scriptName = 'rotator';

    /**
     * @attribute
     * @range [0, 10]
     */
    speed = 5;

    update(dt) {
        this.entity.rotateLocal(0, this.speed * dt, 0);
    }
}

The Editor picks up your scriptName, exposes your attributes automatically, and everything behaves as expected — no magic, no legacy syntax.

Real benefits for real projects​

We didn’t just add ESM support because it was shiny. We added it because it solves real problems PlayCanvas developers have told us about for years.

• You get stronger editor feedback while writing code.
• You can reuse logic cleanly across multiple scripts.
• You can share modules between projects or publish them as libraries.
• You’ll write fewer bugs — and spend less time wrestling with script order or context issues.

Plus, by adopting a standard that the rest of the JS world already embraces, it’s easier than ever to onboard new developers and bring in existing tools and libraries.

Seamless integration without disruption​

Don’t worry — classic .js scripts aren’t going anywhere. If you have an existing project using them, everything still works. You can even mix classic and ESM scripts in the same project.

But going forward, ESM Scripts are the best choice for all new projects — and we think once you try them, you won’t want to go back.

Try It Today​

You can start using ESM Scripts right now — just create a script with a .mjs extension and enjoy everything modern JavaScript has to offer.

Check out the user manual for examples, or drop into the PlayCanvas Forum to share your thoughts.

We can’t wait to see what you build.

To showcase PlayCanvas' support for SOGS, we have collaborated with Christoph Schindelar to build a technical demo:

RUN FULLSCREEN IN A NEW TAB

The church scene above was originally a 1GB PLY file containing 4 million Gaussians - not at all suitable for the web or mobile! Using SOGS, we can serve up the scene in just 55MB! Read on to find out how.

Introduction to Self-Organizing Gaussians​

3D Gaussian Splatting has taken the real-time graphics world by storm, offering breathtaking photorealism. But as many developers have discovered, the incredible detail comes at a cost: massive file sizes. A typical high-quality scene can easily run into hundreds of megabytes, making them challenging for web delivery, mobile experiences, and quick load times.

This is precisely the problem that Self-Organizing Gaussians, a groundbreaking compression technique from Wieland Morgenstern at Fraunhofer HHI, sets out to solve.

The Core Challenge: Taming the Data Deluge​

Each individual Gaussian in a 3DGS scene stores multiple parameters:

• Position (XYZ)
• Scale (3 values)
• Rotation (4 quaternion values)
• Opacity
• Base Color (RGB)
• Spherical Harmonics (SH) coefficients for view-dependent effects (often 45+ values, contributing a huge portion to file size – up to 75%!)

Storing all of these as high-precision floats is what leads to those hefty files.

Enter SOGS: Reshape, Reorganize, Compress​

Instead of just quantizing individual values or creating simple codebooks for attributes (which are valid but more traditional compression steps), SOGS takes a far more innovative approach, directly inspired by how image compression algorithms work best:

1. Grid Reorganization: The fundamental idea is to take all the Gaussians and their attributes and reshape this data. Imagine "unrolling" all the Gaussians and laying their parameters out into a series of 2D grids or "attribute images." For instance, all X positions could form one 2D image, all Y positions another, each SH coefficient its own image, and so on (e.g., 59+ such images if you have 59 attributes per Gaussian). Initially, these images would look like random noise.
2. The "Self-Organizing" Sort (PLAS Algorithm): Here's the magic. SOGS employs a sophisticated sorting algorithm (Parallel Linear Assignment Sorting - PLAS) to reorder the Gaussians themselves within these 2D grids. The goal is to arrange them so that Gaussians with similar properties (especially position, scale, and base color) become neighbors in the 2D grid. This process transforms the noisy, random-looking attribute images into much smoother, more structured images with lower frequency content.
   • Why sort? Compressing highly organized, smooth data (like a sorted image) is vastly more efficient than compressing noisy, random data. The difference can be dramatic (e.g., a 9x reduction for a sorted vs. random image with JPEG).
3. Exploiting Smoothness: By sorting based on primary attributes (position, scale, base color), SOGS leverages the insight that Gaussians similar in these aspects are also likely to have similar secondary attributes (opacity, rotation, and those bulky SH coefficients). This "co-sorting" makes all the attribute images smoother.
4. Leveraging 2D Image Compression: Once these attribute images are smooth and organized, SOGS applies standard, highly optimized 2D image compression codecs to each one. In PlayCanvas, we have opted to use WebP. This is where the massive compression gains come from – the WebP codec is perfect for compressing smooth, predictable image data. Check out the image set for the church:

The Impact for Splat Developers​

Integrating SOGS into PlayCanvas is a game-changer for web-based 3DGS:

• 🗜️ Massive File Size Reduction: We're talking serious compression! The church scene above, for example, was reduced from ~1GB to 55MB (a ~20x reduction).
• ⚡ Lightning-Fast Loading: Smaller files mean your immersive 3DGS experiences load significantly faster, keeping users engaged.
• 📱 Mobile Feasibility: This level of compression makes deploying rich 3DGS content practical even on bandwidth or memory-constrained devices.
• ✨ Exceptional Visual Quality: SOGS is designed to maintain the high visual fidelity that makes 3DGS so compelling, and can even improve it by reducing artifacts.
• 🖼️ Simple Decoding: The compressed format is essentially a set of WebP images, which are trivial and fast to decode using standard browser capabilities.

With SOGS support, PlayCanvas can deliver stunning, performant, and accessible 3D Gaussian Splat-based experiences directly in the browser. This is huge news for e-commerce, architectural visualization, education and entertainment industries.

What's Next​

PlayCanvas Engine support is just the first step. Here's what's coming next:

• Editor Support - Support SOGS data as a first-class citizen in the Asset Panel
• SuperSplat Support - Add SOGS as an export format
• Performance Optimization - Now that we can quickly load vast numbers of Gaussians on mobile, we will turn our attention to boosting frame rates

👨‍💻 Our Open Source Mission​

We proudly provide the PlayCanvas Engine as an MIT-licensed open source project. The 3D Gaussian Splat community has made impressive strides over the past 18 months, largely due to open collaboration. Join us in shaping the future by submitting issues, creating pull requests, or simply starring our GitHub repo! ⭐

👂 Your Feedback Matters​

We hope you approve of this latest update to our open source journey! The SuperSplat community has grown tremendously, and your feedback is invaluable. What features would you love to see next? Share your thoughts on our Discord or ping us on X!

Since its initial release back in November 2023, SuperSplat has grown to be the most popular platform for editing and publishing 3D Gaussian Splats.

It allows you to publish your splats to our superspl.at domain or download the SuperSplat Viewer for self-hosting. Regardless of which option you choose, you get the same viewer experience, giving you total flexibility. But while the SuperSplat Editor has been open source from the beginning, SuperSplat's web-based viewer has not. That changes today with the release of the viewer on GitHub (under the MIT license).

✅ Viewer Features​

So why use the SuperSplat Viewer to publish your splats? There are a lot of great reasons! Here is a run down:

• 🏃 Performance - it is built on the powerful PlayCanvas Engine which delivers high frame rates.
• ✨ Visual Fidelity - the PlayCanvas Engine's advanced 3DGS shaders ensure top quality visuals.
• 🤳 AR Support - view your splat in your space in mixed reality.
• 🥽 VR Support - experience your splat in full immersion using any WebXR-capable headset.
• 🎬 Animation - play back attractive camera fly-throughs for your scenes.
• 🖥️ Fullscreen Support - take your splats fullscreen with the click of a button.
• 🎥 Camera Modes - switch between orbit and fly cameras, tuned for both mobile and desktop.

And this is just the beginning. We have ambitious plans for the viewer with exciting features just around the corner. So what's next? Well, one feature we are excited about is annotations, meaning you will be able to place informational panels within your scenes. Subscribe to the repo to get notified about new releases.

👨‍💻 Our Open Source Mission​

We proudly provide the SuperSplat Viewer as an MIT-licensed open source project. The 3D Gaussian Splat community has made impressive strides over the past 18 months, largely due to open collaboration. Join us in shaping the future by submitting issues, creating pull requests, or simply starring our GitHub repo! ⭐

👂 Your Feedback Matters​

We hope you approve of this latest update to our open source journey! The SuperSplat community has grown tremendously, and your feedback is invaluable. What features would you love to see next? Share your thoughts on our Discord or ping us on X!

SuperSplat is your open source platform for editing and publishing 3D Gaussian Splats. This update introduces video rendering for your splats, alongside numerous other improvements. Let's dive in!

🎞️ Video Rendering​

The SuperSplat Editor is a powerful application for cleaning up, optimizing and publishing your 3DGS scenes. With today's update, you can now render high-quality videos directly from your camera animations set up on the Timeline. The new functionality can be accessed via the new Render menu in the menu bar.

Choose your resolution, set your bitrate, and even render vertical videos optimized for mobile viewing. Video encoding is impressively fast — try it yourself and experience the speed! ⚡

👥 Social Splats​

The SuperSplat site launched exactly 1 month ago. Since then, we have added a raft of new features that makes gives you a much more social experience.

👥 User Pages​

You can now showcase your splats on your own user page! When you find a splat that inspires you, click on the creator link and browse their work. Lots of creators have already inspired us! For example, tipatat has published a smorgasbord of culinary delicacies:

Here are some other awesome user pages for you to visit:

• Studio Duckbill - beautiful locations in Japan with great camera animations.
• Epigraph - realistically rendered splats of products.
• Simon Bethke - talented 3DGS enthusiast showcasing various objects and locations in Germany.

Go explore and see what else you can discover! 🔍

💬 Comments​

You can now leave your thoughts or ask questions under any splat!

🔄 Social Sharing​

You can easily share any splat to your favorite social channels: X, LinkedIn, Slack, email...you name it!

🔗 Splat Embeds​

You can now embed any splat on SuperSplat on your own website! Here's an gorgeous example from world-class 3DGS creator Christoph Schindelar - YES, IT'S INTERACTIVE AND NOT A VIDEO! 😆

To create an embed:

• Hit the Embed button
• Copy the HTML code
• Insert it at the appropriate place on your own site

📺 Viewer Enhancements​

The SuperSplat Viewer embedded above has been heavily enhanced in the month since launch. Here's a quick overview of what's new:

• Progress Bar: Easily scrub through your scene’s animations.
• Camera Settings: Quickly switch between Orbit (ideal for objects) and Fly (ideal for locations) camera modes via the cog icon.
• Redesigned Info Panel: Comprehensive usage instructions for both desktop and mobile.

👨‍💻 Our Open Source Mission​

We proudly offer SuperSplat as an MIT-licensed open source project. The 3D Gaussian Splat community has made impressive strides over the past 18 months, largely due to open collaboration. Join us in shaping the future by submitting issues, creating pull requests, or simply starring our GitHub repo! ⭐

👂 Your Feedback Matters​

We hope you love this update as much as we enjoyed creating it! The SuperSplat community has grown tremendously, and your feedback is invaluable. What features would you love to see next? Share your thoughts on our Discord or ping us on X!