Aholo Viewer: A TypeScript 3DGS Renderer Built Around Chunked Streaming LOD

What Aholo Viewer Solves and Who It Is For

The project is a monorepo containing the renderer package, a documentation website, and a separate package called splat-transform. The renderer package is published as @manycore/aholo-viewer, and splat-transform as @manycore/aholo-splat-transform. The existence of a separate transform package suggests that preprocessing splat data is a first-class concern, which fits the streaming LOD approach. The target audience is not casual users; it is engineers who need to embed a viewer into a web app and are willing to read a manual and possibly dig into architecture notes.

The Chunked Streaming LOD Mechanism

The core mechanism is Chunked Streaming LOD, but the README does not explain the details. It only states that the renderer uses this schema. We can infer that the scene is divided into chunks, each with multiple levels of detail, and that chunks are streamed in as needed, likely based on camera position and view frustum. This is a common technique for massive point clouds and terrains. The renderer is written in TypeScript, so it runs in the browser via WebGL or WebGPU, though the README does not specify which graphics API. The repository structure shows a packages/renderer directory with TypeScript source, and the API docs are generated from src/index.ts. The splat-transform package likely handles converting raw splat data into the chunked format. Without more documentation, the exact data flow remains unclear, which is a limitation for potential adopters.

Build Requirements and Getting Started

To build the project from source, you need Node.js version 22.22.1 or higher and pnpm, with corepack preferred. The README gives a specific clone command because the repository contains submodules: `git clone --recurse-submodules https://github.com/manycoretech/aholo-viewer.git`. After cloning, you run `pnpm install`, then `pnpm dev` to start the development environment. There are also commands for checking and building: `pnpm check`, `pnpm build`, and `pnpm preview`. If you only want to build the renderer package, use `pnpm build:renderer`. The documentation website is built with Astro, and API docs are generated from the renderer's index.ts into a local ignored directory. The README mentions a manual at aholojs.dev and a jsfiddle example, but we cannot verify the content of those links. For npm package usage, you are directed to read packages/renderer/README.md, which is not included in the provided material.

Repository Structure and AI-Assisted Development

The repository is organized with a clear separation of concerns: packages/renderer holds the TypeScript source, website is an Astro site with manual and playground, docs contains architecture and AI collaboration notes, and external holds upstream dependencies. Notably, the project includes AGENTS.md, a guide for AI agents, and .codex/skills/ with project-local Codex skills. There is also a docs/ai/skills/use-aholo-viewer/SKILL.md that serves as an external npm package usage guide for AI coding agents. This is unusual and suggests the project is designed to be used in an AI-assisted coding workflow. The README even mentions a "vibe-coding-guide" for future AI-assisted changes. This is a point of differentiation: the project embraces AI agents as first-class contributors. If you are a developer who uses AI tools heavily, this structure may be appealing. If not, it is still useful because the architecture notes provide insight into the codebase.

Limitations and Failure Modes

The most obvious limitation is the lack of detailed documentation in the README. The Chunked Streaming LOD mechanism is mentioned but not explained. There is no information about supported file formats, memory usage, or performance benchmarks. The README points to a manual and a jsfiddle, but we cannot verify their content. This makes it hard to evaluate the renderer without visiting the website. Another limitation is the requirement for a bleeding-edge Node version (>=22.22.1). As of early 2025, Node 22 is not the latest stable, but it is recent enough that some environments may not have it. The repository also relies on submodules, which complicates cloning and may cause issues if a submodule is not properly initialized. The README warns to treat external/egs-core as read-only, which indicates a dependency on an upstream project. If that upstream changes, Aholo Viewer may break.

Alternative Approaches in the 3DGS Rendering Space

A direct alternative is the original 3D Gaussian Splatting renderer from the paper authors, which is typically written in C++ and uses a different data structure. That renderer is not web-based and requires a desktop environment. Another alternative is using a general-purpose WebGL/WebGPU library like Three.js and manually implementing splat rendering, which gives you full control but requires significant effort. The difference in approach is that Aholo Viewer provides a pre-built streaming LOD schema, so you do not have to design that yourself. However, the C++ reference implementation is more mature and has a larger community. If you need a web-based viewer and are willing to trade control for convenience, Aholo Viewer fits. If you need maximum performance and are not constrained to the browser, a native renderer may be better.

Maintenance and License Considerations

The project is MIT licensed, which is permissive and allows commercial use without restriction, but you should verify the license of the external submodule (external/egs-core) separately. The README does not state the license of that upstream dependency. The repository has recent activity: the last push was on 2026-07-31, with releases 1.8.1 and 1.8.0 on the same day. This suggests active maintenance, but also that the API may change rapidly. The CHANGELOG is mentioned but not included, so we cannot assess the stability of the API. The build process is automated with pnpm scripts, and there are content checks for the website, which indicates a disciplined release process. However, the project is relatively young, and the documentation is thin. You should budget time for reading the architecture notes and possibly the source code itself.

Editorial conclusion

Adopt Aholo Viewer if you need a TypeScript-based renderer for large 3D Gaussian splatting scenes and want a streaming LOD approach that keeps memory bounded. Avoid it if you require a stable API for production or prefer a more mature, widely documented renderer. Before adopting, verify the actual performance on your target hardware by running the provided examples, and check the CHANGELOG for breaking changes between 1.8.0 and 1.8.1. Also confirm that your Node version (>=22.22.1) and pnpm setup match the build requirements.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes