Vibeleaderboard
Index / tool
Visit github.com
Category
Developer Tools
Rank
No. 1112Tools index

Previous survey · No. 1099 ·

Type
TOOL
Use case
Coding
GitHub
595 stars
Latest release
v0.20.0
Date

About

MapLibre Compose is a Kotlin library for adding interactive vector maps to Compose Multiplatform apps on Android, iOS, desktop and web. It is not tied to a map provider, so it works with any MapLibre style and tile source. The author moved from wrapping the Android and iOS SDKs to building on the MapLibre Native C++ core, because the wrapper approach could only expose features both SDKs shared and had no desktop option.

What it does

A set of Kotlin building blocks that put a live, pannable map inside an app screen the same way a button or a list goes there: you describe the map with ordinary UI code and app state, and the library draws it. Phones and Mac, Windows or Linux desktops share one rendering engine, MapLibre Native, while the browser build swaps in MapLibre GL JS. Both engines read the same style format, so one map style and one Kotlin interface cover every target. Add-on modules handle device location, and the demo apps extend to Android Auto, CarPlay and Wear OS.

Why it's ranked here

It sits under the MapLibre organisation, publishes signed packages to Maven Central under a BSD 3-Clause license, and covers far more than a thin wrapper would: separate renderer packages for Vulkan, OpenGL and Metal across Linux, macOS and Windows on both x64 and ARM64, plus location providers for Google and Huawei phone services. The contributor guide shows release discipline as well, with tagged semantic versions and a check that compares the public API against committed snapshots. The ceiling is maturity. Its own stability table rates Android and iOS as Beta, and desktop and web as Alpha.

What's good

One Kotlin interface across every target is the main draw, and the docs state it plainly: the native engine and the browser engine read the same style format. Desktop builds need no C++ toolchain, because they use prebuilt MapLibre Native bindings. Graphics backends are exposed per platform rather than hidden, so a Linux or Windows app can pick Vulkan or OpenGL and a Mac app can pick Metal. Contributor tooling is reproducible: one tool pins the versions CI uses, and every CI job is a task you can run locally. Desktop tests drive a real GPU instead of mocking the renderer.

Tradeoffs

The README says minor releases can still break the public API, and the docs repeat that until version 1.0 a minor bump may contain breaking changes. Desktop and web are Alpha because they depend on internal details of Compose and Skia, and native macOS is Experimental. Offline map downloads are not available in the browser. Working on the code is heavy: Xcode for Apple targets, a pinned Android SDK, and a Vulkan-capable GPU for the desktop tests, which fail on a host without one. The license file still carries an unfilled project-name placeholder in its third clause.

How to use it well

Best fit: a Kotlin team already on Compose Multiplatform that wants the same map screen on Android and iOS, fed by its own tiles or any hosted MapLibre style. Pin an exact version and test each minor upgrade before adopting it, since those can break the API. Treat the desktop and web targets as previews for now. If the product depends on offline maps in a browser, or needs a frozen API contract today, this library does not yet cover that need.

Technical notes+

settings.gradle.kts includes :lib:maplibre-compose and :lib:maplibre-compose-material3, a :lib:location module with gms, hms, linux, macos and windows runtimes, and renderer runtimes split by backend and architecture: opengl and vulkan for Android; vulkan and opengl for linux-x64, linux-arm64, windows-x64 and windows-arm64; metal, vulkan and opengl for macos-arm64. It also adds Huawei's Maven repository scoped to com.huawei, and the demo-app tree has android-auto, wearos, desktop, desktop-nucleus and macos subprojects. build.gradle.kts only aggregates Dokka API docs for the published modules. gradle.properties sets POM_LICENSE_NAME=BSD-3-Clause and signAllPublications=true, keeps 0.0.0-SNAPSHOT placeholders that mise tasks replace with tag-derived versions, and raises the Gradle heap to 4g because iOS release linking exhausts 2 GiB. CONTRIBUTING.md describes mise run api:check against committed api/ dumps (macOS with Xcode only), desktop tests on a headless Vulkan device, desktop using the published maplibre-native-ffi bindings, and a patched MapLibre GL JS that Gradle builds for the web target. docs/src/content/docs/index.mdx maps each platform to its engine and notes the browser lacks offline downloads. LICENSE keeps the template text 'Neither the name of [project]'. AI_POLICY.md is a contributor policy for humans using AI tools; no injection-shaped instruction aimed at a reviewing model appears in the fetched files.

Observed

License
BSD-3-Clause
Language
Kotlin, Compose Multiplatform
Packaging
Maven Central, group org.maplibre.compose, signed publications
Platforms
Android, iOS, native macOS (arm64), desktop JVM, web (Kotlin/JS)
Map engines
MapLibre Native on Android, iOS, macOS and desktop; MapLibre GL JS in the browser
Declared stability
Android and iOS Beta; desktop and web Alpha; native macOS Experimental; minor releases may break the API before 1.0
Renderer backends
OpenGL or Vulkan on Android, Linux and Windows; Metal, Vulkan or OpenGL on macOS arm64
Location runtimes
Google (GMS), Huawei (HMS), Linux, macOS, Windows
API compatibility check
Public API compared against committed dumps (CONTRIBUTING.md)
Browser limitation
Offline map downloads not available on web
Test requirements
Desktop tests need a Vulkan-capable GPU

Read from README.md, build.gradle.kts, LICENSE, settings.gradle.kts, gradle.properties, AI_POLICY.md, CONTRIBUTING.md, docs/src/content/docs/index.mdx, docs/package.json.

Tags

kotlincompose-multiplatformmaplibremapsvector-mapslibrary

Tech Stack

Node.js

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.