The free, browser-based 3D Gaussian Splat editor — inspect, edit, crop, optimize and publish splat scenes without installing anything.
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.
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.
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.
No Code Platforms · AI Development · Developer Tools
Visual LLM workflow platform with RAG pipelines, agent capabilities, and model management for building production AI applications.
Developer Tools · Game Development · Design Tools
Free, MIT-licensed 2D and 3D game engine with one-click multi-platform export and no royalties.
Design Tools · Productivity
The offline-first diagram editor that puts security above all else — no account, no data leaving your machine, no compromises.