The SDK for Swift and Kotlin extends MapTiler's mapping stack: two native libraries designed to make high-performance mapping on iOS and Android as straightforward as possible.
Why we built our own mapping SDK
When we started planning our mobile SDKs, we needed a fast and reliable foundation respected by the community. Our JS SDK is built on MapLibre and includes many quality-of-life improvements, so it was the obvious choice for our mobile SDKs.
However, we noticed that mobile developers often spend too much time on "plumbing": manually constructing style URLs, managing API keys in strings, and configuring 3D terrain sources from scratch. We built the MapTiler SDKs to remove that friction by offering:
- Deep integration: Our SDKs are pre-configured to talk to MapTiler Cloud. Your API key and styles work out of the box.
- Product velocity: We have our own roadmap for features like offline region downloads and weather. Building our own SDK lets us ship these features faster, without waiting for upstream changes.
- Open foundation: Both the Swift and Kotlin SDKs are released under the BSD-3 license. We believe open source is better for a mapping SDK, and we continue to contribute core improvements.
After deciding we needed our own SDK, we had two main reasons for building it ourselves instead of using MapLibre directly:
- A connected experience: We want the SDK to be a natural extension of our data services. MapLibre is a community-owned, provider-neutral project. Our SDK, however, is built specifically to handle MapTiler's API keys, style formats, and search services right out of the box.
- Our own timeline: We have a specific vision for features like weather and mobile-first UI controls. Our SDK lets us release updates as soon as they're ready, without waiting for the community approval process required by a shared open-source project.
While the SDK is optimized for MapTiler Cloud, it remains fully compatible with any standard vector or raster tile source, and you can use your own data. You aren’t locked in. You just get a better experience by default.
Comparing mobile map SDK providers
Here is how our SDK compares to the most common alternatives.
| Alternative | Data Included | Notes |
|---|---|---|
| Google Maps SDK | Yes | Limited styling; restricted data usage; can be expensive at scale. |
| Mapbox SDK | Yes | Closed source; complex licensing; often requires more boilerplate for basic setup. |
| MapLibre SDK | No | Great foundation, but requires you to manually configure all data sources and styles. |
| MapTiler SDK | Yes | Open source foundation; one-line setup for styles and terrain; deeply integrated with MapTiler Cloud. |
Getting started with mobile maps on iOS and Android
Here's how to add the SDK to your iOS or Android project in minutes.
iOS (Swift)
On iOS, the SDK is distributed via Swift Package Manager. Just add our repository URL to your project in Xcode.
Make sure to set your MapTiler Cloud API key beforehand (e.g., in AppDelegate):
Task {
await MTConfig.shared.setAPIKey("YOUR_API_KEY")
}UIKit
import MapTilerSDK
let coordinates = CLLocationCoordinate2D(latitude: 47.137765, longitude: 8.581651)
let options = MTMapOptions(center: coordinates, zoom: 2.0, bearing: 1.0, pitch: 20.0)
var mapView = MTMapView(frame: view.frame, options: options, referenceStyle: .streets)
mapView.delegate = self
view.addSubview(mapView)SwiftUI
Building SwiftUI maps with the SDK takes just a few lines.
import MapTilerSDK
@State private var mapView = MTMapView(options: MTMapOptions(zoom: 2.0))
var body: some View {
MTMapViewContainer(map: mapView) {}
.referenceStyle(.streets)
}Android (Kotlin)
Android developers can add the SDK via Maven/Gradle. Once added to your dependencies, initialization is a one-liner.
dependencies {
implementation("com.maptiler:maptiler-sdk-kotlin:2.0.0")
}Jetpack Compose
// Make sure to set your MapTiler CLoud API key
MTConfig.apiKey = "YOUR_API_KEY"
import com.maptiler.maptilersdk.map.MTMapOptions
import com.maptiler.maptilersdk.map.MTMapView
import com.maptiler.maptilersdk.map.MTMapViewController
import com.maptiler.maptilersdk.map.style.MTMapReferenceStyle
val controller = MTMapViewController(context)
MTMapView(
MTMapReferenceStyle.STREETS,
MTMapOptions(),
controller,
modifier =
Modifier
.fillMaxSize(),
)By moving the API key and style selection into native objects, we eliminate long, brittle URL strings. Everything is autocompleted and type-safe.
Designed for the MapTiler data stack
We produce a massive amount of data, from our global tilesets to high-resolution satellite imagery and 3D terrain. The SDK is built to get it all onto your map with minimal setup.
With a free MapTiler Cloud account, you get professional cartography (Streets, Outdoor, Winter, and more, maintained by our design team), the ability to host and use your own GeoJSONs directly in the SDK, built-in geocoding through our Client library, and reliable global coverage from city streets to ocean bathymetry.
Smart styles and type safety
Writing map styles from scratch is hard. That’s why we provide a wide range of pre-built options tailored for different use cases (hiking, data viz, satellite).
In our SDKs, these aren't just strings; they are lists with built-in variants. If you use a tool like Android Studio or Xcode, you’ll get full autocompletion for every style we offer.
// Swift example of style variants
mapView.style = .dataviz.darkIn practice, that type safety buys you a few things: you don't need to remember whether a style is on 'v2' or 'v4' since the SDK always fetches the latest version, styles like Streets and Dataviz come with Light and Dark variants you can toggle with the system theme, and your API key is handled globally so you never append it to a URL by hand.
3D terrain mapping in one step
On mobile, 3D terrain brings maps to life, especially for outdoor and navigation apps.
// Kotlin: Enable 3D mountains with one call
map.setTerrain(true)
map.setTerrainExaggeration(1.5f)You can enable or disable terrain at any time without reloading the entire map, and we handle the underlying tile fetching and mesh generation for you.
Built-in mobile SDK helpers
The SDK includes a few built-in helpers for common mobile needs:
- Localization: The SDK automatically detects the device's language and updates map labels to match. You can also override this globally (e.g., map.setLanguage(.spanish)).
- User location: A single property handles the permission checks and displays the user’s "blue dot" on the map.
- Native controls: Zoom buttons and attribution are all native UI components that you can position easily using platform-standard layouts.
SDK documentation and GitHub support
We want to hear from you as you build. Both SDKs are documented, with examples for common use cases.
If you run into a bug or have a feature request, please open an issue on our GitHub repositories. We actively monitor them and use your feedback to decide what to build next.
What's next: offline maps and weather layers
We are currently working on offline packs that let you download areas you specify for offline use. We will also be integrating our weather layers directly into the mobile SDKs.
Rendering vector maps on mobile takes real work under the hood, but that complexity shouldn't leak into your code. Our goal with the MapTiler SDK is to keep the surface area clean and focused.
Right now, the SDK focuses on the essentials: handling the lifecycle for you, making 3D terrain a one-liner, and connecting to our cloud data with minimal setup.
As we plan bigger features, we're keeping the same principle in mind: the SDK should stay out of your way and make the maps "just work" so you can focus on your app.
Try it out today with a free MapTiler Cloud account and let us know what you think!
