SuperSplat

SuperSplat is a fully open source, web-based editor for 3D Gaussian Splats (3DGS), the radiance-field rendering format that has rapidly become the go-to method for capturing real-world scenes at photorealistic quality. Built on PlayCanvas and WebGL/WebGPU, it runs entirely in the browser — there is nothing to download, compile or install. You open a .ply file, manipulate your splats, and export or publish the result in seconds.

The editor ships an unusually deep feature set for a free tool: multi-layered selection (box, lasso, polygon, brush, flood fill, sphere), full undo/redo history, per-splat transform palettes, color grading controls (temperature, saturation, brightness, black/white points), an animation timeline for camera paths, and one-click publishing to superspl.at. Data processing runs on the GPU via custom WebGL compute shaders so that operations on scenes with millions of Gaussians remain interactive.

SuperSplat’s open architecture also makes it embeddable — an iframe postMessage API lets other web applications query and control an embedded editor instance, which has made it the foundation for several commercial and research platforms in the 3DGS ecosystem. It handles the full splat lifecycle from import through editing to compressed export in the .sog format (a ZIP-based optimized container), GZipped PLY, and standard PLY.

Activelyly maintained by the PlayCanvas team with releases roughly every two weeks, SuperSplat is now at v2.27 and continues to expand both its editing capabilities and its multi-format export pipeline, including WebP-compressed texture atlases and per-Gaussian spherical harmonics band selection.

What You Get

• Multi-mode selection tools — box, lasso, polygon, brush, flood fill, sphere, and eyedropper selection modes for precise Gaussian-level editing
• Full undo/redo history — command queue architecture tracks every edit operation so you can safely explore and revert changes
• Color grading controls — per-splat temperature, saturation, brightness, black point, and white point adjustments with live GPU preview
• Animation timeline — keyframe-based camera path editor with spline/step interpolation and loop modes for creating flythrough sequences
• Multi-format export — export scenes as standard PLY, GZipped PLY, optimized .sog format (ZIP container with WebP textures), or HTML embeds
• One-click publishing — integrated publish flow pushes scenes directly to superspl.at with title, description, and format options
• Spherical harmonics band control — choose how many SH bands to include on export to trade visual quality against file size
• iFrame embedding API — postMessage interface lets external web apps embed and control a SuperSplat editor instance programmatically
• Localization support — UI available in nine languages (English, French, German, Spanish, Portuguese, Japanese, Korean, Russian, Chinese Simplified)
• PWA installable — installs as a Progressive Web App and associates .ply files with SuperSplat on desktop and mobile operating systems

Common Use Cases

• Photogrammetry cleanup — scan a real-world object or location, load the exported .ply into SuperSplat, crop out background noise, remove floating artifacts, and export a clean scene
• Multi-scan merging — load several separately captured splat files, reposition them in 3D space with transform tools, and combine them into a single unified scene
• Portfolio publishing — artists and photographers capture Gaussian splats of their work and publish them instantly to superspl.at for shareable links on social platforms
• Research and prototyping — 3DGS researchers use the iframe API to embed SuperSplat inside their own web tools and drive editing operations programmatically
• Real estate and architecture — capture interior spaces with a 3DGS scanner, clean up the result in SuperSplat, and embed the final scene in a property listing page
• Camera path creation — define keyframe animation tracks in the timeline editor to produce smooth flythrough videos exported as video or animated sequences

Under The Hood

Architecture SuperSplat is structured as a layered browser application with a clear separation between an event-driven application core and the rendering subsystem. An Events class (extending PlayCanvas’s EventHandler) acts as the central message bus: modules register named functions and fire typed events rather than calling each other directly, which keeps the tool manager, selection tools, timeline, camera, and UI panels fully decoupled. A CommandQueue serializes async GPU operations so that data-processor passes (histogram calculation, AABB computation, GPU picking) execute in a defined order. Edit operations are modelled as reversible command objects collected in an EditHistory stack, giving the undo/redo system a clean abstraction over state mutations. The Scene class owns all Element instances (each splat is an Element) and drives PlayCanvas’s render loop, while the DataProcessor runs headless GPU compute passes off to the side.

Tech Stack The entire application is written in TypeScript targeting ES2022 and bundled with Rollup, with SCSS styles processed via PostCSS and Sass. The rendering engine is PlayCanvas 2.x, which provides the WebGL/WebGPU abstraction layer, entity-component system, and built-in GSplat rendering support. GPU data processing uses custom GLSL shaders compiled and dispatched through PlayCanvas’s low-level shader and render-target APIs. The UI layer is built on @playcanvas/pcui, the component library shared across PlayCanvas tools, providing panels, sliders, and input widgets. Splat serialization and format conversion are handled by @playcanvas/splat-transform, which supports PLY, GZipped PLY, SOG (a ZIP-based optimized container), and HTML embed output. Internationalization uses i18next with dynamic backend loading from static JSON locale files. The build produces a single-page static app deployable anywhere via the serve package.

Code Quality The codebase has no unit or integration test suite — the tsconfig explicitly excludes a debug.ts testing file, and no test runner appears in package.json. ESLint with the PlayCanvas team’s own config (@playcanvas/eslint-config) enforces code style, and TypeScript is set to strict noImplicitAny with null checks partially relaxed. The architecture is consistent and well-organized: modules are cohesive, the event-bus pattern is applied uniformly, and GPU shader files are cleanly isolated in a shaders/ directory. The DataProcessor and Splat classes carry thorough inline comments explaining the GPU buffer pooling design and per-splat state texture encoding. Type coverage is good for application logic but lighter around the PlayCanvas API boundaries where any casts appear. Continuous integration is not visible in the repository, though rapid release cadence (roughly every two weeks) suggests an active manual review culture.

What Makes It Unique SuperSplat is remarkable for being the first fully-featured, GPU-accelerated 3D Gaussian Splat editor that runs entirely in a web browser with no server-side computation. Most comparable tools require desktop installation or proprietary backends. The decision to offload heavy per-splat operations (selection by range, AABB recalculation, histogram analysis) to GPU compute shaders written in GLSL means the editor can interactively handle scenes with millions of Gaussians where CPU approaches would stall. The integration of spherical harmonics band selection during export — reducing output file size while visually matching quality targets — goes beyond what most open source splat tools expose. The iframe postMessage API is a genuinely unusual addition that enables SuperSplat to function as an embedded editing primitive inside third-party web platforms rather than just a standalone tool.

Self-Hosting

SuperSplat is released under the MIT License, which grants anyone the right to use, modify, distribute, and build commercial products on top of the editor without restriction. There are no copyleft conditions: you can embed SuperSplat in a proprietary application, white-label it, or ship it as part of a paid product without being required to open-source your own code. The only obligation is to retain the MIT copyright notice. This makes it one of the most permissive licenses available for self-hosters and commercial integrators alike.

Running SuperSplat yourself is straightforward operationally: it is a fully static single-page application with no backend, no database, and no authentication server. The build process produces a dist/ folder of HTML, JavaScript, CSS, and static assets that can be served from any web server, CDN, or object storage bucket. The only infrastructure requirement is HTTPS (needed for Service Worker registration and PWA functionality). There are no processes to keep alive, no database to back up, and no server-side dependencies — a self-hosted instance is as simple as uploading the build output to S3 or nginx. The optional “publish to superspl.at” feature connects to PlayCanvas’s hosted API, but self-hosters who omit publishing functionality have zero external service dependencies.

The trade-off compared to the hosted version at superspl.at is primarily around the publishing pipeline: the hosted editor integrates with PlayCanvas account management, scene versioning, and shareable URL generation, none of which are replicated in a self-hosted build unless you implement your own backend. There is no enterprise tier, SLA, or paid support channel — the project is community-maintained by the PlayCanvas team with support available through Discord, the PlayCanvas forum, and GitHub issues. Self-hosters take on responsibility for keeping their deployment up to date by pulling new releases, which ship roughly every two weeks.