gpui-maps by GitHub

gpui-maps is a vector-map engine written in Rust. It draws on your GPU, inside your GPUI window, and the same code runs on iOS and in the browser as WebAssembly. No web view, no JavaScript, no access token.

View the source
A still frame of this demo. Start it to use it live.
Runs on your GPU. Loads a 15 MB WebAssembly module once.

© OpenStreetMap contributors · OpenFreeMap · Sentinel-2 cloudless by EOX · NASA

The whole planet, with clouds, night and stars, down to a single street. Drag to spin; pinch, or hold ⌘ or Ctrl and scroll, to zoom. Open full screen

Your first map in three commands.

Clone the repository and run the first example. It opens a window on Singapore with an open, keyless basemap.

src/main.rs
use gpui_maps::basemaps::{self, Basemap};
use gpui_maps::map_view::MapView;

let b = basemaps::load(Basemap::Liberty)?;
let map = cx.new(|_| MapView::new(
    103.85, 1.29, 12.0, 1024.0, 768.0,
    b.style, b.source, rt.clone(),
));

A map is a GPUI view, so you add it to a window like any other element. Read the getting-started guide.

Everything a map needs, in one engine.

The live maps above use a few of these. The rest are in the examples and the docs.

Tiles
Vector tiles over HTTP, PMTiles, MBTiles and raster tiles. Runs fully offline from a single .pmtiles file, with no account, key or outside service, so it works on private networks with no internet.
Data
GeoJSON, CSV, FlatGeobuf, GeoParquet and Cloud-Optimised GeoTIFF, with hover and click picking.
Visualisation
Arcs, animated trips, heatmaps, hexagon and grid binning, dot density, clustering.
3D
A globe with atmosphere and sky, building extrusion, and glTF models.
Navigation
Turn-by-turn route following on Ferrostar's Rust core: manoeuvres, rerouting and a follow camera, drawn by the engine.
Capture
Render a camera or a scripted map story to PNG or video, with no window.
Big data
Dot-density and H3 hexagon layers that stream their tiles live from ClickHouse, read-only and behind a SQL guard.
Dashboards
Charts linked to the map, defined in one JSON file with the SQL inline, for ClickHouse and Postgres (swat-maps-dash).
Catalogues
STAC 1.1 catalogues of open geodata, read into map layers with their licences (swat-maps-stac).

Your coding agent can drive the map.

An app built on gpui-maps can open a local HTTP port that describes itself. An agent lists the actions, calls them, and reads the map's state back as JSON, so it can move, inspect and test the map without screenshots.

claude
$ GPUI_MAP_AGENTIC_PORT=7334 cargo run --example basic_map &
$ claude
 
> Fly to Tokyo Station and tilt it so the buildings show.
 
● Bash(curl -s localhost:7334/ | jq -c '[.actions[].name]')
  ⎿ ["map.state","map.tiles","map.layers",…,"map.fly_to",…]
 
● Bash(curl -s -X POST localhost:7334/map/fly_to \
       -d '{"lon":139.7671,"lat":35.6812,"zoom":16,"pitch":60,"ms":1500}')
  ⎿ {"ok":true,"camera":{"lon":139.7671,"lat":35.6812,"zoom":16.0,
     "pitch_degrees":60.0,"bearing_degrees":null},"eased_ms":1500.0}
 
● The map is over Tokyo Station at zoom 16, tilted 60° so the
  buildings stand up. Read map.state to confirm what it drew.
  • Self-describing. GET / returns every action with its method, path and parameters, so the agent never works from a stale list.
  • Local only. The port binds to 127.0.0.1 and is off unless your app turns it on.
  • Reusable. The gpui-agentic-http crate gives any GPUI app the same surface, with an MCP server and a skill for Claude Code.

Connect Claude Code.

Start your app with its agentic port open, then pick either way, or both. They also work for any other GPUI app built on gpui-agentic-http.

MCP server
$ cargo install gpui-agentic-http
$ claude mcp add gpui-maps -e AGENTIC_HTTP_PORT=7334 \
    -- agentic_mcp_server

Every action becomes a Claude Code tool. A new action shows up as a tool by itself.

Skill
$ mkdir -p .claude/skills
$ cp -r gpui-agentic-http/skills/agentic-app \
    .claude/skills/

Claude Code finds the app's port and calls its actions over HTTP. Nothing to configure.

Rust everywhere: desktop, mobile and WebAssembly.

One engine, written once in Rust with WGSL shaders. It compiles to a native macOS view, an iOS app and a WebAssembly module, and draws the same map on each.

Your GPUI app
Midtown Manhattan in 3D, in a dark style, inside a macOS window.
macOS. A GPUI view on Metal. Add it to any window of your app.
gpui-maps.swatmobility.com/demo
The web demo: central Tokyo drawn in a browser by the WebAssembly build.
Web. The same Rust compiled to WebAssembly, on WebGPU with a WebGL2 fallback. This is a real browser frame.
An iPhone showing the Megurin bus network of Taito City, Tokyo, on a dark map with a legend and a time slider.
iOS. Rust on Metal in a UIKit shell, with a Swift embedding for SwiftUI apps. Shown: SWAT Studio on iPhone, replaying a Tokyo bus timetable.

Open the live web demo Loads a 15 MB WebAssembly module. Works best in a browser with WebGPU.

SWAT Studio: every example in one app

A free Mac app that opens the engine's demos side by side: styles, the globe, 3D buildings and vehicles, 25 transit networks on the clock, data visualisation, ClickHouse dashboards, PMTiles and GeoParquet. Built from the examples in the repository.

Download for Mac All releases Free. Signed and notarised. macOS 13 or later, Apple silicon and Intel.

Also in the repository

  • swat-maps-doc A map document format: datasets, layers, filters, scales and tooltips, with undo and redo.
  • swat-maps-dash A dashboard format and a guarded SQL template compiler.
  • swat-maps-stac A reader for STAC catalogues of open geodata.

Plain Rust with no GPUI dependency. They build for WebAssembly.

Free for everyone. Supported for teams.

Open source

Free

  • MIT or Apache-2.0, your choice
  • Commercial use included, no sign-up
  • Questions and bugs in GitHub issues
Get the source

Commercial support

Talk to us

  • Agreed response times and a private channel
  • Long-term support releases
  • Features built to your schedule
  • A commercial agreement for procurement
Contact SWAT