3D map library that renders OpenStreetMap as a globe
The 3D map platformfor products that don't blend in
Performance. Customization. A look that's yours.
Everything starts
with OpenStreetMap
The rest is ours, from query to pixel.
OpenStreetMap is our data source. Everything that turns that data into a 3D world is written in-house: the pipeline that generates each tile, the live service that pushes them to your browser, and the renderer that draws them on screen. A standalone stack. No third-party tile vendor. Nothing about your map's quality or roadmap depends on a partner we can't fix.
- - A high dynamic range (HDR) pipeline
- - Cascaded shadow maps
- - Ambient occlusion
- - Edge detection
- - Atmospheric fog
- - An atmosphere limb pass
- - Sun and moon bloom
- - Filmic tonemapping
- - Color grading
- - A composable shader chain
A look nobody else has
Set a date and a place. The sun rises where it should. The moon shows the right phase. The stars are where they were that night. Every tone the map carries follows.
The platform doesn't fake the sky. Sun position is computed from your coordinates and the date you pass it. The moon shows the lunar phase of that exact night. Above them, a catalogue of real stars rotates as it would for an observer at that spot. The sun then drives every directional light in the scene: shadows, atmospheric tint, the glow around the sun itself, the color of the next pixel.
Climb out of the atmosphere and the sky keeps going. Stars pass behind the planet. Constellations appear. The horizon thins to a lit rim on black.
- ·Real shadows. Cast in real time as the sun moves across your scene's depth.
- ·Ambient depth. Alleys, doorways, recesses darken the way they would.
- ·Atmospheric fog. Distance hazes; canyons keep their depth.
- ·Sun and moon bloom. Pinned to the actual sun position, not a sprite.
- ·Color grade. Re-tone the whole engine to your palette in one step. Nothing is baked, so it holds at every distance.
Bend it to your product
Your camera, your scene, your objects, your palette. The engine stays open to you all the way down to the shader chain.
The default camera lets users pan and zoom. Swap it. Plug a first-person controller, a drone overflight, a driving rig. Same scene, different navigation paradigm. Drop your own 3D objects into the world. Re-tone the entire output to your brand. Replace shader chunks if you want. The renderer doesn't hide them.
As simple as: const map = new CityMap3D(config)
Bring your own camera
Free-fly, first-person, drone, driving. The navigation paradigm is yours.
Bring your own 3D objects
They render alongside the world's geometry.
Re-grade the engine
Match your palette in a single configuration step.
Replace shader chunks
The post-effect chain is composable; nothing is hidden.
Anchor your AI answers to the world
Plug a RAG, an agent, any source that returns coordinates. Get back, every frame, the screen positions where your tooltips, badges, and dashboards belong.
The platform owns the camera and the projection. It streams the geo-to-screen mapping back to you in real time, frame-synced with the render loop. Your AI's answers live over the right rooftop, the right street, the right point, and they follow the camera as the user moves.
The search that finds those points can be yours too. A geocoder over your own index, and a category matcher whose embedding model runs on your own machine. Nothing leaves it, when you build the index or when a user types.
"2-bed under $1.2M, near a subway, quiet street, prewar charm."
The answer pins itself to the right rooftops.
It adapts to
the device it lands on
The platform measures the frame it actually delivers and takes work off itself until the frame fits. Nobody has to guess what your users carry.
Every visible tile gets a level of detail computed from its real distance to the camera, and every tile is geometry. No raster fallback, near or far, so your palette reaches the horizon. Thousands of trees, lamps, and markers render in a single draw call. Decoding runs off the main thread; the map stays under your finger while it loads. New tiles are announced over the WebSocket the moment they are ready, no polling. The source is the whole planet, so your scenes never run out of world.
- ·The load follows what a frame costs on the device, not a budget we picked for you.
- ·Adaptive level of detail, computed per visible tile from its true distance in three dimensions.
- ·Real geometry at every zoom. No raster fallback anywhere in the pipeline.
- ·Tiles travel as a binary format built for the job, not as text.
- ·Thousands of objects in a single GPU draw call, pooled across every loaded tile.
- ·Tiles announced over WebSocket the moment they are ready, no polling.
- ·Park the camera and the map keeps filling in behind it.
From a streetlight to orbit,in a single frustum
One import. One config.
Take the controls
Open the demo and watch the sun set on a city you know. Or get in touch when you're ready.