SplatTransform for 3D Gaussian Splat Conversion

SplatTransform's Gaussian Splat Processing Scope

SplatTransform addresses the format conversion and editing problem created by heterogeneous 3D Gaussian splat data. Engineers working with trained or captured scenes often need to change formats before a scene can be inspected, delivered, transformed, merged, or used to generate another representation. The package provides both a command-line tool and an importable library, so the same processing concepts can support scripts and applications.

It is aimed primarily at engineers handling Gaussian splat assets and associated delivery pipelines. That includes teams preparing web assets, generating collision representations, reducing or filtering scene data, or creating derivatives from splat files. It is not presented as a general mesh editor. Its operations are centered on Gaussian data, including spherical harmonic information and splat-specific render metadata.

The CLI exposes conversions, statistical summaries, merging, transformations, filtering, spatial reordering, and procedural generation through JavaScript generators. Outputs extend beyond common splat containers. The README lists an HTML viewer, LOD data, a sparse voxel octree for collision detection, and a lossless WebP image rendered from a camera view.

This range creates a useful asset-processing boundary, but it also makes format selection important. The destination determines which attributes can be represented and what the output is intended to do. SOG is positioned for compressed web delivery, Streamed SOG is positioned for large multi-LOD scenes, voxel output serves collision-oriented uses, and WebP output is a rendered image. They are not interchangeable file formats.

The library is described as platform-agnostic and usable in both Node.js and browser environments. The package metadata confirms that its main distribution is published through the `@playcanvas/splat-transform` package with ES module and CommonJS entry points. This makes the project relevant to both command-oriented batch preparation and programmatic integration.

Ordered CLI Processing for Gaussian Splat Actions

The CLI is built around an ordered positional pipeline:

splat-transform [GLOBAL] input [ACTIONS]  ...  output [ACTIONS]

The documented syntax has two important consequences. First, input files become the working set. Second, actions run in the order in which they appear. The last file is treated as the output, and actions placed after that file modify the final result. This means the pipeline's argument order is part of its processing semantics rather than presentation detail.

Actions may be repeated and may appear after any input or output file. That arrangement supports a pipeline in which a scene is loaded, transformed or filtered, sent to an output, and then subjected to further processing. A command author must still read the ordering carefully. An action after the output is not the same placement as an action before it, even if the action name is the same.

The format table identifies another important behavior: output can be discarded by using `null`. The README describes this as useful with `--stats` for analysis-only runs. It prevents a run intended only to report scene statistics from creating a normal output file. The literal `null` is part of the documented CLI interface, not a substitute value that a caller can choose freely.

The project therefore treats conversion as a sequence of data operations rather than a hard-coded pairwise file conversion. This is a better fit for scripted asset preparation, provided the command ordering is tested for each pipeline. The excerpt shown here does not document every action flag, so commands that need advanced filtering, merging, or generation should use the current action reference instead of assuming flag names or option values.

SplatTransform Format Coverage and Data Loss Boundaries

SplatTransform has broad format coverage, but the supported-format matrix is asymmetric. It reads PLY, Compressed PLY, SOG, Streamed SOG, SPZ, SPLAT, KSPLAT, LCC and LCC2. It writes PLY, Compressed PLY, SOG, Streamed SOG, SPZ, GLB, CSV, HTML Viewer, LOD, Voxel and WebP. Several source formats are input-only, including LCC, LCC2, KSPLAT and SPLAT. Several derivative formats are output-only, including GLB, CSV, HTML and WebP.

PLY is described as the industry-standard uncompressed format for source, editing and interchange. SOG is a super-compressed format for web delivery using `meta.json` and WebP textures, with bundled and unbundled arrangements. Streamed SOG stores chunked multi-LOD data and uses `lod-meta.json`, which makes it the documented option for scenes too large to handle as a single web asset.

Compressed PLY is automatically detected and decompressed on read. SPZ support covers Niantic versions 2 through 4. GLB output uses the `KHR_gaussian_splatting` glTF extension, but the format table does not list GLB as an input. Voxel output is a sparse octree represented by `.voxel.json` and `.voxel.bin`, intended for collision detection rather than visual splat rendering.

Format support does not guarantee complete metadata preservation. Antialiased and 2DGS scenes are tagged when their source headers identify them. PLY can carry Brush's render-mode comment, SOG can carry a `model` entry, and SPZ has an antialiased header bit. Other output formats have nowhere to record this information and can drop the tag silently. Pipeline owners need to treat render semantics as a conversion requirement, not an incidental attribute.

Antialiased and 2DGS Metadata During Conversion

SplatTransform has specific rules for scenes trained with antialiasing or represented as 2DGS. On input, it recognizes Brush's `SplatRenderMode` PLY comment, Postshot's `antialiased` comment, the SPZ antialiased header bit, and the SOG `meta.json` model entry. When more than one recognized source supplies a value, the README states that the later value wins.

A PLY containing `scale_0` and `scale_1` but no `scale_2` is read as 2DGS regardless of comments. SplatTransform materializes the missing column as a zero-thickness scale so later pipeline processing can operate on a consistent scene representation. On output, a 2DGS PLY drops the `scale_2` column again. That behavior makes the conversion internally consistent while preserving the source representation in formats designed for it.

Destination support remains uneven. PLY and Compressed PLY receive the applicable Brush-style render-mode comment. SOG writes either `antialiased` or `2dgs` in its model entry. SPZ sets its antialiased bit but warns that it cannot represent 2DGS. Formats without a place for this metadata drop the tag silently.

There is another boundary when several inputs are combined. If their detected models disagree, SplatTransform warns and writes the combined result as untagged. The operation does not claim that the resulting rendering mode is valid for every original input. Engineers building recurring conversion pipelines should inspect warnings and use `--info`, which reports this information as `model`.

Installing SplatTransform and Preparing a First CLI Run

The README distinguishes global CLI installation from local library installation. Install the package globally when a shell needs the `splat-transform` command:

npm install -g @playcanvas/splat-transform

The package metadata maps the `splat-transform` executable to `bin/cli.mjs`. After installation, the available command follows the documented form `splat-transform [GLOBAL] input [ACTIONS] ... output [ACTIONS]`.

Install the package as a project dependency when application code will import its library API:

npm install @playcanvas/splat-transform

This local form keeps the package within the project dependency tree while the global form prioritizes shell access. The README does not document a Node.js version requirement in the section provided here, so an adopter should check `package.json` and the library usage guide before imposing a runtime version in automation.

The first-use documentation does not provide a complete command with concrete file names, so this article does not invent one. The documented action-less conversion shape is:

splat-transform [GLOBAL] input [ACTIONS]  ...  output [ACTIONS]

Here, an input extension must appear in the documented input list and the output extension in the output list. For analysis without a generated file, the README identifies `null` as the output and `--stats` as a useful combination. It also links SuperSplat Convert as a browser-based option for one-off conversions without installing the package locally.

Library Exports, Generated Outputs, and Alternative Workflows

The package metadata exposes the main library through ES module and CommonJS branches. It also provides a `./worker` export, a `./viewer-settings` export, and direct `./lib/*` exports. These entry points indicate that the project is intended for more than its CLI wrapper, although exact programmatic calls are documented in the separate library usage guide rather than the README excerpt.

Output generation can cross from splat processing into rendering or collision workflows. A `.html` file creates a single-page or unbundled viewer based on SOG. A `.webp` file is rendered from a camera view through a GPU rasterizer. `.voxel.json` and `.voxel.bin` form a sparse voxel octree for collision detection. Streamed SOG creates multi-LOD assets for progressive delivery, while the LOD option provides a separate output purpose.

The GPU rasterizer makes the backend environment relevant for image output. The README links a Docker Backend guide for backend operation, including GPU and Vulkan setup. It does not document a complete fallback matrix for machines without those capabilities, so local installations should not be assumed to support every listed output.

A real alternative is a conventional 3D asset converter that operates on meshes or a different splat representation. Such a tool may fit an existing glTF or mesh pipeline, but it does not provide SplatTransform's documented Gaussian-specific merge, spherical harmonic filtering, SOG output, or collision-voxel generation. Conversely, choosing SplatTransform means accepting its format direction and metadata limits. The correct decision depends on preserving splat attributes, not merely opening a file with the same extension.

The MIT license permits reuse and modification under its terms. Review the repository `LICENSE` and any relevant dependency or asset notices separately. The README does not provide a migration guide for changing CLI action syntax between releases, so automation should be checked against the documentation for the installed version.

SplatTransform Release Activity and Upgrade Checks

The repository is not archived. Its last push was on 2026-10-09. Recent listed releases include v3.10.1 on 2026-10-09, v3.10.0 on 2026-10-06, and v3.9.2 on 2026-10-05. This sequence places recent changes within the same week, but the release list alone does not establish compatibility for a specific asset pipeline.

Upgrade review should focus on format behavior, especially antialiased and 2DGS metadata, because the README defines different preservation rules for PLY, SOG and SPZ. It should also cover action syntax, browser exports, Node.js entry points, and Docker or GPU requirements. The repository contains `src/`, `lib/`, `bin/`, `test/`, `rollup.config.mjs`, `tsconfig.json`, and package metadata, indicating separate source, library, command-line, build, and test areas.

The published package includes `dist/`, `bin/`, and `lib/`, according to `package.json`. Its runtime dependencies include `@adobe/spz` and `webgpu`. Changes in format readers or GPU-backed output can therefore affect more than the TypeScript application layer. Teams that pin versions should review release notes and reproduce representative conversions before replacing a working installation.

Maintenance is recent by the recorded 2026-10-09 push, but the cost of adopting updates remains specific to the workflow. A text-only format conversion has fewer environmental requirements than WebP generation through a GPU rasterizer. A large-scene delivery pipeline also has more acceptance criteria because it must preserve the intended LOD and Streamed SOG layout.

Editorial conclusion

SplatTransform suits engineers who need repeatable splat conversion, transformation, inspection, merging, or generated collision data through a shared CLI and library. It is a poor choice when the required direction is unsupported or when every render-model attribute must survive conversion. Before adoption, check the format matrix for the exact input and output extensions, inspect representative files with `--info`, and verify how antialiased or 2DGS metadata is handled by the selected destination.

Frequently asked questions

Official sources

1. License: MIT
2. playcanvas/splat-transform on GitHub
3. Project website
4. README
5. Releases