Rustic Maps SDK
Rustic Maps SDK is a native map SDK written in Rust. It gives your application map rendering, search, routing, turn-by-turn navigation, and offline maps from one Rust core, delivered to Android (Kotlin), iOS (Swift), and React Native through UniFFI’s UDL-first bindings. WebAssembly is a first-class target, so the same core renders map tiles in a browser with WebGPU.
What the SDK gives you
One contract, four platforms
The FFI surface is a single frozen UniFFI UDL file. The Kotlin, Swift, and React Native Turbo Module bindings are generated from it, and the WebAssembly TypeScript mirror is regression-checked against it. The contract changes addition-only: existing members keep their signature and meaning.
Search, routing, and traffic
Ten vendor-neutral provider contracts cover geocoding (forward and reverse), routing, the distance matrix, place search, traffic incidents, traffic flow, elevation, raster tiles, vector tiles, and offline routing. A full map-platform provider implementation backs them, rate-limited and retry-aware, with a disk response cache under your own byte budget.
A rendering core that draws anywhere
The renderer spans web-mercator projection, an anchored camera with
animations and fit-bounds framing, exact frustum tile listing, a
frame-driven tile scheduler with per-frame budgets and parent fallback,
and a byte-budget tile texture pool feeding a wgpu renderer. The same
scene draws headless in tests, on Android and iOS surfaces, and in the
browser through WebGPU.
Turn-by-turn navigation
The navigation state machine follows the Ferrostar model. It composes banner and spoken instructions verbatim from the provider’s text, publishes speech-instruction triggers at documented distance bands, and hands deviation handling and reroute policy to you at clear seams.
Offline maps
A deterministic compiler turns an OpenStreetMap PBF extract into a compact self-describing routing archive. An offline routing provider answers routes over the memory-mapped graph, honoring recorded turn restrictions, and wraps the online provider as an automatic fallback.
Structured diagnostics
A bounded, per-subsystem diagnostics ring streams structured log events to a foreign listener with coordinate scrubbing at the sink. Readbacks expose frame tile statistics, cache terms, and provider-failure records, so a screen in your product can show exactly what the SDK is doing.
Architecture at one glance
| Layer | What it is |
|---|---|
geospatial-types | The record and math layer: coordinates, bounding boxes, routes, places, traffic, tiles, and the typed error model |
geospatial-traits | The ten provider contracts every provider implementation fulfills |
map-core, map-cache | Provider resolution with cache-then-network behavior, backed by a SQLite response cache with per-category time-to-live and byte-budget eviction |
mapquest-provider | The map-platform provider implementation (rate-limited, retry-aware, fixture-tested) |
map-rendering | Projection, camera, tile scheduler, texture pool, and the wgpu renderer |
map-navigation | The turn-by-turn trip-state machine and its instruction composition |
map-offline-graph-compiler, map-offline-graph-archive | OpenStreetMap extracts compiled into the offline routing archive and its memory-mapped reader |
map-native-core | The UniFFI binding crate: the frozen UDL contract is the single source of truth |
map-web-bindings | The wasm-bindgen surface for the browser |
The full call surface these crates expose across the FFI is the FFI contract; each member’s documentation lives in the generated API reference.
Requirements at a glance
- Android: API level 24 or higher. The release AAR is 16 MiB across three ABIs (8.7 to 13 MiB each after strip).
- iOS: iOS 17 or higher. The XCFramework ships two arm64 slices.
- React Native: a source TurboModule package compiled against your application’s own React Native version.
- WebAssembly: any browser with WebGPU; the wasm package is 3.6 MiB.
Per-platform tables, artifact sizes, and the version policy are in Requirements and distributions.
Where to go next
- Install the artifacts and build a rendered map: Your first map.
- Resolve places and plan a route: Search and routing.
- Simulate a guided turn-by-turn drive: Turn-by-turn navigation.
- Keep rendering and routing working without a network: Offline maps.
- See the core running from a browser, no build step: Live demo.
Status and license
The SDK is in active development. The canonical short link is https://sdk.mapquest.live, which serves this site in place (subpaths preserved, so the hostname stays in your browser). The rendered site is rebuilt from the source repository’s build pipeline; a section appears here only once the pipeline that produces it is green, and each page carries the build’s provenance stamp.
The SDK is dual-licensed under MIT OR Apache-2.0. Map imagery © MapQuest; map data © OpenStreetMap contributors (ODbL). See third-party notices for the full attribution and license table, and keep the attribution visible in your application.