A routing API gives you a route. A navigation SDK gets a person down it.

That gap is larger than it looks. The route is a one-time answer to "how do I get there." Navigation is a loop that runs for the length of the trip: take a position fix, decide where on the route that is, decide whether the person is still on it, work out which instruction comes next and when to say it, and redraw the screen. A routing API does none of that.

Key Takeaways

  • A navigation SDK handles position snapping, instruction timing, off-route detection, rerouting, and the guidance UI.
  • It is not the same thing as a routing API. A navigation SDK needs a route, so it has to get one from somewhere.
  • Ferrostar is a BSD-licensed open-source navigation SDK for iOS, Android, and web, with a shared Rust core and platform-native UI.
  • Whichever you choose, check license, platform coverage, how rerouting is triggered, and whether you can replace the location provider.

What a Navigation SDK Actually Does

The work runs continuously while a trip is in progress, and it splits into a few jobs.

  • Location handling. The SDK consumes a stream of positions and works out where on the route the user is. Ferrostar makes the location provider replaceable, which matters if your positions come from your own hardware or a simulator rather than the device.
  • Off-route detection. Deciding that a deviation is real rather than a bad fix. Ferrostar documents its off-route detection logic as customizable.
  • Rerouting. The Ferrostar SDK provides "support for real-time updates and rerouting," which means fetching a new route mid-trip and switching to it.
  • Instructions. The routing layer supplies the maneuver instructions, with "language flexibility with instructions in 25+ languages." The SDK decides when to surface each one.
  • The guidance interface. Ferrostar builds this from composable components in SwiftUI and Jetpack Compose, with a UI layer that uses MapLibre.

Each is tractable alone. Running all of them against live position data, for the length of a trip, is where the work is.

They solve different halves of the same problem.

  • A routing API answers "what is the path from A to B," returning geometry and turn-by-turn instructions as data.
  • A navigation SDK consumes that and runs the live trip.

You can use a routing API without a navigation SDK. Drawing a route line on a map, or showing an ETA, needs no navigation layer at all. The moment you want a user to follow the route in real time, you need the loop.

Going the other way is not really an option. A navigation SDK needs a route source, so choosing one means choosing or accepting a routing API behind it.

Open Source or a Vendor SDK?

Navigation SDKs come from the same vendors that provide routing APIs, including Google Maps Platform, Mapbox, HERE Technologies, and TomTom, and from open-source projects. Terms, platform support, and pricing change, so check each vendor's own documentation rather than a third-party summary.

An open-source SDK gives you the source, which decides whether you can change the parts that assume a car on a road. Off-route logic tuned for highway driving behaves differently for someone walking, and a default location provider may not be the one you want if positions come from your own hardware or a simulator.

Ferrostar

Ferrostar is the open-source entry Stadia Maps maintains. The documented facts:

  • License: open source under a BSD license.
  • Platforms: iOS, Android, and web. The product page also lists progressive web apps.
  • Architecture: a shared core written in Rust with platform-native UI, built as composable components in SwiftUI and Jetpack Compose.
  • Rendering: the UI layer uses MapLibre, with Metal rendering supported.
  • Customization: off-route detection logic and the location provider are both replaceable.
  • Travel modes: described as being for "foot, bike, car, and custom routing."
  • Source: github.com/stadiamaps/ferrostar, with platform tutorials at stadiamaps.github.io/ferrostar.

Using it with Stadia Maps basemaps and routing requires a Stadia Maps API key. The SDK documentation points to GitHub issues and the #ferrostar channel on the OSM US Slack for questions, with commercial support available through sales.

Choosing a Navigation SDK for a Mobile App

The navigation SDK sits between your route source and your UI, so these are the questions worth settling before you build on one.

  • License. Can you ship it in a commercial app, and can you modify it?
  • Platform coverage. Does it cover every platform you ship on, or will iOS, Android, and web each need a separate implementation?
  • Routing lock-in. Does the SDK work with a routing API of your choice, or only the vendor's?
  • Rerouting control. Can you change what counts as off-route, and how quickly a reroute fires?
  • Location provider. Can you feed it your own positions, from a fused provider, a simulator, or external hardware?
  • Travel modes. Does it handle the modes you need, or does it assume a car?
  • UI customization. Can you restyle the maneuver banner and progress views, or are you adopting the vendor's design?

Frequently Asked Questions

What is a navigation SDK?

A navigation SDK is a library that turns a route into a live guided experience. It handles snapping the user's position to the route, detecting when they have gone off it, requesting a reroute, timing turn-by-turn instructions, and rendering the guidance interface. A routing API provides the route; the navigation SDK runs the trip.

What is the difference between a navigation SDK and a routing API?

A routing API answers what the path from A to B is, returning geometry and instructions as data. A navigation SDK consumes that route and runs the live trip, including position snapping, off-route detection, rerouting and the guidance UI. You can use a routing API on its own to draw a route or show an ETA. Real-time guidance needs both.

Is there an open-source navigation SDK?

Yes. Ferrostar is an open-source navigation SDK available under a BSD license, with a shared core written in Rust and platform-native UI for iOS, Android, and web. Its source is at github.com/stadiamaps/ferrostar.

What is the best navigation SDK for a mobile app?

The choice turns on how much of the navigation behavior you need to change. Commercial SDKs come from the vendors that also provide routing APIs, including Google Maps Platform, Mapbox, HERE Technologies, and TomTom. Ferrostar is an open-source option under a BSD license, with native UI components in SwiftUI for iOS and Jetpack Compose for Android, and the same core on web. Check license, platform coverage, whether you can use your own routing API, and whether off-route logic and the location provider are replaceable.

What platforms does Ferrostar support?

Ferrostar supports iOS, Android, and web, with composable UI components in SwiftUI and Jetpack Compose. The product page also lists progressive web apps, and the documentation notes that the core runs on many embedded architectures.

Do I need a routing API to use a navigation SDK?

Yes. A navigation SDK needs a route to guide along, so it has to get that route from somewhere. Some SDKs work only with a specific vendor's routing. Using Ferrostar with Stadia Maps basemaps and routing requires a Stadia Maps API key.

Can I change how a navigation SDK decides a user is off route?

Check the SDK before you commit. Ferrostar documents off-route detection logic and the location provider as customizable, which matters for travel modes where the default assumptions about a car on a road do not hold.

Where to Go Next

Routing & Navigation