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 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, SuperSplat (and splat-transform) write out a folder of SOG chunks plus a 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 -K / --collision-mesh. It voxelizes the splat, flood-fills the navigable interior from a seed position, and writes out a watertight .collision.glb that you can import straight into PlayCanvas as a mesh collider.

splat-transform scene.ply \
  --seed-pos 0,1,0 \
  --voxel-params 0.05,0.1 \
  --voxel-carve 1.6,0.2 \
  -K \
  scene.sog

That one command gives me two outputs:

• scene.sog - a single-file compressed splat for quick iteration; the shipped build uses the streamed folder from Step 2.
• scene.collision.glb - a voxel-derived mesh that hugs the real geometry.

I dropped both into the PlayCanvas project and attached the GLB 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 modelling, 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 popularised 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(retreat), hasPickupsNearby, goToPickup)] : []),
            ...(traits.lootPriority > 0.7   ? [sequence(hasPickupsNearby, goToPickup)] : []),
            ...(traits.retreatThreshold > 0.3 ? [sequence(hpBelow(retreat), retreat)] : []),
            ...(traits.aggression > 0.2     ? [sequence(hasEnemiesInRange(range), 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 -K → .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!

🏠 We've Moved​

SuperSplat can now be found on a shiny new domain! From now on, point your browser at:

The SuperSplat Editor that you know and love can now be accessed at https://superspl.at/editor. Much easier to remember, don't you think?

🌐 Publish your Splats to the Web​

Recently, we added the ability to export an HTML viewer of your splat from the SuperSplat Editor. Built on the powerful PlayCanvas Engine and our open source Compressed PLY format, it offers fast load times and high-performance rendering. However, hosting the HTML viewer was still your responsibility. And let's be honest, not everybody has the time or expertise to host their own website. So we've added a new feature to SuperSplat to make it easier to share your splats with others.

It's as easy as 1-2-3:

1. Log in with your PlayCanvas account (or sign up if you don't have one).
2. Select File > Publish when you've finished crafting your splat.
3. Fill out the publishing options form and hit Publish.

That's it! Your splat will be published to the web and you'll be given a URL to share with others.

🎥 Create Camera Flythroughs​

Sure, it's great to be able to share your splats with others, but for that extra 'wow' factor, why not add a camera flythrough? SuperSplat Editor 2.0 introduces the Timeline that makes it a breeze to author great looking camera animations. Simply select a frame in the timeline, position the camera, and set a keyframe. Do this for as many frames as you want and you've got a camera flythrough!

📄 Load and Save your SuperSplat Projects​

With the ability to create camera animations, your splat projects are becoming more and more complex. To support this, we've added a new project file format so you can save your work between sessions. The extension of SuperSplat's new project file format is .ssproj.

The introduction of the new project file format has also prompted us to reorganize the File menu. Open, Save and Save As now only operate on .ssproj files. To import and export other file formats into your project (such as .ply or .splat) you can use the Import and Export options in the File menu.

👥 Explore Splats from the Community​

With the ability to publish splats to the web, superspl.at has become a great place to explore the work of the Gaussian Splat community. Browse or search digitized reality from creators around the world.

View Splats in Immersive AR and VR​

One of the coolest things about the PlayCanvas-powered web viewer is that it's fully integrated with WebXR, the browser-based standard for immersive experiences. Simply tap the viewer's AR button and you can spawn photorealistic 3D models directly into your environment.

Or dive straight into a splat in fully immersive VR.

👨‍💻 Our Open Source Mission​

We are proud to bring SuperSplat to you as an MIT-licensed open source project. The 3D Gaussian Splat community has come a long way in the last 18 months and much of that progress is thanks to the OSS community. So it's important to us that we play our part. But we're stronger together, so please do consider joining our open source effort. Submit issue reports, open pull requests...or just help us out by starring our repo! ⭐

👂 Your Feedback Matters​

We hope you love today's update! We put our heart and soul into this release and we're excited to share it with you.

The SuperSplat community has grown a lot over the last year and we want to get your feedback. What other features would you like to see added to the platform? Let us know on the Discord or ping us on X!

Today we're proud to announce the release of PlayCanvas React, a new declarative way to build 3D content using React.

PlayCanvas React is a thin React wrapper around the PlayCanvas API. It allows you to build rich 3D content in a declarative way that fully integrates with the React ecosystem. You can create rich, complex 3D content with assets, physics, gaussian splats, audio, and more, all while leveraging the powerful state management of React.

Check out the CodeSandbox below. Slide open the code editor and play with the code in real time.

What does this look like?​

With @playcanvas/react you create a scene using entities and components, just like you would in the PlayCanvas Editor or Engine. Entities have position, rotation and scale. They're the building blocks of your scene. Components on the other hand add behavior to an entity. For example, adding a <Render/> component to an entity allows it to render a mesh.

import { Application, Entity } from '@playcanvas/react';
import { Script as PcScript } from 'playcanvas';

// This script spins the entity it's attached to
class Spinner extends PcScript {
  update(dt) {
    this.entity.rotate(0, this.speed * dt, 0)
  }
}

/**
 * Your first @playcanvas/react example! 
 * This renders a spinning box with a camera and some lighting.
 */
export const HelloWorld = () => {

  const material = useMaterial({ diffuse: 'gray' })

  return <Entity>
    {/* Create a camera entity */}
    <Entity name='camera' position={[4, 3, 4]}>
      <Camera clearColor='#111111' fov={28} />
    </Entity>

    {/* Create the spinning box entity */}
    <Entity position={[0, 0.5, 0]}>
      <Render type='box' material={material} />
      <Script script={Spinner} speed={10}/>
    </Entity>
  </Entity>
};

If you’re already familiar with the PlayCanvas API, you’re already off to a good start! You’ll see that any component system available in the engine can be used out of the box including rigid bodies, collision, physics etc. Follow our Getting Started Guide and you'll be up to speed in no time.

If you're coming from a React background, you'll find it easy to integrate with existing React projects. Even if you’re new to PlayCanvas, you can pick up the basics in just a few hours.

Why React?​

React is loved by developers because it makes building user interfaces simple, intuitive, and predictable. With PlayCanvas React, you can now apply the same magic to 3D! Instead of writing complex, imperative code to create and manage 3D scenes, you can describe them declaratively, just like you do with HTML for a webpage. React’s component-based approach also makes it easy to reuse and organize your 3D content, so you can focus on creativity instead of boilerplate.

What about the Editor and Engine?​

• The PlayCanvas Engine underpins everything. PlayCanvas React is simply a thin wrapper around the engine with a React friendly syntax. There's no strict rule for using one over the other, but if you're familiar with React and its ecosystem, you'll find PlayCanvas React fits well with your stack.

• The Editor on the other hand is a powerful browser-based tool for building rich 3D content. PlayCanvas React is another way of achieving the same goal. Whilst the Editor provides a full suite of tools for asset management, scene organization, and rapid iteration, PlayCanvas React is more about building 3D content from within your React code. If you enjoy a code-centric workflow or want to integrate 3D content directly into a larger React application, PlayCanvas React may be the perfect fit.

Open Source FTW​

PlayCanvas React is completely open source, licensed under the MIT License. We believe that by sharing our work, collaborating with the community, and encouraging contributions, we aim to build a robust ecosystem.

If you find a bug, have a suggestion, or want to contribute, feel free to open an issue or submit a pull request. We welcome your feedback and ideas!

A new step for 3D​

The library is already being used in production! Snap AI from Snap Inc — an app for generating 3D assets from text — is built on PlayCanvas React:

To get started you can follow the installation and getting started guide, then check out the repo and explore some of the examples in the live playground.

Happy coding!

For the full details, visit our GitHub:

RELEASE NOTES

It's not every day we do a major version bump of the Engine. Let's take a walk down memory lane to see how we got here:

• October 2010: Coding of the Engine begins!
• 24 October 2011: Engine migrated to GitHub
• 4 June 2014: Engine goes open source
• 24 April 2018: Engine hits 1.0.0

Back in 2018, the Engine was bumped to 1.0.0 because we adhere to semantic versioning which dictates:

If your software is being used in production, it should probably already be 1.0.0. If you have a stable API on which users have come to depend, you should be 1.0.0. If you’re worrying a lot about backward compatibility, you should probably already be 1.0.0.

With hindsight, the Engine should probably have reached 1.0.0 some years before. It had long been stable and was already being used heavily in production!

Why Bump to 2.0.0​

Semantic versioning says that you perform a major version bump when you introduce breaking changes. To say we go out of our way to avoid introducing breaking changes in an understatement. But since 1.0.0, we had done 73 minor versions along with countless patch releases. Along the way, the Engine accumulated a considerable amount of "cruft".

It was getting to the point where parts of the codebase were restricting our ability to advance the Engine's capabilities. And so, we took to the decision to do a spring clean. 🧹 Here are some highlights of what we removed:

• WebGL 1 support. This is the big one. Today, devices that support WebGL 1 but not WebGL 2 is less than 2% and this number is only going to get smaller. And supporting WebGL 1 was making it extraordinarily difficult to construct the foundations we needed in order to support WebGPU. Cheerio, WebGL 1 - it's been fun! 👋
• Scripts 1.0 support. The very first ScriptComponent implementation was deprecated with the introduction of Scripts 2.0 back in 2016. So after 8 years of deprecation, it's gone! We are now focused on delivering our new ESM-based scripting system, due soon.
• AudioSourceComponent. This component was the precursor to the Engine's SoundComponent. AudioSourceComponent has been deprecated for many years so it's time for it to go.
• ...and several other public API symbols. What we are left with is a cleaner, tighter codebase that can power us into the future!

What if my Project Breaks​

Never fear! Today's release is more relevant to 'Engine-only' users who pull the engine from NPM. At a time of their choosing, these developers can upgrade to 2.0.0 and give it a try. The vast majority of projects will update without modification.

Editor users will gain access to Engine 2.0.0 in the coming weeks. At that point, moving to 2.0.0 will be opt in for existing projects. We plan to support the last Engine 1.x release in the Editor for at least a year after Engine 2 becomes available. This should be plenty of time for developers to migrate. New projects will automatically use 2.0.0. We will release more information about the transition for Editor users in the coming weeks.

In the meantime, we ask NPM users to try Engine 2.0.0 and give us your feedback as soon as you can. We hope you like it! Head over to the Forum, Discord or GitHub to have your say. 👂

What's New​

The 2.0.0 release isn't just about breaking changes! We have some exciting features to announce by way of some brand new Engine examples:

Check 'em out:

• Custom Shaders: Cross Hatching
• Custom Shaders: Used with Skinning and Instancing
• Screen Space Ambient Occlusion
• Hardware Instancing
• glTF Hardware Instancing Extension

Thanking the Open Source Community​

We could not have reached this point without the amazing open source community:

Thank you for your incredible contributions. 🙏

CLICK HERE to open in a new tab. Credits: Splats scanned at the V&A Museum. HDRI from Poly Haven.

We have big news for the 3D Gaussian Splat community - the PlayCanvas Editor now has fully integrated support for splats! Learn how to quickly build stunning, interactive 3DGS applications today.

The application above shows several splats assembled in a single application, with animation and post effects spicing up the visuals. Let's check out how it was built.

Step 1: Clean in SuperSplat 🧹​

After capturing the statues to PLY format, our first stop is SuperSplat, the open source tool for editing and optimizing 3D Gaussian Splats. Here, in a little over a minute, we can isolate the statue from the background and align it with the origin:

Once we are done, we can download the splat using our compressed PLY format. In this case, our downloaded PLY is only 1.56MB!

Step 2: Import into the Editor 🚧​

Now that we have a clean, compressed PLY, we simply need to drop it into the Editor's Asset Panel. And from there, drag it into the viewport to add it to the scene. Let's do that (along with a cube map for a photographic backdrop):

The PlayCanvas Editor is a powerful visual environment for building and publishing 3D scenes. You can:

• Grab useful scripts (and other assets) from the Asset Store. Here, we import an Orbit Camera script.
• Create beautiful user interfaces, using either HTML or PlayCanvas' built-in UI system.
• Add sound, physics, VR/AR support and much, much more.

Step 3: Add Animation and Post Effects ✨​

What really makes the demo pop is the transitions that fade the statues in and out.

With the Editor, you can customize the shader code that renders your splats to apply stunning animation effects. For the transition between statues, individual splats are transformed and recolored over time, while a full-screen bloom effect is ramped up and down.

Resources​

Today's release makes working with 3D Gaussian Splats both easy and fun! We've shown you how to build a virtual gallery or museum but the possibilities are endless. With 3D Gaussian Splats in the PlayCanvas Editor, you can target many verticals: product visualization (furniture, clothing, consumer electronics), automotive, education, travel and so much more.

To get started, here is an useful list of resources:

• Statue Project - feel free to fork it, explore and experiment.
• 3D Gaussian Splatting User Guide
• SuperSplat (don't forget to install the PWA)

Go Forth and Create​

We hope you love today's update as much as we do! ❤️

But let us know what you think by heading over to the forum or ping us on X!

Version 0.17.1 focuses on two key areas: performance and PWA support.

Performance Improvements​

SuperSplat is now over 2x faster on the GPU! 🏃

Compare before and after (notice GPU time dropping from 32ms to 13.5ms for the bike scene):

This is thanks to the v1.71.0 release of the PlayCanvas Engine, which includes a dramatic overhaul of how splats are processed by the GPU. For the technical details, take a look at this pull request.

The result is that SuperSplat can now throw around millions of splats and still maintain a silky smooth frame rate. Try it for yourself!

PWA Support​

A Progressive Web App (PWA) is a web application that provides a native app-like experience, including the ability to install it on a user's home screen or desktop.

From today, SuperSplat is shipping with PWA support! 🎉

To install SuperSplat as a PWA:

1. Visit https://playcanvas.com/supersplat/editor.
2. Hit the Install SuperSplat button in the address bar.

PLY File Association​

With SuperSplat installed as a PWA, your operating system can now open launch PLY files directly into the tool. Simply right-click on a PLY file and select SuperSplat to open it.

You can also set SuperSplat as the default tool to open your PLYs. Then, you can simply double-click a PLY file to open it instantly in SuperSplat!

Your Feedback Matters​

We hope you love today's update! ❤️

The SuperSplat community has grown a lot in recent weeks and we want to get your feedback. What other features would you like the PWA to get? Are you still experiencing any performance problems? What is still missing from SuperSplat? Let us know by heading over to the forum or ping us on X!

WebGPU on the Rise​

Since its inception back in 2010, PlayCanvas has been layered on top of WebGL. In 2017, we were proud to launch support for WebGL 2.0 in partnership with our friends at Mozilla. April 2023 marked the beginning of a new era for web graphics when Google enabled WebGPU by default in Chrome 113. Since then, WebGPU adoption has exploded and today, Web3D Survey reports that 62.19% of end users can now run WebGPU. With Firefox and Safari due to launch their WebGPU support in the not-too-distant future, expect this number to rise dramatically in 2024.

Why WebGPU Matters​

If you enable WebGPU for your PlayCanvas project, you may not notice much difference to begin with. In fact, we have put a great deal of effort into ensuring your WebGL projects look identical under WebGPU. But over time, there is are a great deal of opportunities to achieve performance improvements due to WebGPU's reduced driver overhead.

Another key feature unique to WebGPU is support for Compute Shaders which allow for general computation on the GPU. Support for Compute Shaders landed in Engine v1.70.0. Here you can see Computer Shaders in action simulating 1 million particles on the GPU:

Click here to run it for yourself in a WebGPU-enabled browser (i.e. Chrome or Edge).

In short, WebGPU represents the future for PlayCanvas and you can expect some incredible advances in performance and functionality over the coming months.

Getting Started with WebGPU​

WebGPU support in PlayCanvas is still considered 'Beta'. There are still some unimplemented features (for example, the run-time lightmapper is still not supported). Therefore, you have to currently 'opt in' to WebGPU support. To do this, open your Project's Settings in the Inspector and expand the RENDERING section. Then update Graphics Devices to include WebGPU (beta).

Once we are satisfied WebGPU support has matured enough, it will become the default.

Your Feedback is Important​

Since WebGPU support is new, we rely on the community for feedback. What works and what doesn't? Please submit an issue if you discover any problems or kick off a new thread on the forum if you want to discuss WebGPU support in more detail. We want to hear what your opinions! 👂