Today we are releasing the Bitruvius SDK for MapLibre GL JS in Public Beta, giving developers a high-performance way to bring large-scale 3D geospatial data directly into MapLibre.
The Public Beta is open to everyone and available at no charge for commercial and non-commercial applications under the Bitruvius SDK License Agreement. You can install it today from npm, explore the live examples, or dig directly into the API reference.
MapLibre GL JS has become an important foundation for open 2D web mapping. In the world of 3D maps, several projects have demonstrated ways to visualize 3D Tiles and I3S alongside MapLibre, but getting the data to render is only part of the problem. Production 3D geospatial integration means dealing with coordinate transformations, vertical references, terrain alignment, decoding, rendering integration, and the performance demands of moving massive datasets through a browser.
We built the Bitruvius SDK for MapLibre to solve those problems.
Loading 3D data is not the hard part
Positioning it correctly is.
Getting a 3D dataset onto the screen does not necessarily mean it is geographically correct. Real-world 3D data can involve ECEF, Mercator and local coordinate spaces, tileset transformations, projected coordinate systems, terrain elevation, and different vertical references and height models. Any one of these being wrong will mean your data is no longer accurate, even if it looks plausible at first.
These differences become especially obvious when 3D content meets terrain. A building floating above the ground is not correctly integrated. Neither is a point cloud that is horizontally correct but vertically offset from the surface beneath it. In an operational context, these errors are more than just cosmetic, because they propagate into every measurement, every drape, and every spatial question asked of the scene.
The Bitruvius SDK handles that positioning automatically. Its placement accounts for whether the MapLibre scene is flat or using a 3D terrain, reads the coordinate information published by the service, and converts between ellipsoidal and orthometric heights so that datasets authored against different vertical references line up with each other.
Terrain is part of the same pipeline. Bitruvius turns LERC-based elevation content into MapLibre 3D terrain, decoded through the SIMD-optimized TurboLERC codec, and that terrain becomes the surface the 3D content is positioned against. For vertical references, the SDK includes geospatial support for converting between WGS84 ellipsoidal and orthometric heights using EGM96 where required.
Load the data. Bitruvius determines where it belongs.
Map your 3D data in just a few lines
Working with 3D Tiles and I3S should feel like a natural extension of building with MapLibre.
Install the SDK:
npm install @bitruvius/sdk-maplibreThen add, for example, a 3D Tiles mesh layer using the same MapLibre addLayer() workflow you already use:
import * as maplibregl from 'maplibre-gl';
import {
prepareMapLibre,
Tiles3DMeshLayer
} from '@bitruvius/sdk-maplibre';
await prepareMapLibre(maplibregl);
const map = new maplibregl.Map({
container: 'map',
style,
pitch: 60
});
map.on('load', () => {
map.addLayer(
new Tiles3DMeshLayer({
id: 'city',
url: 'https://…/tileset.json'
})
);
});One layer. The SDK handles streaming, georeferencing, decoding, placement, and the working set underneath it. The same development model extends across the SDK for 3D Tiles, I3S, point clouds, Gaussian splats, buildings, integrated meshes, and other 3D content.
Connecting open 3D data standards within MapLibre
At the center of the SDK are the industry’s two major open standards for streaming large-scale 3D geospatial content: 3D Tiles and Indexed 3D Scene Layer (I3S). Both are Open Geospatial Consortium (OGC) Community Standards. 3D Tiles is developed and maintained through Cesium and its community, while I3S is developed and maintained by Esri, with versions of each specification adopted through the OGC Community Standards process.
Though while they serve similar types of data, the ways these data are stored and georeferenced are quite different, requiring different approaches to loading and streaming.
The Bitruvius SDK for MapLibre is an independent implementation built around the published 3D Tiles and I3S specifications and purpose-built for streaming this data in MapLibre GL JS, making large-scale 3D geospatial data from either format behave like it belongs in the map.
3D Tiles support
The 3D Tiles format is designed for streaming massive, heterogeneous 3D geospatial content. The ecosystem can represent photogrammetry, textured 3D environments, buildings, BIM/CAD, point-based content, and other tiled representations of the physical world.
The Bitruvius SDK streams 3D Tiles directly into MapLibre across a range of real-world content, including textured 3D objects, aerial and satellite-derived integrated meshes, point clouds, buildings, Google Maps Platform Photorealistic 3D Tiles, and Gaussian splats delivered through 3D Tiles.
For Gaussian splats, Bitruvius can stream Niantic SPZ content within a 3D Tiles tileset, with SPZ v1 through v4 decoded by Bitruvius TurboSPZ.
For Google Maps Platform services, developers provide their own Maps API credentials, and Google’s applicable terms, attribution, and usage requirements continue to apply.
I3S support
The SDK also brings I3S Scene Layers directly into MapLibre, including 3D Objects, Integrated Meshes, Points, Point Clouds, and Buildings/BIM.
An I3S Point Cloud Scene Layer can be streamed throughI3sPointCloudLayer, with LEPCC-compressed tiles decoded by Bitruvius TurboLEPCC. Projected datasets are not limited to Web Mercator either. The SDK can resolve coordinate information published by the service and position the resulting content within the MapLibre environment.
I3S 3D Objects can retain their attributes for filtering and GPU-driven symbology, while Building Scene Layers can be explored as geographically positioned BIM content. Existing I3S infrastructure can become part of a MapLibre application without replacing MapLibre as the application’s mapping foundation.
Your existing data should not dictate your renderer.
3D that behaves like part of the map
Geographic alignment is only one side of integration. The 3D content also needs to interact with the rest of the map.
The Bitruvius SDK uses MapLibre custom layers rather than treating the 3D environment as a disconnected application. The SDK rendering stack is built on WebGL2, with 3D content participating in the MapLibre scene and style ordering.
Vector data can also be draped directly onto 3D Tiles and I3S mesh content. A parcel boundary, flood zone, site plan, raster, line, circle, or heatmap can follow the surface of buildings and photogrammetry rather than disappearing underneath or cutting through the 3D scene. Symbol layers remain in screen space so labels stay readable instead of being painted onto walls.
The result is much closer to a GIS experience than simply drawing a second 3D canvas over a map.
Decoding built for performance
These datasets can be enormous, so decoding performance is an essential part of the Bitruvius architecture. The Bitruvius codecs are compiled to WebAssembly, SIMD-accelerated, and decode off the main thread through Web Workers where the browser supports it. The SDK returns compact data structures that can move efficiently into the WebGL2 rendering pipeline.
| Codec | Decodes |
|---|---|
| TurboSPZ | SPZ v1 to v4 Gaussian splats, including SPZ streamed through 3D Tiles |
| TurboLEPCC | LEPCC I3S point clouds and standalone point-cloud content |
| TurboLERC | LERC elevation and raster services |
The glTF and 3D Tiles pipeline also decodes Draco, meshopt, KTX2, and Basis.
Detailed codec benchmarks deserve their own publication with reproducible results, but early benchmarking shows up to 2x increase in decode speed using Bitruvius codecs. For this Public Beta, the important point is architectural: high-performance decoding is integrated directly into the SDK rather than bolted onto the visualization layer afterward.
What is available in the Public Beta
The current Public Beta supports MapLibre GL JS versions 5 and 6, with version 6 as the primary development target. The rendering stack uses WebGL2, while decoding can run through SIMD-enabled WebAssembly and Web Worker pools where browser capabilities allow it.
The Public Beta includes workflows across 3D Tiles and I3S spanning photorealistic 3D, integrated meshes, 3D objects, points, point clouds, Buildings/BIM, Gaussian splats, and elevation. Underneath the MapLibre integration are dedicated streaming engines for 3D Tiles and I3S, renderers for meshes, point clouds, Gaussian splats and rasters, geospatial coordinate and datum handling, and standalone codec packages.
As a Public Beta, the SDK will continue to evolve as we expand format coverage, harden APIs, optimize performance, and incorporate feedback from developers using it in real applications.
We want developers to push it.
Free to use
The Bitruvius SDK Public Beta is available at no charge for use in commercial and non-commercial applications under the Bitruvius SDK License Agreement.
Install it directly from npm:
npm install @bitruvius/sdk-maplibreThe SDK is proprietary Bitruvius software and is licensed rather than sold. The license allows the unmodified SDK to be used in applications, websites, and services and allows it to be distributed when embedded or bundled as part of those applications. Restrictions on standalone redistribution, modification, reverse engineering, and other uses are defined in the license agreement.
Third-party data and services remain governed by their respective providers. Google Maps Platform, Cesium ion, ArcGIS services, and other external services may require their own credentials, licenses, attribution, or fees independently of Bitruvius.
Try it
We did not want the launch experience to end with screenshots or a prerecorded demo.
The Bitruvius SDK for MapLibre GL JS Public Beta is open to everyone, and the Bitruvius SDK examples are runnable and editable directly in the browser. Change the code, hit Run, try different datasets, and push the SDK.
The examples include Google Photorealistic 3D Tiles, aerial and satellite integrated meshes, 3D Tiles point clouds, SPZ Gaussian splats, I3S 3D Objects, Integrated Meshes, Points, Point Clouds, Buildings/BIM, elevation services, masking, unified city-scale layers, measurement, elevation profiles, first-person navigation, and more.
Choosing MapLibre should not mean giving up access to 3D Tiles. Existing I3S infrastructure should not dictate the mapping framework used to build your next application. Open standards give developers the freedom to build different implementations around the same geospatial ecosystems, and we are building Bitruvius around that freedom.
3D Tiles. I3S. MapLibre GL JS. Open standards, independently implemented.
3D Tiles and I3S are OGC Community Standards. 3D Tiles is developed and maintained through Cesium and its community; I3S is developed and maintained by Esri. MapLibre, Cesium, Esri, Google Maps Platform, Niantic, deck.gl, and other names referenced are trademarks or names of their respective owners. References to third-party products, services, standards, datasets, or organizations are for identification and interoperability purposes and do not imply endorsement, sponsorship, or affiliation with Bitruvius.
