DeckGL Streamer
Scalable 3D Point Cloud Streaming for Modern Web Visualization
Large-scale 3D point cloud datasets present unique challenges: precision issues in browser rendering, unpredictable memory growth, and architectural coupling between streaming and visualization layers. These challenges are magnified for non-geographic datasets — indoor scans, engineering surveys, industrial capture, and local metric systems — where assumptions about longitude/latitude simply don’t apply.
DeckGL Streamer is a purpose-built architecture that addresses this space: a structured 3D point cloud streaming pipeline optimized for local coordinate space and modern WebGL visualization. It couples seamlessly with deck.gl for GPU-accelerated rendering and React for lifecycle orchestration, while keeping the streaming logic independent and explicit.
Why a dedicated streamer?
Tile3DLayer is a strong solution for 3D Tiles workflows. This project focuses instead on native EPT streaming in local space, with explicit point-budget control and a stricter separation between streaming and rendering. The goal is to pair its rendering capabilities with a streaming layer designed around local-coordinate point cloud workflows.
Check out the video below and read more about the project...
City-scale streaming
City-scale point cloud streamed dynamically.
Tiles are loaded on demand based on camera position and view frustum.
True 3D loading
Point clouds are streamed in full 3D.
Tiles are resolved across x, y, and height (z), not just on a 2D plane.
Street-view navigation
First-person “street-view” navigation through a dense point cloud.
Tiles stream dynamically as the camera moves through the scene.
Synthetic Forest
Navigation through a synthetic dataset for demo purposes. The data was created using 2500 individual random trees on a 50x50 grid. Each tree has between 150K and 200K data points. the shape, color and size of the tree are sampled from a parameter space. Full data size is about 400M data points.
Motivation
In client projects involving large 3D point cloud datasets, the same tension kept reappearing: balancing performance, architectural clarity, and budget constraints.
Industrial and indoor scans often live in local coordinate systems. Clients needed scalable browser-based exploration, but without the engineering overhead of building or maintaining a tightly coupled custom viewer. At the same time, precision issues and rendering instability quickly emerged when pushing standard WebGL pipelines beyond their comfort zone.
DeckGL Streamer was developed out of that practical struggle — to provide a structured streaming layer for large point clouds that preserves numerical precision, keeps concerns separated, and integrates cleanly with modern web ecosystems.
Design Goals
Reliable streaming of hundreds of millions (and beyond) of points
Stable rendering in local coordinate space
Explicit control over point budgets and level-of-detail
Clean separation between streaming and visualization
Integration with modern web ecosystems
Capabilities
Native Entwine Point Tile support
Explicit point budget control
Stable local-space rendering
Modern GPU visualization via deck.gl
Integration-ready architecture
Intended Use Cases
Indoor and industrial scans
Engineering and metric datasets
Digital twin environments
Non-geographic 3D data at scale
Architecture Overview
1. Native EPT Streaming
The streamer operates directly on Entwine Point Tiles (EPT).
Tile hierarchy, metadata traversal, and loading prioritization remain native to the EPT structure.
No custom format or viewer-specific preprocessing is required.
2. View-Driven Tile Selection
Tile loading is driven by camera position, pitch, and bearing.
Frustum-aware tile selection
Progressive loading
Deterministic level-of-detail
Explicit global point budget
This ensures stable navigation even under rapid camera movement.
3. Local Coordinate Precision
Datasets are transformed to a local origin before rendering.
This prevents floating-point precision issues common when rendering large coordinates in WebGL.
The architecture does not depend on CRS pipelines or geographic assumptions.
4. Rendering Integration
Rendering is delegated to deck.gl.
This allows:
GPU-accelerated visualization
Flexible styling and coloring
Interaction and picking
Composition with additional layers
The streaming layer remains independent from the rendering engine.
5. React Orchestration
React manages lifecycle and state updates.
Streaming, rendering, and UI logic remain separate concerns, making the system suitable for integration into larger applications.