gaussian-splat-lite 1.3.2 → 1.4.1

package/dist/types/addons/NeuralDenoiseNode.d.cts

@@ -9,8 +9,7 @@ import { Node, type NodeBuilder, type NodeFrame } from "three/webgpu";
 export type NeuralDenoiseMode = "performance" | "quality";
 /**
  * Experimental temporal neural denoiser for stochastic Splat rendering on WebGPURenderer,
- * including its WebGL2 fallback,
- * used in place of TAANode. After Hu et al., "Ultra-fast Neural Inference for
+ * including its WebGL2 fallback. After Hu et al., "Ultra-fast Neural Inference for
  * Stochastic Gaussian Splatting Denoising" (arXiv 2609.25604), adapted to
  * scenes whose objects move.
  */

package/dist/types/addons/NeuralDenoiseNode.d.ts

@@ -9,8 +9,7 @@ import { Node, type NodeBuilder, type NodeFrame } from "three/webgpu";
 export type NeuralDenoiseMode = "performance" | "quality";
 /**
  * Experimental temporal neural denoiser for stochastic Splat rendering on WebGPURenderer,
- * including its WebGL2 fallback,
- * used in place of TAANode. After Hu et al., "Ultra-fast Neural Inference for
+ * including its WebGL2 fallback. After Hu et al., "Ultra-fast Neural Inference for
  * Stochastic Gaussian Splatting Denoising" (arXiv 2609.25604), adapted to
  * scenes whose objects move.
  */

package/dist/types/addons/NeuralDenoiseXR.d.cts

@@ -0,0 +1,31 @@
+import type { PerspectiveCamera, Scene, WebGLRenderer } from "three";
+import type { WebGPURenderer } from "three/webgpu";
+import type { NeuralDenoiseMode } from "./NeuralDenoiseNode.cjs";
+
+/** Per-eye neural denoising and presentation during an active WebXR session. */
+export declare class NeuralDenoiseXR {
+  readonly renderer: WebGLRenderer | WebGPURenderer;
+  scene: Scene;
+  camera: PerspectiveCamera;
+  readonly mode: NeuralDenoiseMode;
+  readonly msaa: boolean;
+  stabilize: boolean;
+  private views;
+  private output;
+  private readonly nodeRenderer;
+  private readonly onSessionEnd;
+  constructor(
+    renderer: WebGLRenderer | WebGPURenderer,
+    scene: Scene,
+    camera: PerspectiveCamera,
+    mode?: NeuralDenoiseMode,
+    msaa?: boolean,
+  );
+  private createViews;
+  /** Capture, denoise and present each eye during an active XR animation frame. */
+  render(): void;
+  /** Discards both eyes' history after a camera cut or scene replacement. */
+  reset(): void;
+  private disposeViews;
+  dispose(): void;
+}

package/dist/types/addons/NeuralDenoiseXR.d.ts

@@ -0,0 +1,31 @@
+import type { PerspectiveCamera, Scene, WebGLRenderer } from "three";
+import type { WebGPURenderer } from "three/webgpu";
+import type { NeuralDenoiseMode } from "./NeuralDenoiseNode.js";
+
+/** Per-eye neural denoising and presentation during an active WebXR session. */
+export declare class NeuralDenoiseXR {
+  readonly renderer: WebGLRenderer | WebGPURenderer;
+  scene: Scene;
+  camera: PerspectiveCamera;
+  readonly mode: NeuralDenoiseMode;
+  readonly msaa: boolean;
+  stabilize: boolean;
+  private views;
+  private output;
+  private readonly nodeRenderer;
+  private readonly onSessionEnd;
+  constructor(
+    renderer: WebGLRenderer | WebGPURenderer,
+    scene: Scene,
+    camera: PerspectiveCamera,
+    mode?: NeuralDenoiseMode,
+    msaa?: boolean,
+  );
+  private createViews;
+  /** Capture, denoise and present each eye during an active XR animation frame. */
+  render(): void;
+  /** Discards both eyes' history after a camera cut or scene replacement. */
+  reset(): void;
+  private disposeViews;
+  dispose(): void;
+}

package/dist/types/addons/neuralDenoiseState.d.cts

@@ -0,0 +1,22 @@
+import type { Camera, Matrix4, RenderTarget, Vector2 } from "three";
+
+/** Capture sizing, projection jitter and history lifetime for neural denoising. */
+export declare function createNeuralDenoiseState(
+  targets: RenderTarget[],
+  margin: number,
+): {
+  size: Vector2;
+  projection: Matrix4;
+  valid: boolean;
+  historyIndex: number;
+  jitterIndex: number;
+  reset(): void;
+  setSize(width: number, height: number): void;
+  setStencil(stencil: boolean): void;
+  beginCapture(camera: Camera): void;
+  endCapture(camera: Camera): void;
+  advance(): void;
+};
+export declare const getUnjitteredProjection: (
+  camera: Camera,
+) => Matrix4 | undefined;

package/dist/types/addons/neuralDenoiseState.d.ts

@@ -0,0 +1,22 @@
+import type { Camera, Matrix4, RenderTarget, Vector2 } from "three";
+
+/** Capture sizing, projection jitter and history lifetime for neural denoising. */
+export declare function createNeuralDenoiseState(
+  targets: RenderTarget[],
+  margin: number,
+): {
+  size: Vector2;
+  projection: Matrix4;
+  valid: boolean;
+  historyIndex: number;
+  jitterIndex: number;
+  reset(): void;
+  setSize(width: number, height: number): void;
+  setStencil(stencil: boolean): void;
+  beginCapture(camera: Camera): void;
+  endCapture(camera: Camera): void;
+  advance(): void;
+};
+export declare const getUnjitteredProjection: (
+  camera: Camera,
+) => Matrix4 | undefined;

package/dist/types/addons/neuralDenoiseWeights.d.cts

@@ -9,8 +9,36 @@ export type NeuralDenoiseLayer = {
  * Trained on this renderer's stochastic frames.
  */
 export type NeuralDenoiseModel = {
-  /** Use fixed local filtering without learned multiscale passes. */
+  /**
+   * Use fixed local filtering without learned multiscale passes.
+   * Requires `compactMix` and `movingKnee` when true.
+   */
   compact?: boolean;
+  /**
+   * Required with `compact`: shares of the 3x3 mean, each in [0, 1], for
+   * settled denoised history and for camera motion or short history.
+   * The transition uses `movingKnee` and `reach`.
+   */
+  compactMix?: [settled: number, movingOrShort: number];
+  /**
+   * Maximum share of smoothing applied to the displayed accumulated path,
+   * in [0, 1]. Omitted or zero disables it; otherwise `movingNoise` and
+   * `movingKnee` are required. Applies only while the camera moves and
+   * preserves the stored accumulated history. Object motion with a still
+   * camera continues to use the existing history rejection.
+   */
+  movingMean?: number;
+  /**
+   * Required with nonzero `movingMean`: nonnegative multiplier of the
+   * mean's squared standard error. Larger values allow smoothing across
+   * greater color differences.
+   */
+  movingNoise?: number;
+  /**
+   * Required with `compact` or nonzero `movingMean`: positive camera-induced
+   * screen motion, in pixels per frame, at which the motion response is 0.5.
+   */
+  movingKnee?: number;
   /** Strengthen display stabilization for single-sample stochastic noise. */
   stabilizeNoise?: boolean;
   /** Gain of the variance gate between the two history paths. */
@@ -111,7 +139,18 @@ export type NeuralDenoiseModel = {
     pointwise3: NeuralDenoiseLayer;
     head: NeuralDenoiseLayer;
   };
-};
+} & (
+  | { compact?: false }
+  | {
+      compact: true;
+      compactMix: [settled: number, movingOrShort: number];
+      movingKnee: number;
+    }
+) &
+  (
+    | { movingMean?: 0 }
+    | { movingMean: number; movingNoise: number; movingKnee: number }
+  );
 export declare const neuralDenoiseModels: {
   quality: NeuralDenoiseModel;
   performance: NeuralDenoiseModel;

package/dist/types/addons/neuralDenoiseWeights.d.ts

@@ -9,8 +9,36 @@ export type NeuralDenoiseLayer = {
  * Trained on this renderer's stochastic frames.
  */
 export type NeuralDenoiseModel = {
-  /** Use fixed local filtering without learned multiscale passes. */
+  /**
+   * Use fixed local filtering without learned multiscale passes.
+   * Requires `compactMix` and `movingKnee` when true.
+   */
   compact?: boolean;
+  /**
+   * Required with `compact`: shares of the 3x3 mean, each in [0, 1], for
+   * settled denoised history and for camera motion or short history.
+   * The transition uses `movingKnee` and `reach`.
+   */
+  compactMix?: [settled: number, movingOrShort: number];
+  /**
+   * Maximum share of smoothing applied to the displayed accumulated path,
+   * in [0, 1]. Omitted or zero disables it; otherwise `movingNoise` and
+   * `movingKnee` are required. Applies only while the camera moves and
+   * preserves the stored accumulated history. Object motion with a still
+   * camera continues to use the existing history rejection.
+   */
+  movingMean?: number;
+  /**
+   * Required with nonzero `movingMean`: nonnegative multiplier of the
+   * mean's squared standard error. Larger values allow smoothing across
+   * greater color differences.
+   */
+  movingNoise?: number;
+  /**
+   * Required with `compact` or nonzero `movingMean`: positive camera-induced
+   * screen motion, in pixels per frame, at which the motion response is 0.5.
+   */
+  movingKnee?: number;
   /** Strengthen display stabilization for single-sample stochastic noise. */
   stabilizeNoise?: boolean;
   /** Gain of the variance gate between the two history paths. */
@@ -111,7 +139,18 @@ export type NeuralDenoiseModel = {
     pointwise3: NeuralDenoiseLayer;
     head: NeuralDenoiseLayer;
   };
-};
+} & (
+  | { compact?: false }
+  | {
+      compact: true;
+      compactMix: [settled: number, movingOrShort: number];
+      movingKnee: number;
+    }
+) &
+  (
+    | { movingMean?: 0 }
+    | { movingMean: number; movingNoise: number; movingKnee: number }
+  );
 export declare const neuralDenoiseModels: {
   quality: NeuralDenoiseModel;
   performance: NeuralDenoiseModel;

package/dist/types/data/RadPagedSplats.d.cts

@@ -1,7 +1,7 @@
 import { IndexedSplats } from "./IndexedSplats.cjs";
 import type { ReorderedSplatResult } from "./defines.cjs";
 export type RadPagedSplatsOptions = {
-  /** Maximum records in one decoded chunk. Defaults to Spark's 65,536. */
+  /** Maximum records in one decoded chunk. Defaults to 65,536. */
   pageSize?: number;
   pageCount: number;
   numSh: number;

package/dist/types/data/RadPagedSplats.d.ts

@@ -1,7 +1,7 @@
 import { IndexedSplats } from "./IndexedSplats.js";
 import type { ReorderedSplatResult } from "./defines.js";
 export type RadPagedSplatsOptions = {
-  /** Maximum records in one decoded chunk. Defaults to Spark's 65,536. */
+  /** Maximum records in one decoded chunk. Defaults to 65,536. */
   pageSize?: number;
   pageCount: number;
   numSh: number;

package/dist/types/index.d.cts

@@ -2,11 +2,10 @@ export {
   GaussianSplatRenderer,
   type GaussianSplatRendererOptions,
 } from "./rendering/GaussianSplatRenderer.cjs";
-export { TAAPass } from "./addons/TAAPass.cjs";
-export { TAANode } from "./addons/TAANode.cjs";
 export type { NeuralDenoiseMode } from "./addons/NeuralDenoiseNode.cjs";
 export { NeuralDenoiseNode } from "./addons/NeuralDenoiseNode.cjs";
 export { NeuralDenoisePass } from "./addons/NeuralDenoisePass.cjs";
+export { NeuralDenoiseXR } from "./addons/NeuralDenoiseXR.cjs";
 export {
   SplatCapture,
   type SplatCaptureOptions,

package/dist/types/index.d.ts

@@ -2,11 +2,10 @@ export {
   GaussianSplatRenderer,
   type GaussianSplatRendererOptions,
 } from "./rendering/GaussianSplatRenderer.js";
-export { TAAPass } from "./addons/TAAPass.js";
-export { TAANode } from "./addons/TAANode.js";
 export type { NeuralDenoiseMode } from "./addons/NeuralDenoiseNode.js";
 export { NeuralDenoiseNode } from "./addons/NeuralDenoiseNode.js";
 export { NeuralDenoisePass } from "./addons/NeuralDenoisePass.js";
+export { NeuralDenoiseXR } from "./addons/NeuralDenoiseXR.js";
 export {
   SplatCapture,
   type SplatCaptureOptions,

package/dist/types/loaders/rad/radFormat.d.cts

@@ -7,7 +7,7 @@ export type RadChunkRange = {
   count?: number;
   filename?: string;
 };
-/** Spark RAD version 1 directory. Child references use file-global indices. */
+/** RAD version 1 directory. Child references use file-global indices. */
 export type RadMeta = {
   version: number;
   type: "gsplat";
@@ -43,7 +43,7 @@ export type RadDecodedChunk = PostDecodeSplatData & {
   lodRadii?: Float32Array;
 };
 export declare function unpackRadChunk(decoded: RadDecodedChunk): RadChunkData;
-/** Without chunkSize, Spark treats the dataset as one chunk. */
+/** Without chunkSize, the dataset is treated as one chunk. */
 export declare function getRadChunkSpan(
   meta: RadMeta,
   index: number,

package/dist/types/loaders/rad/radFormat.d.ts

@@ -7,7 +7,7 @@ export type RadChunkRange = {
   count?: number;
   filename?: string;
 };
-/** Spark RAD version 1 directory. Child references use file-global indices. */
+/** RAD version 1 directory. Child references use file-global indices. */
 export type RadMeta = {
   version: number;
   type: "gsplat";
@@ -43,7 +43,7 @@ export type RadDecodedChunk = PostDecodeSplatData & {
   lodRadii?: Float32Array;
 };
 export declare function unpackRadChunk(decoded: RadDecodedChunk): RadChunkData;
-/** Without chunkSize, Spark treats the dataset as one chunk. */
+/** Without chunkSize, the dataset is treated as one chunk. */
 export declare function getRadChunkSpan(
   meta: RadMeta,
   index: number,

package/docs/BuildRad.md

@@ -0,0 +1,91 @@
+# Building RAD files
+
+[Back to documentation](../README.md#documentation)
+
+Convert PLY or SPZ models into RAD files with levels of detail (LOD), ready for [RAD streaming](RadStreamScheduler.md). Requires Node.js 20.19+ on the 20.x branch, or 22.12+. No compilation is required.
+
+```sh
+npm install --global gaussian-splat-lite
+gsl-build-lod scene.ply
+```
+
+This writes `scene-lod.rad` beside the input. Large models can take a long time to convert.
+
+To run without a global installation:
+
+```sh
+npx --package gaussian-splat-lite gsl-build-lod scene.ply
+```
+
+From a repository checkout, first build the decoder with `npm run build:wasm:lod` (requires Rust), then use `npm run build-lod -- <input>` with the same options. The full `npm run build:wasm` command also builds the decoder.
+
+## Inputs and output
+
+Inputs must be `.ply` or `.spz` files. Splats with NaN or infinite values, or a zero rotation, are skipped, and the conversion reports how many.
+
+```sh
+# Convert several files, each to its own RAD file.
+gsl-build-lod room.ply garden.spz
+
+# Choose an output path for a single input.
+gsl-build-lod scene.ply -o output/scene.rad
+
+# Keep only the base color, reducing file size and memory use.
+gsl-build-lod scene.ply --max-sh 0
+```
+
+The output directory must exist. Existing output files, including matching `.radc` files when using `--rad-chunked`, are never overwritten. Choose a different output name or remove the old files before converting again. Output files are first written under hidden temporary names in the output directory and receive their final names only after all of them are complete. Failed conversions return a nonzero exit code and remove their output files; if a file cannot be removed, a warning shows its path.
+
+The output keeps up to SH3. SH4 inputs are accepted and converted to SH3 or the level chosen with `--max-sh`. Higher SH levels retain more view-dependent color and increase file size. Conversion is lossy, so colors and shape can differ slightly from the source.
+
+## LOD spacing
+
+```sh
+gsl-build-lod scene.ply --lod-base 1.75
+```
+
+`--lod-base` controls the spacing between detail levels (default `1.75`, range `1.1`–`16`). Smaller values produce more intermediate levels and usually larger files; larger values produce fewer levels and usually smaller files. This setting does not discard input splats.
+
+## Memory and temporary storage
+
+```sh
+gsl-build-lod scene.ply --memory-budget 16 --temp-dir /fast-disk/rad-temp
+```
+
+`--memory-budget` sets a target in GiB (default `4`, minimum `1`, fractional values accepted). Values such as `16` are supported when enough RAM is available. Lower targets may make conversion slower and require more temporary disk space; output quality is unchanged. If conversion reports insufficient memory, increase this value.
+
+The target covers the whole conversion, worker threads included: the converter measures its memory as it runs and keeps within it. Leave room for the operating system and other applications.
+
+`--temp-dir` chooses where temporary working files are stored; the default is the system temporary directory. Use a fast disk with enough free space, as temporary files can be much larger than the input. Each conversion keeps them in its own `gsl-build-rad-*` folder there, which is removed when the conversion finishes or fails; if it cannot be removed, a warning shows its path.
+
+## Split files
+
+```sh
+gsl-build-lod scene.ply --rad-chunked
+```
+
+This writes `scene-lod.rad` plus `scene-lod-0.radc`, `scene-lod-1.radc`, and so on.
+
+Host all files together in the same directory and load the `.rad` file. A single `.rad` file also supports streaming; its server must support HTTP Range requests.
+
+```js
+import { RadStreamScheduler } from "gaussian-splat-lite";
+
+const streaming = new RadStreamScheduler({
+  url: "/models/scene-lod.rad",
+});
+```
+
+See [RadStreamScheduler](RadStreamScheduler.md) for the complete loading and display example.
+
+## Options
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `--lod-base <base>` | `1.75` | LOD spacing, from `1.1` to `16`; smaller values retain more detail levels. |
+| `--max-sh <0..3>` | `3` | Highest SH degree to keep, limited by the input. |
+| `--memory-budget <GiB>` | `4` | Target memory use in GiB, at least `1`; for example `16`. |
+| `--temp-dir <path>` | System temp directory | Location for temporary files; created if needed. |
+| `--rad-chunked` | Disabled | Write a header and separate `.radc` files. |
+| `-o <path>` or `--output <path>` | `<input-stem>-lod.rad` | Output path; requires exactly one input. |
+| `-h` or `--help` | — | Show command help. |

package/docs/GaussianSplatRenderer.md

@@ -58,7 +58,7 @@ On native WebGPU, Splats are sorted before every draw. On WebGL, sorting finishe
 
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
-| `stochastic` | `boolean` | `false` | Use stochastic rendering; smooth its noise with temporal anti-aliasing |
+| `stochastic` | `boolean` | `false` | Use stochastic rendering; smooth its noise with neural denoising |
 | `stochasticSort` | `boolean` | `true` | Sort Splats from front to back in stochastic rendering; `false` skips sorting |
 | `autoAdvanceStochasticSample` | `boolean` | `true` | Change the noise pattern on every render, including in WebXR |
 
@@ -100,7 +100,7 @@ Model colors are converted for you. Control the final image with your Three.js r
 
 Set `encodeLinear` to choose the conversion yourself. For example, to blend Splats in sRGB next to a linear scene, render them into their own target with `encodeLinear: false`, then unpremultiply that layer, convert it to linear, and premultiply it again before compositing.
 
-For temporal anti-aliasing and effects such as Bloom, see [TAAPass and TAANode](TAAPass.md). To render offscreen, read pixels back, or build cube and environment maps, use [SplatCapture](SplatCapture.md).
+For neural denoising and effects such as Bloom, see [Neural denoising](NeuralDenoiseNode.md). To render offscreen, read pixels back, or build cube and environment maps, use [SplatCapture](SplatCapture.md).
 
 ## On-demand rendering
 

package/docs/NeuralDenoiseNode.md

@@ -1,18 +1,10 @@
-# NeuralDenoiseNode and NeuralDenoisePass (Experimental)
+# Neural denoising (Experimental)
 
 [Back to documentation](../README.md#documentation)
 
-The experimental neural denoiser smooths [stochastic rendering](StochasticRendering.md). Use `NeuralDenoiseNode` with `WebGPURenderer`, including its WebGL2 fallback, or `NeuralDenoisePass` with `WebGLRenderer`. The trained models are included; no extra downloads are needed.
+The experimental neural denoiser smooths [stochastic rendering](StochasticRendering.md). Use `NeuralDenoiseNode` with `WebGPURenderer`, including its WebGL2 fallback, or `NeuralDenoisePass` with `WebGLRenderer`. For immersive rendering, use [NeuralDenoiseXR](#webxr) with either renderer. The trained models are included; no extra downloads are needed.
 
-## Choose between TAA and neural denoising
-
-| | `TAANode` / `TAAPass` | `NeuralDenoiseNode` / `NeuralDenoisePass` |
-| --- | --- | --- |
-| Moving objects | May leave a faint trail | Helps reduce trails; moving detail can still look soft or grainy |
-| Camera movement | Some grain returns | Smooths noise during movement; fast turns can look softer |
-| Cost | Lower | Depends on mode; Quality uses more GPU time and memory |
-
-With neural denoising, newly exposed backgrounds need time to settle. Results vary by scene and motion.
+Neural denoising smooths noise during movement and helps reduce trails behind moving objects. Moving detail can still look soft or grainy, and newly exposed backgrounds need time to settle. Results vary by scene and motion.
 
 ## Choose a mode
 
@@ -48,7 +40,7 @@ With MSAA off, stabilization is stronger to reduce flicker, which can add some t
 ## Before you start
 
 - **WebGL2 requirements.** Both WebGL2 paths require `EXT_color_buffer_float`. MSAA also requires `OES_sample_variables`; check `renderer.getContext().getExtension("OES_sample_variables")` before enabling MSAA. If it is unavailable, leave MSAA disabled. Unsupported configurations throw an error.
-- **One camera.** Use a `PerspectiveCamera` or `OrthographicCamera`. WebXR is not supported.
+- **Camera.** Use a `PerspectiveCamera` or `OrthographicCamera` for the node/pass. For WebXR, use `NeuralDenoiseXR` with your application's `PerspectiveCamera` as shown below.
 - **Stencil masks.** Create the Three.js renderer with `stencil: true` to use them.
 - **Reset after a jump.** Call `denoise.reset()` after a camera cut or scene replacement. Resizing resets automatically; normal object movement needs no reset.
 - **On-demand rendering.** Keep rendering after each change so the image can settle.
@@ -88,7 +80,7 @@ const pipeline = new RenderPipeline(renderer, color.add(bloom(color, 0.6, 0.4, 0
 
 ## WebGLRenderer: NeuralDenoisePass
 
-Use the pass in place of `RenderPass` or `TAAPass`:
+Use the pass in place of `RenderPass`:
 
 ```js
 import { NeuralDenoisePass } from "gaussian-splat-lite";
@@ -114,6 +106,33 @@ renderer.setAnimationLoop(() => {
 // On cleanup: stop the animation loop, then dispose the composer and each pass.
 ```
 
+## WebXR
+
+Use `NeuralDenoiseXR` during XR frames. It supports `WebGLRenderer` and initialized `WebGPURenderer`, including its WebGL2 fallback. Each eye uses its own image history and resolution; both modes and optional MSAA are available.
+
+```js
+import { NeuralDenoiseXR } from "gaussian-splat-lite";
+
+renderer.xr.enabled = true;
+splatRenderer.stochastic = true;
+const xrDenoise = new NeuralDenoiseXR(renderer, scene, camera, "performance");
+
+renderer.setAnimationLoop(() => {
+  // Update animation here. Start the XR session using your normal XR button.
+  if (renderer.xr.isPresenting) xrDenoise.render();
+  else renderer.render(scene, camera); // Or your desktop denoising pipeline.
+});
+
+// After a teleport or scene replacement: xrDenoise.reset().
+// On cleanup: xrDenoise.dispose().
+```
+
+Call `render()` directly during an active XR animation frame. It presents the final image, including tone mapping and output color conversion; do not put it in an `EffectComposer` or `RenderPipeline`. Those desktop pipelines do not automatically become stereo pipelines. When using a desktop denoiser too, reset its history when leaving XR.
+
+The constructor takes `(renderer, scene, camera, mode = "quality", msaa = false)`. `scene`, `camera`, and `stabilize` can be changed; call `reset()` after replacing the scene or camera. If `renderer.xr.cameraAutoUpdate` is `false`, update the XR camera yourself before rendering. Eye resizing resets history automatically, and ending the session releases the eye resources.
+
+Stereo rendering increases GPU and memory use. Start with `"performance"` and MSAA off, and check image quality and frame timing on the target headset. Native WebGPU also requires the browser's [WebXR WebGPU binding](https://immersive-web.github.io/webxr-webgpu-binding/) and a session requested with the `"webgpu"` feature. The XR path presents color only; it does not provide scene depth to the XR compositor or a stereo postprocessing chain.
+
 ## Color
 
 `RenderPipeline`, or the composer's `OutputPass`, applies tone mapping and the output color space at the end.

package/docs/RadStreamScheduler.md

@@ -2,7 +2,9 @@
 
 [Back to documentation](../README.md#documentation)
 
-Shows large RAD scenes by loading only the detail the camera needs, and updating it as the camera moves. It supports RAD version 1 files with levels of detail (LOD), either as a single `.rad` file or split into a header and `.radc` pages. It works on WebGPU and WebGL2, and needs no Spark runtime.
+Shows large RAD scenes by loading only the detail the camera needs, and updating it as the camera moves. It supports RAD version 1 files with levels of detail (LOD), either as a single `.rad` file or split into a header and `.radc` pages. It works on WebGPU and WebGL2.
+
+To convert your own models, see [Building RAD files](BuildRad.md).
 
 ```js
 import { RadStreamScheduler } from "gaussian-splat-lite";