Avala includes a WebGPU rendering path for GPU-accelerated point clouds, Gaussian splats, and 3D scenes. WebGPU provides direct access to the GPU’s compute and rendering capabilities, enabling real-time visualization of datasets with millions of points. When WebGPU is not enabled, the viewer uses WebGL automatically.
Feature Flags
WebGPU capabilities are controlled by seven feature flags. The master switch must be enabled for any other flag to take effect.
| Flag | Description | Impact |
|---|
webgpuEnabled | Master switch for all WebGPU features | Enables the WebGPU rendering backend. When off, all rendering uses WebGL. |
webgpuComputeShaders | GPU compute for point cloud processing | Moves point cloud operations (sorting, filtering, transformation) from the CPU to GPU compute shaders. |
webgpuRenderBundles | Pre-recorded rendering commands | Records frequently-used draw call sequences into reusable bundles, reducing per-frame CPU overhead. |
wgslShaders | WGSL shader language | Uses WebGPU Shading Language for shader programs instead of GLSL. |
gpuFrustumCulling | GPU-based visibility culling | Runs frustum intersection tests on the GPU to skip points outside the camera’s view before rendering. |
gpuLod | GPU-based level of detail | Reduces point density for distant regions on the GPU, maintaining visual quality while reducing the number of rendered points. |
webgpuFullRendering | Complete WebGPU rendering pipeline | Routes the entire rendering pipeline through WebGPU, including scene rendering, material evaluation, and post-processing. |
WebGPU features are under active development. All feature flags default to off and are currently available to staff users for testing. When WebGPU is not enabled, the viewer uses WebGL automatically. Browser requirements: Chrome 113+, Edge 113+, or a browser with WebGPU support.
What Each Feature Enables
Compute Shaders
When webgpuComputeShaders is active, point cloud processing operations run as GPU compute dispatches rather than CPU loops. This includes:
- Point sorting for correct transparency and depth ordering
- Attribute computation (intensity mapping, color interpolation)
- Spatial filtering (range, bounding box, custom filters)
Compute shaders process millions of points in parallel, significantly reducing processing time compared to CPU-based loops for large datasets.
Render Bundles
When webgpuRenderBundles is active, the viewer records sequences of GPU draw commands into reusable bundles. On subsequent frames where the scene structure has not changed, the pre-recorded bundle is replayed instead of re-issuing individual draw calls. This reduces CPU-side overhead significantly for complex scenes with many objects.
Frustum Culling
When gpuFrustumCulling is active, a compute shader tests each point against the camera’s view frustum (the visible pyramid) before rendering. Points outside the frustum are discarded on the GPU, avoiding the cost of processing and rasterizing invisible geometry. This is especially impactful when zoomed into a small region of a large point cloud.
Level of Detail
When gpuLod is active, the viewer dynamically adjusts point density based on distance from the camera. Nearby regions retain full detail, while distant regions are rendered with progressively fewer points. The LOD computation runs entirely on the GPU, so the full dataset remains available for interaction — only the rendering density changes.
The WebGPU backend includes several specialized components that optimize rendering performance.
| Component | Purpose |
|---|
| GPURadixSort | GPU-based radix sorting algorithm for depth-ordering points and splats. Runs entirely in compute shaders, sorting millions of elements per frame. |
| GPUBufferPool | Reuses GPU buffer allocations across frames to avoid the cost of repeated allocation and deallocation. Reduces memory pressure and garbage collection pauses. |
| RenderBundleCache | Caches pre-recorded render bundles keyed by scene configuration. Automatically invalidates when the scene changes. |
| WebGPUPerformanceTimer | Uses GPU timestamp queries for accurate frame timing. Measures actual GPU execution time rather than CPU-side submission time, providing precise performance profiling. |
| GSplatPipelinePrecompiler | Asynchronously compiles Gaussian splatting shader pipelines at startup. Prevents frame stalls that would otherwise occur when a pipeline is first used. |
WebGPU Scene Renderer
The WebGPUSceneRenderer handles the full 3D scene rendering pipeline: geometry submission, material evaluation, lighting, and post-processing. It manages render passes, depth testing, and multi-target output for effects like picking and ID rendering.
Gaussian Splatting Renderer
The WebGPUGSplatRenderer renders Gaussian splat datasets using GPU-accelerated sorting and splatting. It uses GPURadixSort to depth-sort splats every frame, then renders them as view-dependent 2D Gaussians. Pipeline compilation is handled asynchronously by GSplatPipelinePrecompiler to avoid frame hitches during initialization.
Browser Support
| Browser | Minimum Version | Status |
|---|
| Chrome | 113+ | Enabled by default |
| Edge | 113+ | Enabled by default |
| Firefox | Nightly | Requires dom.webgpu.enabled flag |
| Safari | Technology Preview | Requires feature flag |
WebGPU support is actively expanding across browsers. Chrome and Edge provide full production support. Firefox and Safari support is experimental and may have limitations with certain features.
WebGL Fallback
When WebGPU is not available (unsupported browser, disabled flags, or GPU driver issues), the viewer automatically falls back to WebGL rendering. The fallback is seamless — the same data loads and the same panels appear, but rendering uses the WebGL pipeline instead.
Key differences in fallback mode:
| Capability | WebGPU | WebGL Fallback |
|---|
| Compute shaders | Available | Not available (CPU fallback) |
| Render bundles | Available | Not available |
| GPU frustum culling | Available | CPU-based culling |
| GPU level of detail | Available | CPU-based LOD |
| Gaussian splatting | GPU-sorted | CPU-sorted (slower) |
| Maximum point count | Tens of millions | Lower (depends on hardware) |
For the best experience with large point cloud datasets (over 1 million points), use Chrome or Edge 113+ to ensure WebGPU is available.
