MCPcopy Index your code
hub / github.com/cvlab-epfl/gaussian-splatting-web

github.com/cvlab-epfl/gaussian-splatting-web @main

Chat with this repo
repository ↗ · DeepWiki ↗ · + Follow
124 symbols 189 edges 10 files 0 documented · 0%
What it actually does AI analysis from the code graph — generated when you open this
loading…
README

WebGPU viewer for Gaussian Splatting nerfs

Image

This repository contains the source for an interactive web viewer of NeRFs crated with the code available from INRIA. The app with instructions is hosted at jatentaki.github.io.

Building

This project has been created using webpack-cli. Before the first build, go to the code directory and execute npm install to install dependencies.

Afterwards, you can use

npm run build

to bundle the application or

npm run serve

to have a live-updating server.

Browser compatibility

The official compatiblity table of WebGPU can be found here. In practice, the following are known to work:

MacOS: works with recent (version 115+) Chrome/Chromium browsers.

Windows: works with Edge 116+, most likely with Chrome/Chromium as well (it's the same thing but I was not able to test).

Ubuntu: works with Chrome dev version and custom flags. The steps are as follows: 1. Download and install Chrome dev. 2. Launch from command line with extra flags: google-chrome-unstable --enable-features=Vulkan,UseSkiaRenderer. 3. Go to chrome://flags/#enable-unsafe-webgpu and enable webgpu. Restart the browser for the change to take effect, make sure to use the flags from the previous step as well. 4. The Gaussian viewer should work.

Firefox: the nightly channel is supposed to support webGPU experimentally but in practice it fails on parsing my shaders across MacOS/Ubuntu.

If you succeed with any other configuration or fail with the ones described above, please open an issue and tell us.

Architecture

Unlike the original paper, this code doesn't use computer shaders to compute each pixel value independently but instead maps the problem to a standard rasterization technique, where each Gaussian is a flat rectangle facing the camera, with the actual content drawn via a fragment shader. I found this approach to yield substantially better framerates than compute shaders, although both are available in WebGPU.

This was my first substantial webdev project, therefore the code is far from idiomatic. I'm happy to receive PRs both to improve performance and to clean up the codebase.

Extension points exported contracts — how you extend this code

CameraRaw (Interface)
(no doc)
src/camera.ts

Core symbols most depended-on inside this repo

pack
called by 7
src/packing.ts
destroy
called by 6
src/renderer.ts
setDirty
called by 5
src/camera.ts
create
called by 4
src/gpu_context.ts
mat4toArrayOfArrays
called by 3
src/renderer.ts
roundUp
called by 3
src/packing.ts
unpack
called by 3
src/packing.ts
requestContext
called by 2
src/renderer.ts

Shape

Method 64
Class 41
Function 18
Interface 1

Languages

TypeScript100%

Modules by API surface

src/packing.ts53 symbols
src/camera.ts29 symbols
src/renderer.ts9 symbols
src/ply.ts8 symbols
src/depth_sorter.ts8 symbols
src/bitonic.ts8 symbols
src/gpu_context.ts5 symbols
src/index.ts3 symbols
src/shaders.ts1 symbols

For agents

$ claude mcp add gaussian-splatting-web \
  -- python -m otcore.mcp_server <graph>

⬇ download graph artifact

Ask about this repo answers extend the page