Best Gaussian Splat Viewers in 2026

You can create a beautiful Gaussian splat in Postshot, Polycam, or Luma — but a .splat file on a server is useless to a client who doesn’t have a viewer. The whole point of the format is browser playback. This post compares the browser-based Gaussian splat viewers worth using in 2026, what formats each supports, where they break, and how to choose.

For the capture side, see Creating Gaussian Splats: Postshot, Polycam, Luma. For the underlying theory, see Gaussian Splats: The Next-Gen 3D Reconstruction.

Why browser viewers matter

A point cloud has Potree. A 3D Tiles dataset has CesiumJS. A GeoTIFF has any number of web map libraries. A Gaussian splat in 2023 had nothing — you trained the model on a research GPU and viewed it in a research GUI.

That changed quickly. By 2024 there were three or four credible WebGL renderers. By 2026 there are half a dozen, each with different strengths.

Why this matters: your client doesn’t have a desktop splat viewer. They don’t want to install Postshot to look at the deliverable. The only realistic delivery channel is “click a link in your browser, see the scene.” Pick the wrong viewer and the page either won’t load, won’t run at frame rate, or won’t display the splat correctly.

Want to try it now? Open a Gaussian splat in the browser — free, no signup, your file stays on your computer.

The viewers, compared

“Hosted only” means the viewer only loads splats hosted on that company’s servers — you can’t bring your own .splat to their viewer.

SuperSplat (PlayCanvas)

SuperSplat is PlayCanvas’s open-source Gaussian splat editor and viewer. Originally launched as an editing tool — crop, clean up floaters, re-export — it doubles as one of the strongest browser playback engines available.

Strengths:

• Open source under an MIT-style licence
• Embeddable as an iframe or via the PlayCanvas engine
• Mature editing tools (the editor side of the project is genuinely useful)
• Good mobile performance with smart Gaussian sorting
• Active development from a well-funded studio

Weaknesses:

• .spz support is partial — you may need to convert to .splat first
• No native .ksplat support
• Editor mode is heavier than pure playback; embed the playback build for client delivery

Best for: Production deliveries where you want a single viewer that works reliably across desktop and mobile and may double as an in-house editor.

Spark (Stoichast)

Spark is a relatively new WebGL2 splat renderer from Stoichast, focused on tight integration with React and Three.js applications. It’s lean, modern, and built around the .spz compressed format from Niantic.

Strengths:

• Best .spz support of any open-source viewer
• Lowest memory overhead I’ve measured
• Excellent mobile performance — iPhone 14+ runs 4-million-Gaussian scenes at 60 fps
• React-friendly API
• Active and responsive maintainers

Weaknesses:

• Smaller community than SuperSplat or mkkellogg
• Fewer editing or interaction primitives — it’s a renderer, not a platform
• Documentation is improving but still thinner than mature tools

Best for: Mobile-first delivery, where file size and battery cost matter. If you’re delivering to phones, Spark is the default choice.

mkkellogg/GaussianSplats3D (Three.js)

Mark Kellogg’s GaussianSplats3D is the most popular open-source Three.js splat renderer. It introduced the .ksplat format — a streaming-optimised packing of a .splat that loads faster and uses less memory.

Strengths:

• Best .ksplat support (it invented the format)
• Plays well with existing Three.js scenes
• Strong documentation and examples
• Handles multi-splat scenes (more than one splat in one viewer)
• Active maintenance with frequent updates

Weaknesses:

• Mobile performance varies — older iOS devices struggle with larger scenes
• No .spz support yet
• Slightly heavier setup than Spark for a pure-splat use case

Best for: Custom web apps already built on Three.js, or where multiple splats need to be composed in one scene.

Niantic Scaniverse Web

Niantic’s Scaniverse app is a major mobile capture platform and has a paired web viewer. The viewer is closed source but is the most polished mobile splat experience available — Niantic also publishes the .spz format that other viewers are now adopting.

Strengths:

• Outstanding mobile performance
• Best-in-class .spz decoding
• Smooth, branded sharing UX

Weaknesses:

• Closed — only loads splats captured in Scaniverse
• No path to embed in your own page
• Not a viable choice for delivering splats captured in Postshot, Polycam, or Luma

Best for: Scaniverse users sharing within the Niantic ecosystem. Not useful for arbitrary splat delivery.

Polycam and Luma web viewers

Both Polycam and Luma host their captured splats on their own infrastructure with their own web viewers. The UX is decent and the viewers handle the splats they generate well.

Strengths:

• Zero setup — capture in the app, share the link
• Mobile-friendly
• Built-in branding from the platform (Polycam logo, Luma logo)

Weaknesses:

• Locked to the platform — you can’t view a Postshot splat in Polycam’s viewer
• Not white-labelled — your client sees Polycam or Luma branding
• Limited control over playback (no custom embed, no measurement, no annotation)
• Performance ceiling is lower than dedicated open-source renderers

Best for: Casual or internal sharing of captures from those platforms. Not suitable as a primary client deliverable.

CesiumJS (3D Tiles + Gaussian)

Cesium added Gaussian Splatting as a layer type for 3D Tiles 1.1 in 2025. This is fundamentally different from the other viewers: instead of loading a monolithic .splat file, the splat is tiled into a 3D Tiles structure and streamed.

Strengths:

• Streaming — only the visible tiles load, no upfront download
• Scales to splats that would never fit in browser memory as a single file
• Georeferenced — splat sits on the Cesium globe in correct world coordinates
• Combines with terrain, imagery, vector data in one viewer

Weaknesses:

• Tiling pipeline is still niche — most generation tools don’t output 3D Tiles Gaussian yet
• Setup is heavier than dropping a .splat into a web page
• Not the right answer for a single object or single room scene

Best for: Large-area or georeferenced splats where streaming is mandatory. See 3D Tiles Explained and CesiumJS for 3D Tiles for the underlying format.

Performance ceilings: what actually breaks

Splat performance is bounded by two things: GPU memory and sort cost. Each frame, all visible Gaussians are sorted by depth before rendering. As Gaussian count grows, sort cost grows worse than linearly.

The numbers below are rough — they vary with GPU, driver, browser, and scene composition. They’re a starting point.

Practical advice: keep production deliveries under 3 million Gaussians if you care about mobile, under 5 million if you only care about desktop. SuperSplat and Postshot both have editing tools to crop down a 10-million-Gaussian capture to a 3-million-Gaussian deliverable without obvious quality loss.

Embedding and sharing

The viewers above all support embedding — but the security model varies. A Gaussian splat viewer is a WebGL shader that runs arbitrary GPU code; you don’t want to drop it directly into your authenticated app origin.

Common patterns:

1. Same-origin embed: Drop the viewer JS into your page. Simple, but the viewer shares the page’s origin — any vulnerability in the viewer can read your app’s cookies and localStorage. Don’t do this for serious applications.
2. Iframe to a separate origin: Host the viewer on a different subdomain (e.g. embed.example.com) and load it in an iframe from your main app. The browser’s same-origin policy isolates the viewer from your app.
3. Sandboxed iframe with CSP: Same as above plus an explicit Content-Security-Policy that restricts what the viewer can load. The current best practice.

Swyvl uses the third pattern. Splats render in a sandboxed iframe from embed.swyvl.io, served with a CSP that locks down origin access. SuperSplat and Spark presets are both supported — the platform chooses the appropriate viewer based on the file format and size of the upload.

For a primer on the broader pattern, see How to Share a 3D Model Online.

Which viewer to pick

A short decision tree:

• Mobile-first deliveries, want smallest files: Spark with .spz.
• Already on Three.js: mkkellogg with .ksplat.
• General-purpose desktop and mobile, want editor tools: SuperSplat with .splat.
• Georeferenced or very large: CesiumJS with 3D Tiles Gaussian.
• Quick internal share from a Polycam or Luma capture: their built-in viewer is fine.
• Branded client delivery without writing viewer code: use a platform that embeds SuperSplat or Spark for you.

Where the format is heading

A few patterns are clear at the time of writing:

• .spz is becoming the de facto compressed delivery format. Expect every viewer to support it by the end of 2026.
• Tiled / streamed splats (the CesiumJS approach) will become more accessible as more tools learn to output them.
• Hybrid Gaussian + SDF representations (which combine the visual quality of splats with usable geometry) are starting to appear in research papers — production tools will follow.
• Mobile splat performance continues to improve; on current trajectories, 5-million-Gaussian splats will play smoothly on mid-range phones by 2027.

The viewer landscape is no longer the bottleneck for Gaussian Splatting. Capture, processing, and delivery are. Pick a viewer that fits your delivery story and move on — the splat itself is where the work actually is.

For more on choosing the right delivery format for spatial data generally, see What File Formats Do Drone Surveys Produce?. For the comparison against photogrammetry and NeRF, see Gaussian Splats vs Photogrammetry vs NeRF.