Spark 2.0

What is Spark 2.0?

Spark 2.0 is an update to Spark, a dynamic 3D Gaussian Splatting (3DGS) renderer designed to run in the browser. Its core purpose is to stream and render large 3DGS worlds on the web by automatically adjusting level-of-detail as the viewer moves.

Spark runs with THREE.js and WebGL2, targeting broad device support through standard web browsers. In earlier Spark versions, it supported rendering multiple 3DGS objects in the same scene, real-time editing and relighting, and a shader graph system for dynamic splat-based effects and animations. Spark 2.0 adds a Level-of-Detail (LoD) system that selects what detail to render for the current viewpoint and streams the required data over the Internet.

Key Features

• Browser-based 3DGS rendering: Built to run in a web browser using THREE.js and WebGL2, aiming to support desktop, iOS, Android, and VR through standard web playback.
• Dynamic Level-of-Detail (LoD) system: Optimizes 3DGS detail based on the viewer’s viewpoint so that only the necessary data is rendered.
• Streaming for large worlds: Streams required 3DGS data over the Internet as you move through a scene, enabling “huge 3DGS worlds” rather than rendering everything at full fidelity.
• Unified 3DGS world composition: Addresses the need for correct back-to-front sorting across multiple 3DGS objects so objects co-exist in the same 3D space rather than appearing as “pasted over” local-only sorting artifacts.
• Shader graph support (Spark feature): Uses a shader graph system for creating dynamic splat-based effects and animations (described as part of Spark’s earlier feature set).

How to Use Spark 2.0

Start from a Spark-based 3DGS web experience (or build one in THREE.js), then enable/attach the Spark 2.0 LoD method for the target 3DGS world. As users move around the scene, the renderer automatically optimizes the splat detail level for the current viewpoint and streams the corresponding data for rendering.

If you’re building or experimenting with splat appearance, you can interact with the underlying splat properties described in the post (center location, XYZ scales, rotation, RGB color, and opacity) and validate how the rendering pipeline blends semi-transparent splats.

Use Cases

• Streaming exploration of large scanned environments: When navigating a big 3DGS world in the browser, LoD selection and streaming helps keep rendering practical by adapting splat detail to the user’s viewpoint.
• VR-ready 3DGS experiences in web runtimes: Because Spark is described as WebGL2/THREE.js-based and “Best experienced in VR” is noted for an example experience, Spark 2.0 can fit interactive VR exploration workflows that rely on web rendering.
• Multi-object 3DGS scenes: For scenes composed from multiple 3DGS objects, Spark’s design is intended to produce unified sorting so that objects visually integrate in 3D space.
• Real-time editing and relighting of splat-based scenes (Spark feature): In workflows that require interactive changes to a 3DGS scene while maintaining dynamic splat rendering, Spark’s earlier capabilities are positioned as relevant context for Spark 2.0.
• Dynamic splat effects and animations (shader graph): When you need procedural or dynamically shaded splat-based visuals, Spark’s shader graph system is the mechanism described in the source.

FAQ

What does Spark 2.0 add compared to Spark?

Spark 2.0 adds a Level-of-Detail (LoD) system that can stream and render large 3DGS worlds by adjusting detail level based on the viewer’s viewpoint.

How does Spark render 3D Gaussian Splatting in the browser?

The renderer is built to integrate with THREE.js and run on WebGL2 in a standard web browser.

What are 3DGS “splats” in this context?

The post describes splats as millions of semi-transparent, colored ellipsoids whose properties include a 3D center, XYZ radii (scales), orientation, RGB color, and opacity; these blend to form surfaces and fine details.

Does Spark support multiple 3DGS objects in the same scene?

Yes—Spark (the renderer) is described as supporting multiple 3DGS objects in the same scene, along with design choices intended to ensure unified back-to-front sorting across objects.

What’s the role of sorting when rendering splats?

The post explains that a common approach is the painter’s algorithm (back-to-front ordering) using blending via the “over” operator; Spark’s system design emphasizes correct global ordering across objects.

Alternatives

• Non-streaming 3DGS web renderers: Alternative renderers may load and render a fixed set of splats without viewpoint-based LoD streaming, which can limit very large worlds.
• Other browser 3D rendering approaches (mesh/point-based): Instead of 3DGS, some systems render surfaces using texture-mapped triangles or other primitives, trading off splat-based density/appearance characteristics for different performance and content workflows.
• Different web graphics APIs: The post specifically targets WebGL2 for broad availability; alternatives could be based on other APIs, potentially reducing device coverage depending on compatibility.
• Standalone 3DGS pipelines: Desktop or native pipelines that preprocess and render 3DGS outside the browser may avoid web streaming/LoD complexity but won’t provide the same “in-browser” interaction model described for Spark.