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 those rows into a 3D world is written here: the pipeline that generates each tile, the live service that pushes them to your browser, and the renderer that draws them on screen. No glue. No third-party tile vendor. Nothing about your map's quality or roadmap depends on a partner we can't fix.
- - Deferred shading
- - Cascaded shadow maps
- - Ambient occlusion
- - Edge detection
- - Atmospheric fog
- - Lens flares
- - 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, lens flares, the color of the next pixel.
- ·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.
- ·Lens flares. Pinned to the actual sun position, not a sprite.
- ·Color grade. Re-tone the whole engine to your palette in one step.
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.
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.
"3-bedroom under €600k, near a metro, calm street, parisian charm."
The answer pins itself to the right rooftops.
Sixty frames a second
on mobile
The platform picks the right level of detail and the right format for every visible tile. Bandwidth pays for what you can actually see.
Each visible tile gets a zoom level computed from its distance to the camera, and a format that fits its job: vector geometry up close, compressed raster at distance. Thousands of trees, lamps, and markers render in a single draw call. As upstream data changes, new tiles push to the client live, no polling. The planet is already ingested; you don't run out of world.
- ·Adaptive level of detail, computed per visible tile from camera distance.
- ·Vector geometry near, compressed raster far. Bandwidth scales with what's visible.
- ·Thousands of objects per tile in a single GPU draw call.
- ·Live tile push the moment upstream data changes.
- ·The whole planet, already ingested. Your scenes never run out of world.
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.