MapLibre

Welcoming YellowMap as a Silver Sponsor!

Fri, 15 May 2026 00:00:00 GMT

We are thrilled to officially welcome YellowMap as a Silver sponsor of the MapLibre organization!

Why YellowMap Chose MapLibre: A Shift to Modern Vector Maps

For YellowMap, the decision to migrate to MapLibre was driven by a desire to modernise and add functionality. They recently transitioned from raster map configurations to vector tile approach allowing for smoother zooming and easier customisation. During this transition, YellowMap conducted exhaustive high-load and performance testing that confirmed MapLibre could meet their high standards.

Today, YellowMap’s infrastructure, powered by a Kubernetes cluster, serves nearly a million map views a day and handles global map tile updates every four weeks. MapLibre GL JS has helped them handle this massive scale effortlessly.

How YellowMap Meets Data Compliance Needs with MapLibre

At the core of YellowMap’s product offering is SmartMaps, built to address the strict data privacy demands of the European B2B market. While many modern mapping providers rely on external content delivery networks (CDNs) or track user behaviors via cookies, YellowMap takes a self-hosted approach:

100% GDPR Compliance: YellowMap hosts all mapping systems entirely on their own self-managed servers.
No Tracking: SmartMaps solution operates completely without cookies and does not transmit any user data (such as IP addresses or advertising IDs) to external providers or third-party CDNs.
Digital Sovereignty: SmartMaps’ independent architecture provides data security for privacy-critical B2B power users, including major financial institutions like Sparkasse, where end-users rely on secure interfaces to do things like look up local ATM branches.

Showcase of SmartMaps used in a store-locator application.

MapLibre’s open-source, vendor-agnostic nature goes hand-in-hand with YellowMap’s data privacy and digital sovereignty philosophy, allowing them to maintain complete ownership of their tech stack and uphold their digital sovereignty unique selling proposition (USP).

How YellowMap Utilizes MapLibre Today

YellowMap’s core mapping SDK, SmartMaps GL, functions as a specialized wrapper around MapLibre GL JS. Their current deployment relies heavily on several advanced MapLibre features:

Globe View: Providing an immersive, global perspective for large-scale data visualization.
Multi-Language Support: Enabling end users customers to switch map languages dynamically.
3D Buildings: Rendering buildings as 3D extrusions for detailed cityscapes and immersive urban visualizations.

The Road Ahead

YellowMap’s integration with MapLibre is only expanding. Driven by growing customer demand for digital sovereignty and data protection, they are currently preparing to integrate MapLibre Native into their environment, with internal technical documentation slated for completion in the coming days.

YellowMap is also interested in developments surrounding the entire backend tile generation stack, Martin tile server format integrations, and native support for simple SVG sources.

We are incredibly grateful for YellowMap’s support, which helps ensure that MapLibre remains open, and community-driven mapping framework for everyone. If you are interested in sponsoring MapLibre, please reach out to us at sponsor@maplibre.org. We would love to hear from you!

MapLibre Newsletter April 2026

Sun, 03 May 2026 00:00:00 GMT

Welcome to the April 2026 edition of the MapLibre Newsletter! This month, we have exciting updates across all our projects. Key milestones include overhauls for React Native and Flutter, the transition toward MapLibre GL JS v6, and foundational research into a native MLT 3D tile format.

📱 MapLibre Native

Alex Cristici improved the resilience of MapLibre Native when the system runs out of memory (see PR).

There now is a new experimental C API for MapLibre Native, which can serve as a foundation for new platforms. See the new repository as well as the onboarding discussion. This is the work of Sargun Vohra, who also used what he learned when creating MapLibre Compose for the new C API.

Releases:

Platform	Latest Versions
Android	13.1.0
iOS	6.25.1 , 6.26.0

🌐 MapLibre GL JS

Versions 5.22.0, 5.23.0, and 5.24.0 were released this month, introducing mostly performance improvements and bug fixes along with minor public API additions, and marking the final releases for version 5.

We have begun releasing version 6 pre-releases featuring the breaking changes planned for this major update. We will continue rolling these out over the next few weeks and expect to finish shortly.

The primary breaking changes for this version include:

Dropping WebGL1 support to resolve long-standing bugs and feature requests while improving performance and compatibility with modern libraries.
Transitioning from CommonJS to ESM, which will allow us to move faster, adopt modern tools, and upgrade our overall build system and infrastructure.

Once all breaking changes are in place, we will provide a migration guide to assist with the transition from version 5 to version 6. While most changes so far are fairly trivial, some may be tricky; we encourage you to try these pre-releases and help us build robust migration documentation for the community.

It has been over a year since our last major update, and we believe now is the right time to move on from legacy constraints we have carried for a while.

As always, we would like to thank all our contributors:

👏 Xavier Bourry, Frank Elsing, Jakub Pelc, itisyb, Yu Chun Tsao, neodescis, Matt Van Horn, Will Field, Ashwin Chandran, Seokcheol Jeong, Sam, and Kyℓe Hensel.

🧩 MapLibre Tile (MLT)

Markus Tremmel has shared initial design considerations and encoding strategies for MLT 3D, building on an original proposal by Anas. This project explores how a dedicated 3D tile format can be optimized for the MapLibre ecosystem while identifying key areas where it diverges from existing standards like 3D Tiles.

There is potential for direct MapLibre GL JS integration, which would pave the way for more robust 3D capabilities natively and the project is currently seeking feedback on both use cases and technical encoding.

You can explore the design document and provide feedback on the GitHub repository.

⚛️ MapLibre React Native

MapLibre React Native v11 is here, and it is the first release to exclusively support React Native’s new architecture. Alongside this foundational shift, the entire API has been overhauled to align with MapLibre GL JS, making it easier than ever to share knowledge and code between web and native map implementations.

One of the most exciting additions is style-spec compliant paint and layout props on the unified Layer component. This means layer definitions exported from the style spec can be spread directly onto a Layer component with no translation needed.

A full migration guide with before-and-after code snippets for every breaking change is available in the v11 migration docs. Grateful to everyone who contributed to this release and look forward to building on this clean foundation in the versions ahead!

🪶 MapLibre Flutter

flutter-maplibre-gl

flutter-maplibre-gl, the long-standing Flutter plugin, has shipped v0.26.0! This release focuses on closing years of accumulated backlog and bringing the package back to a healthy maintenance baseline.

Interactive examples of new features.

Highlights:

Offline regions, rebuilt end-to-end — the offline manager now supports pause/resume of downloads, per-tile progress reporting, cache eviction policies, and rate-limit safety on the tile server side.
WASM release mode on Flutter Web — long-standing build issues with WASM in release mode have been resolved, making Flutter Web a viable production target.
takeSnapshot() — a single, unified snapshot API now works consistently across Android, iOS, and Web.
Tap handling — onMapClick now reliably fires on every tap, including taps on rendered features.
Feature State on Web — setFeatureState, getFeatureState, and removeFeatureState are now available on the Web platform, closing a feature parity gap with the native platforms.
Camera interpolation — easeCamera now accepts interpolation curves, removing velocity jumps in GPS-following scenarios.
Synchronous GeoJSON drag — drag handling for GeoJSON features is now synchronous, eliminating stale positions during interactions.
A long tail of fixes — including Android split-screen behavior, an iOS onStyleLoaded race condition, and a brand new example app.

A screenshot of the new hover effect.

Full changelog: https://github.com/maplibre/flutter-maplibre-gl/blob/main/CHANGELOG.md

Package: https://pub.dev/packages/maplibre_gl

Special thanks to all the contributors and maintainers for shepherding the package through this work.

flutter-maplibre

Version 0.3.5 of the flutter-maplibre has been released, featuring several improvements to consistency and stability alongside general maintenance. The MapLibre SDKs and the dependencies on jni / jnigen have been updated.

As an ongoing task, work continues on static typed expressions that fit well into Dart. Ideas regarding the Dart syntax, can be discussed here.

✨ Community Spotlight

HDTP is an open data platform by Codeando México that features a notable GTFS Realtime (GTFS-RT) visualizer. This tool combines MapLibre with deck.gl to create an interactive map (checkout the cine mode) for exploring real-time transit data, efficiently displaying live vehicle positions.

👥 Conferences & Events

LinuxFest Northwest

On April 25, Stephanie May and Matt Wilden delivered a joint presentation at LinuxFest Northwest on the synergies between MapLibre and OpenStreetMap US. They discussed how the tooling and infrastructure across both ecosystems have matured enough for anyone to build an open-source map—including building custom tiles, styling layers, and scaling a CDN or dynamic tile server.

The enthusiastic crowd was eager to dive deeper into the world of open mapping. You can find the slides for their talk, titled “The Latest in Open Source Maps,” here, along with various demos showcasing how accessible working with open-source data and maps has become.

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Native: May 13, 2026 – 7:00–8:00 PM Berlin Time (UTC+2)
MapLibre GL JS: May 13, 2026 – 8:00–9:00 PM Berlin Time (UTC+2)

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

May 27, 2026 – 9–10:00 AM UTC

All calls are open to everyone. Zoom links are shared in the MapLibre Slack. Not yet a member? Request an invite via the OpenStreetMap US Slack and join the #maplibre channel. We’d love to see you there!

MapLibre Newsletter March 2026

Fri, 03 Apr 2026 00:00:00 GMT

Welcome to the March 2026 edition of the MapLibre Newsletter! This month marks a significant transition for our community. We have made the decision to sunset the current MapLibre Bounty Program as we shift towards a contributor recognition system.

Please stay tuned for more details in the coming months as we finalize how this new system will empower our community. In the meantime, we encourage everyone to read the FAQ included in our recent blog post for more context on this change.

This evolution is made possible by the continued and growing support from our partners.

🙏 We are particularly grateful to Notion for their recent financial contribution via Open Collective.

Contributions like these are vital as we look out for co-funding models for major features like Terrain3D and the maturation of the MapLibre Tile (MLT) project.

Now, let’s dive in for the latest updates!

📱 MapLibre Native

Releases

Platform	Latest Versions
Android	13.0.0 , 13.0.1 , 13.0.2
iOS	6.24.0 , 6.25.0
Node.js	6.4.0 , 6.4.1

Terrain3D: Call for Funding

Support for Terrain3D is one of the most upvoted features for MapLibre Native. While several, (mostly) vibe coded prototypes have been developed, delivering a production-grade implementation is something that requires a significant investment in graphics engineering and expertise.

A visualization of elevation data

We are pleased to announce significant progress! We have identified a company that is willing to commit substantial funding to this initiative. However, they are seeking an additional co-funding partner to bring this feature to life.

If your organization is interested in supporting this development, please reach out to us at team@maplibre.org. We are also open to connecting with individual developers who are interested in contributing to this effort.

To clarify, MapLibre (the organization) is not directly funding Terrain3D for MapLibre Native at this stage. Instead we are facilitating connections between interested parties (companies, developers). MapLibre will provide maintainer support through consensus building, quality control, CI/CD, communication and release management.

We have created a dedicated branch feature/terrain-3d for continued work on the initial prototype. You can follow the progress in this PR.

🌐 MapLibre GL JS

We had a great month with 5 new releases: v5.20.0, v5.20.1, v5.20.2, v5.21.0, v5.21.1.

✨ Some of the highlights of this month include:

We introduced updateable features to the geojson-vt library, which improved the GeoJSON update performance significantly. While this initially caused a few nasty bugs which were quickly resolved thanks to Ryan Scully, the results are worth it. The latest version is reportedly 7x faster compared to when we began GeoJSON optimizations a few months ago. Many thanks to everyone who contributed code, helped with the testing, and submitted bug reports!
Memory optimizations and removal of legacy code supporting outdated browsers, mainly lead by Johan.
Improved ETag handling added by Rivka Matan and Ryan Scully stops the map from re-downloading unchanged data, saving bandwidth and speeding up load times.
Resampling support is available now. This was added by Lars Maxfield. This option lets users turn off smoothing to see raw, pixel-accurate terrain data instead of a blended or blurry image
An example of how to use MapLibre GL JS with 3D tiles example was added by Hang.

Last month we mentioned starting pre-releases for Version 6. However due to the high volume of contributions to the current branch, we have decided to continue with Version 5 for now. We still aim to begin the Version 6 transition in the coming months.

🏆 The sheer volume of work contributed this month is amazing! A huge thanks to this month’s contributors: Claudio, Baixiaochun, Xavier Bourry, Johan, Kikuo Emoto, Kate Miháliková, Gareth Bowker, Danila Poyarkov, Ted Piotrowski, Hang, yano-h-wni, Rivka Matan, Ryan Scully, ItisYB, Lars Maxfield, JT, Stephen Andre and PierreC.

🧩 MapLibre Tile (MLT)

The MapLibre Tile (MLT) project has seen significant progress this month. The Rust implementation is rapidly maturing; we have introduced a comprehensive suite of synthetic tests to ensure stability across edge cases.

Beyond just stability, we have achieved full decoding and expanded partial encoding support, bringing us closer to a production-grade toolkit. This progress is a major step toward making MLT a viable, high-performance alternative to MVT, offering better compression and faster parsing for large-scale geospatial data.

Tim Sylvester also made many improvements to the Java CLI tool. The performance for parallel conversion from MVT has been improved by several orders of magnitude. This now makes it a suitable tool to adapt existing MVT creation pipelines. In addition, the data input of the Java encoder is being generalized. This prepares MLT for a future where the data model of MLT that goes beyond MVT parity, enabling support for m-values or encoding lists and nested key-value structures.

On the rust side (competition is good!), both the encoder and decoder have seen major refactorings by Yuri Astraken and Frank Elsinga that have increased this encoders performance and output quality signifcantly. It can now beat java in most cases, but this is because we have settings that explore more state-space which is slower. More engineering is neccesary to improve performance beyond what java offers. There are also experiments using diplomat to provide FFI access to the rust based tooling. More on this in the next update.

You can follow the development and check out the MLT Specification on GitHub.

🦀 Martin

This month, like the last month, has been focused on implementing a production-grade MLT encoder/decoder, so there has not been much movement regarding Martin.

We fixed a startup crash that occurred when ST_Extent returns a LineString instead of Polygon , and added ZSTD support thanks to @nuts-rice. We also further reworked our new documentation site and ironed out a few of the remaining inconsistencies.

✨ Community spotlight

We are tracking an exciting development in the rendering world: the Slug algorithm is now out-of-patent.

Most maps currently draw text using pictures of letters, which can look fuzzy when you zoom in close to the map view. The Slug algorithm replaces these pictures with mathematical blueprints, allowing labels to remain perfectly crisp at any angle or scale.

Now that this technology is public property, we are looking for community members to help us research how to bring these benefits to MapLibre. Join us in our GitHub discussion.

👥 Conferences & Events

FOSSGIS

MapLibre was well-represented at the FOSSGIS, a German open source geospatial and OpenStreetMap conference. It was a fantastic opportunity to connect with the community and share updates on our projects.

Oliver Wipfli(former MapLibre coordinator) shared how his project Mapterhorn is expanding from terrain tiles to create a new dataset with satellite coverage.
Kilian Finger discussed progess on getting MapLibre React Native ready for the new architecture.
Frank Elsinga and Bart Louwers gave a talk on the latest MapLibre developments, specifically introducing the community to MapLibre Tile (MLT).

If you want to view the MapLibre talks at the conference, checkout the recordings below (they are in German):

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Navigation: Apr 8, 2026 – 5:00–6:00 PM UTC
MapLibre Native: Apr 8, 2026 – 6:00–7:00 PM UTC
MapLibre GL JS: Apr 8, 2026 – 7:00–8:00 PM UTC

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

Apr 29, 2026 – 10:00–11:00 AM UTC

We're Sun-setting the Bounty Program

Mon, 23 Mar 2026 00:00:00 GMT

TL;DR: MapLibre is sun-setting the bounty program as originally conceived because it isn’t a sustainable way to incentivize contributions at our current scale. The Board and maintainers are working hard to identify what comes next. We will honor any existing bounty commitments.

Since our founding, MapLibre has asked sponsors to contribute to a development fund intended to incentivize new feature development; primarily through bounties. After running this program for several years, we’ve concluded it no longer serves our community well.

Effective March 31, 2026, we will no longer be offering bounties for development work. We will instead pursue roadmap and feature development goals through pathways more typical for open source software.

We are working toward a contributor recognition system that rewards regular, high-value contributions that sustain and strengthen our community. If you have questions or ideas, please reach out.

Reason for the change

We are making this change because the system as it was designed fails on a structural level:

Overhead: The bureaucratic overhead is high for both MapLibre and our community.
Visibility: Many very helpful contributions happen outside this system and remain invisible to it, such as community work and ecosystem maintenance.
AI: We need to respond to the rising use of coding agents and AI assisted development; the Bounty System does not adequately incentivize the patterns we need from contributors.
Compensation: The payouts are not competitive enough to be a meaningful or reliable income source in most markets.
Adoption: We have not seen significant usage of this system for contributions.

The Governing Board’s mission is to sustain and grow this project by recognizing those who invest their time and money in it. A bounty-based model may have seemed like a good idea at first, but at our current scale it creates more problems than it solves.

Looking ahead

We would like to replace the bounty system with a contributor recognition system that rewards impact and community contribution. The Board and maintainers are actively working to define what this looks like, and we will share more details as they are finalized.

MapLibre exists because of its contributors across code, ecosystem integrations, and community work. That hasn’t changed. Our goal is a well-funded project that can pay the people who sustain it. That starts with sponsorship; if your company builds on MapLibre, please become a sponsor.

MapLibre remains a community-driven project. If you have feedback or ideas, we want to hear from you. This is an ongoing conversation, and we’re building the future together.

Frequently asked questions

Q: What is the history of the bounty program?

MapLibre introduced our bounty program in 2022 to give back to contributors, encourage new participation, and create a lightweight reward system. Developers could sign up, comment on bounty-labeled issues, complete the work, and submit an invoice through OpenCollective. The process was bureaucratic by design, and at the time, we had no budget or runway. We are more established today, and want to align with the common practices of other open source organizations to ensure the sustainability and stability of the project.

Q: Is this part of a broader organizational change?

No. MapLibre remains a lean organization with a Governing Board made entirely of volunteers and four part-time staff members.

Our financial reports are public. We are currently operating at a loss. See our sponsor page if you want to help.

Q: What if I have an in-flight bounty?

Contact your maintainer. We will honor existing commitments.

Q: I maintain a MapLibre integration for another platform or framework. When can MapLibre financially support me?

Ecosystem maintainers — the volunteers who keep integrations like Flutter, React Native, Qt, and others working — extend MapLibre’s reach into developer communities our core team cannot serve directly. That work matters enormously to us, and to the users and companies downstream who depend on it.

We can’t pay you directly yet, but it’s a goal we’re working toward. In the meantime, we support ecosystem maintainers in concrete ways: we’re exploring grant-based and commercial funding for larger efforts, we can help with hardware or testing resources if you’re blocked by a missing device or platform, and we can cover reasonable conference travel costs for presenting your work. Reach out to a board member to start the conversation.

MapLibre Newsletter February 2026

Tue, 03 Mar 2026 00:00:00 GMT

Welcome to the February 2026 edition of MapLibre Newsletter! It’s been an active month with exciting updates, from shifting rendering backends to launching a collection of agent skills to perform MapLibre related tasks.

A special thanks to MapTiler for their continued support. We updated our Sponsors page this month, to make clearer how organizations and individuals can give. If you have been thinking about contributing, there has never been a better time.

Our gratitude goes to MapTiler for their continued support to MapLibre.

With that note, let’s dive into the latest updates across the MapLibre ecosystem!

📱 MapLibre Native

Core library: Distance-Based Level-of-Detail (LOD)

Nathan Olson implemented a distance-based level-of-detail algorithm into the core library. However, platform APIs for this functionality still need to be added.

Experimental WebGPU Backends for Mobile

Birk Skyum implemented a WebGPU backend for Android and for iOS. At this point the motivation behind this is more or less “because we can”, but it might offer opportunities to share custom shaders between platforms in the future.

New Hillshading Algorithms Merged

Andrew Calcutt’s PR that implements additional hillshade algorithms has been merged! These algorithms are included in the current pre-release for Node.js, and the next releases for MapLibre iOS and MapLibre Android.

Android: Transitioning to Vulkan by Default

We released MapLibre Android 13.0.0 which now uses Vulkan as a default rendering backend. This means that the org.maplibre.gl:android-sdk package is now using Vulkan. You can use the org.maplibre.gl:android-sdk-opengl package if you prefer to stick to OpenGL ES for now.

🌐 MapLibre GL JS

New Releases: Versions 5.18 and 5.19

We’ve released versions 5.18 and 5.19 this month. A major highlight is the migration of our documentation to Zensical, the next-generation replacement of Material for MkDocs, which has served us very well until now. We also added anisotropicFilterPitch to support some interesting data analysis use cases.

We would like to thank all the contributors this month for these versions - truly inspiring work!

🙏 n4n5, Lars Maxfield, pcardinal, Simon, Birk Skyum, Harel Mazor, Ganesh Lokhande, Ryan, Frank Elsinga, Kai Gritun, Stanislaw Puda, Lucas Wojciechowski, Russell Porter

The Road to Version 6

The following PR, which will pave the way for our next major release is now ready to be merged:

👉 https://github.com/maplibre/maplibre-gl-js/pull/6992

We expect to release a first pre-release for version 6 in March. While we haven’t made a major (breaking) release in over a year now to keep things as maintainable as possible, it is now time to move forward with changes we’ve previously deferred.

The primary change in version 6 regarding developer experience will be the transition to ESM. As the industry moves toward ESM and our current build process is becoming increasingly complex, we are considering not releasing a CommonJS version. This transition will allow us to leverage newer technologies like Rolldown.

We would love to hear your thoughts on these expected breaking changes to ensure we don’t disrupt your workflow. Please join the discussion in the relevant tracking issue and share your feedback.

🪶 MapLibre Flutter

Versions 0.3.4 and 0.3.4+1 of maplibre have been released this month, bringing significant architectural improvements and expanded platform support.

iOS transition to FFI

A major milestone in this release is the complete transition of the iOS implementation to use FFI, removing all remaining usages of method channel serialization. This simplifies the integration between Flutter and the native SDK while providing minor performance gains.

Federated plugin architecture

As part of an ongoing committment to code quality, the plugin has been reorganized into a fully federated plugin architecture, separating each platform implementation into a dedicated packages. This restructuring improves long-term maintainability and allows each platform to evolve independently. These changes happened under the hood and require no migration from users.

Experimental desktop support

Experimental support for Windows and macOS has been introduced via a WebView–based implementation that uses MapLibre GL JS. This is a simple solution to bring performant vector map rendering to these desktop platforms while broader native support continues to mature.

MapLibre GL JS map rendering within a Flutter App on Windows.

Documentation and Future Roadmap

The documentation website has been migrated to Zensical alongside the broader MapLibre migration. Check it out and let us know what you think.

Looking ahead, work is progressing on typed style layer properties and expressions, a highly anticipated feature. We are currently targeting static typing for style expressions, paint/layout properties, and new style layer inspection capabilities for the upcoming v0.4.0 release.

🤖 Maplibre Agent Skills

In an effort to move with the times and inform the LLMs of all the great things you can build with MapLibre, we’ve launched maplibre-agent-skills, a library of structured knowledge files that help AI coding assistants (Claude Code, Cursor, GitHub Copilot) write better MapLibre applications.

Rather than putting up with bad or wrong MapLibre integrations, we’re directly informing the AI agents so they in turn share good information and the right recommendations on when it makes sense to use MapLibre, how to deal with tile sources and other renderer resources, and how to follow open-ecosystem patterns.

Skills available now:

maplibre-tile-sources — choosing hosted vs. self-hosted tiles, OpenFreeMap, PMTiles, glyphs, CORS
maplibre-pmtiles-patterns — serverless tile hosting on S3, R2, and static hosts
maplibre-mapbox-migration — migrating from Mapbox GL JS to MapLibre GL JS

Visit maplibre-agent-skills for more details on how to use or install these, or review the open issues for what’s next.

We’re looking for contributors. Skills are plain markdown files, easy to read, review. We welcome your expansions, corrections and questions. If you’ve tackled geocoding, routing, styling, framework integration (React, Vue, Angular, Flutter, Swift), or performance — your experience can make a big impact.

See contributing guidelines for how to write a skill, or open an issue to propose a new one we haven’t thought of yet.

🎨 Style Spec

The MapLibre Style Spec continues to evolve to support more complex styling needs:

split and join, which allow better string manipulation, are now part of the spec and are expected to be incorporated in MapLibre GL JS soon.
resampling was also added to support other layers besides raster.
symbol-elevation will probably land soon to allow better support for placing symbols in a 3D map, check it out here: https://github.com/maplibre/maplibre-style-spec/pull/1508

🦀 maplibre-rs

In February our focus has been on text rendering, with the following enhancements merged in:

SDF renderer plugin, adding support for text labels as shown on the picture below. Thanks to @maxammann for the PR.
Support for configurable text-field property for symbol layers, so it’s possible to e.g. set the language of the labels. Thanks to @birkskyum for the PR.
Render tests harness added to the project. Thanks to @birkskyum for the PR.

Demonstration of the new SDF-based text rendering in maplibre-rs.

🧩 MapLibre Tile (MLT)

There is a growing interest in the new format. Our current priorities are:

Mature decoders. In particular, we are rebuilding the test infrastructure to ensure high quality decoders in all the major languages.
Encoders in Rust and C++. Having mature encoders will allow integration into all kinds of tools such as databases and tiles servers.
Leverage the native strengths of the MLT directly. For example, in MapLibre GL JS we aim to move away from the current method of converting data into an MVT-style model.

📣 Call for Volunteers: MLT Logo

The MLT project is looking for a volunteer to design our official logo. This is a great opportunity to contribute to the project and leave a lasting mark on the MapLibre ecosystem. Please join the discussion to provide your inputs or share your submissions!

We’ve made great progress on the tooling side, including a Rust-based TUI and a dedicated QGIS plugin 🎉 Stay tuned for more updates!

MLT TUI: Direct feature inspection within the terminal.

MLT Data integration progress within the QGIS ecosystem.

⚙️ Martin

While it has been a relatively quiet month as we focus on MLT development, we’ve still shipped several key improvements to the tile server:

Web UI Fixes: The path-prefix now works correctly within the Web UI.

Smarter Routing: Common URL mistakes (e.g., using /source.mvt instead of /source) now return a 301 redirect instead of a 404, including periodic log hints to help fix configurations.

COG Stability: The experimental Cloud Optimized GeoTIFF (COG) backend was tightened significantly (thanks to David E Disch, PR #2510). To ensure stability, COGs must now be fully WebMercator-compatible (EPSG:3857), tiled, and consistently sized. Some previously ambiguous COGs may no longer load as we move toward a more predictable, production-ready implementation.

Manbhav Sugla also migrated our documentation to Zensical, which looks much more modern than what we had before.

✨ Community spotlight

Yossef from our community has build QGIS2VectorTiles which streamlines the process of packing a QGIS project into a styled vector tile package ready for MapLibre. It allows users to design maps within the familiar and flexible QGIS Desktop and export stunning MapLibre client-side web maps leveraging GDAL’s MVT driver.

The exported output package includes:

Vector tile source: XYZ directory
Styled QGIS layer file: A .qlr file
MapLibre style: A ready-tp-use .json stylesheet
MapLibre sprites (optional) :.png and .json files
A ready-to-use MapLibre viewer: A pre-configured .html file

This package is ideal for:

Client-side web map rendering via MapLibre, OpenLayers, and Leaflet
Lightweight WMS/WMTS vector tile serving via GeoServer and QGIS Server
Sharing complex, multi-source styled QGIS projects packaged as a single data source and layer file

A short demo is attached:

Exporting styled vector tiles directly from QGIS.

More information is available on the plugin homepage.

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Navigation: Mar 11, 2026 – 5:00–6:00 PM UTC
MapLibre Native: Mar 11, 2026 – 6:00–7:00 PM UTC
MapLibre GL JS: Mar 11, 2026 – 7:00–8:00 PM UTC

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

Mar 25, 2026 – 9:00–10:00 AM UTC

🔗 View meeting times in your local timezone.

All calls are open to everyone. Zoom links are shared in the MapLibre Slack. Not yet a member? Request an invite via the OpenStreetMap US Slack. We’d love to see you there!

CalTopo joins the MapLibre Sponsorship program

Mon, 16 Feb 2026 00:00:00 GMT

We’re pleased to announce that CalTopo is now a Silver sponsor of the MapLibre project.

CalTopo has built one of the most trusted field mapping platforms in the US, relied on by search and rescue teams, wildland firefighters, and backcountry adventurers who need maps to work when it counts. We’re proud to welcome them as a MapLibre sponsor — and to support the open-source rendering infrastructure that powers their maps.

CalTopo is an app for collaborative map building and offline adventuring, and they rely heavily on MapLibre powering their 3D maps, making it possible for users to explore terrain in a more intuitive, visual way.

Below, the CalTopo team shares more about why they chose to support MapLibre and how it fits into their product roadmap.

What motivated CalTopo to support MapLibre?

MapLibre is a core part of how CalTopo works and we rely on it every day to deliver the mapping experience our users expect. Supporting MapLibre is about investing in an organization that we depend on and believe in. When the libraries continue to grow and improve, it helps us build better tools for our community and ensures the long-term stability of the mapping technology behind our apps.

How does MapLibre fit into your product and technical roadmap?

MapLibre plays a central role in how people experience CalTopo. In our mobile app, it’s the map engine that displays all of our layers, routes, and user data. On the web, MapLibre powers our 3D maps, making it possible for users to explore terrain in a more intuitive, visual way. As we continue to invest in performance and expand our 3D capabilities, MapLibre remains an important part of how we bring those ideas to life.

What do open-source mapping tools mean for your community?

Open-source mapping tools make it possible for us to stay focused on what matters most to our users. By building on reliable, community-driven libraries, we’re able to move faster, keep costs down, and put more effort into solving real planning and navigation challenges. That ultimately means a better product for our users and access to powerful tools without unnecessary barriers.

We’re thankful for the work and care that goes into the libraries and MapLibre organization. The time and effort contributed by the community have a direct impact on the tools our users rely on every day. We’re proud to support this work and excited to be part of an open mapping ecosystem that continues to grow and improve through collaboration.

We’re grateful to CalTopo for their support and for sharing their perspective. Sponsorships like this help strengthen the long-term sustainability of the MapLibre project. If you are interested in sponsoring MapLibre, we invite you to learn more about our sponsorship program.

MapLibre Newsletter January 2026

Tue, 03 Feb 2026 00:00:00 GMT

Welcome to the January 2026 edition of MapLibre Newsletter! This edition covers project updates across the MapLibre ecosystem, a round-up of events from the past month, and highlights from our growing global community.

MapLibre continues to move forward thanks to the support of its community. Since launching GitHub Sponsors, 87 sponsors have supported MapLibre over time, with 35 sponsors currently backing the project, alongside 40+ community backers on Open Collective contributing varied amounts.

Thank you to everyone who supports MapLibre with their time, feedback, code, and financial contributions 💙.

Our sincere thanks to the individuals and organizations who support MapLibre through GitHub Sponsors and Open Collective. Your contributions, big or small, help keep the project open, independent, and community-driven.

📱 MapLibre Native

We’ve published the test app for iOS on TestFlight!

If you have a spare iPhone lying around, please enroll and run the ‘long running test’ made by Adrian Cojocaru. Any crashes are automatically reported to our Sentry project and will be available for MapLibre developers to investigate¹. Testflight link: https://testflight.apple.com/join/h81pYA1M

Nathan Olson added camera roll support to MapLibre Native (#3011). This feature is now available on both MapLibre iOS and MapLibre Android.
Nathan also is working on a distance-based level-of-detail(LOD) implementation in #4057. This is the same algorithm that is used for MapLibre GL JS. If you (also) have an aviation related use case for MapLibre Native we would love to hear from you.
Releases this month:
- MapLibre iOS 6.23.0, 6.22.2

🌐 MapLibre GL JS

Versions 5.16 and 5.17 were released this month. We also integrated the geojson-vt version that was recently onboarded into the MapLibre organization, which should facilitate faster GeoJSON updates in the near future.

We are looking to improve GeoJSON serialization, including addressing limitations related to nested properties. We’d love to get community feedback on the following PR: https://github.com/maplibre/maplibre-gl-js/pull/6992

Once this PR is merged and GeoJSON serialization is improved, it will pave the way for releasing version 6 as this will be breaking. Version 6 will also include additional breaking changes that we’ve gathered over the past year, which are described in the following issue:

https://github.com/maplibre/maplibre-gl-js/issues/6427

Any feedback is very welcome.

We would like to thank this month’s contributors, every contribution helps make the library better for everyone who uses it. THANK YOU! 🙌

Lucas Wojciechowski, Les, melitele, Minh Nguyễn, Stanislaw Puda, Lars Maxfield, ToHold, Licheng Mao, Ryan, Stephanie May, yujian, Harel Mazor, Taku Fukada, David E Disch

🧩 MapLibre Tile

This month we officially announced MapLibre Tile!

Tim Sylvester is working on adding PMTiles support to the Java Encoder CLI (#798). The Java CLI tools can be downloaded from the releases page.

We have added coverage checking to the Java encoder/decoder. At the Codecov page you can see that Rust and Java have some catching up to do to reach the coverage number of the TypeScript decoder.

We have a monthly community call to discuss MLT developments, if you would like an invite, send a message to team@maplibre.org

Screen grab from the MapLibre demo site showcasing vector tiles.

⚙️ Martin

We’ve released Martin 1.3.0, bringing improvements to logging, font handling, routing, and tile formats - plus several performance and UX fixes.

Highlights include:

More flexible logging: Martin now uses tracing instead of log, enabling better instrumentation and configurable log output via RUST_LOG_FORMAT. Supported formats include compact (default), json, full, bare, and pretty.
Improved glyph support beyond U+FFFF: Fonts with characters outside the Basic Multilingual Plane (e.g. emoji, historic scripts, or private-use glyphs) are now handled correctly. We also removed FontSources.masks, reducing memory usage and startup time.

Since not everyone is likely aware of what U+FFFF means:
- U+0000 - U+FFFF is Basic Multilingual Plane, which covers characters for almost all modern languages
- U+10000 - U+3347F covers minor characters such as historic scripts and emojis
- U+E0000 - U+E01EF is for tags and variation selectors
- U+F0000 - U+10FFFF is for private use (i.e. can be assigned arbitrary custom characters without worrying about possible conflict with the future standards)

Native subpath support: A new route_prefix config option and --route-prefix CLI flag allow Martin to serve from a subpath without requiring reverse-proxy URL rewriting.
MLT decoding support: Martin now supports the MapLibre Tiles Specification (MLT), allowing MLT-based tiles to be served directly.
Human-readable time estimates in martin-cp progress output
PostgreSQL materialized view support and improved table metadata

Check out the full changelog on GitHub, and as always, thanks to Hiroaki Yutani, David E Disch, Amanda, Kunal, thomfuhrmann, Birk Skyum, Frank Elsinga and Yuri Astrakhan who contributed to this release 💙

👥 Conferences & Events

Last month, members of the MapLibre team were on the ground connecting with the community, sharing updates, and learning alongside fellow open-source contributors at the following events:

FOSS4G Asia in Nashik, India where Frank Elsinga held a workshop on Tile Serving with MapLibre.
State of the Map India in Nashik, India
FOSDEM in Brussels, Belgium where Frank Elsinga and Bart Louwers presented State of the MapLibre Tile Format.

MapLibre team members at recent community conferences, including FOSS4G Asia (Nashik, India), State of the Map India, and FOSDEM (Brussels).

It was great to meet community members in person, exchange ideas, and represent MapLibre across regions.

We’re looking forward to attending more events in the coming months. If you’d like to follow along or suggest events we should be part of, please let us know in this GitHub discussion.

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Navigation: Feb 11, 2026 – 5:00–6:00 PM UTC
MapLibre Native: Feb 11, 2026 – 6:00–7:00 PM UTC
MapLibre GL JS: Feb 11, 2026 – 7:00–8:00 PM UTC

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

Feb 25, 2026 – 9:00–10:00 AM UTC

🔗 View meeting times in your local timezone.

All calls are open to everyone. Zoom links are shared in the MapLibre Slack. Not yet a member? Request an invite via the OpenStreetMap US Slack. We’d love to see you there!

Note: crash reports may include some privacy-sensitive data such as IP addresses (see privacy policy). ↩

Announcing MapLibre Tile: a modern and efficient vector tile format

Fri, 23 Jan 2026 00:00:00 GMT

Today we are happy to announce MapLibre Tile (MLT), a new modern and efficient vector tile format.

What is MapLibre Tile?

MapLibre Tile (MLT) is a successor to Mapbox Vector Tile (MVT). It has been redesigned from the ground up to address the challenges of rapidly growing geospatial data volumes and complex next-generation geospatial source formats, as well as to leverage the capabilities of modern hardware and APIs.

MLT is specifically designed for modern and next-generation graphics APIs to enable high-performance processing and rendering of large (planet-scale) 2D and 2.5 basemaps. This current implementation offers feature parity with MVT¹ while delivering on the following:

Improved compression ratio: up to 6x on large tiles, based on a column-oriented layout with recursively applied (custom) lightweight encodings. This leads to reduced latency, storage, and egress costs and, in particular, improved cache utilization.
Better decoding performance: fast, lightweight encodings that can be used in combination with SIMD/vectorization instructions.

In addition, MLT was designed to support the following use cases in the future:

Improved support for 3D coordinates, i.e. elevation.
Improved processing performance, based on storage and in-memory formats that are specifically designed for modern graphics APIs, allowing for efficient processing on both CPU and GPU. The formats are designed to be loaded into GPU buffers with little or no additional processing.
Support for linear referencing and m-values to efficiently support the upcoming next-generation source formats such as Overture Maps (GeoParquet).
Support complex types, including nested properties, lists and maps.

As with any MapLibre project, the future of MLT is decided by the needs of the community. There are a lot of exciting ideas for other future extensions and we welcome contributions to the project.

For a more in-depth exploration of MLT have a look at the following slides, watch this talk or read this publication by MLT inventor Markus Tremmel.

When can I use it?

For the adventurous, the answer is: today. Both MapLibre GL JS and MapLibre Native now support MLT sources. You can use the new encoding property on sources in your style JSON with a value of mlt for MLT vector tile sources.

To try out MLT, you have the following options:

The easiest way to try out MLT is to use the MLT-based demotiles style.
You can also try out the encoding server that converts existing (MVT-based) styles and vector tile sources to MLT on the fly. This is mostly a tool for development.
To create tiles for production, you could use Planetiler, as the upcoming version will support generating MLTs.

Refer to this page for a complete and up-to-date list of integrations and implementations. If you are an integrator working on supporting MLT, feel free to add your own project there.

We would love to hear your experience with using MLT! Join the #maplibre-tile-format channel on our Slack or create an Issue or Discussion on the tile spec repo.

Acknowledgements

MapLibre Tile came to be thanks to a multi-year collaboration between academia, open source and enterprise. Thank you to everyone who was involved! We are very proud that our community can innovate like this.

Special thanks go to Markus Tremmel for inventing the format, Yuri Astrakhan for spearheading the project, Tim Sylvester for the C++ implementation, Harel Mazor, Benedikt Vogl and Niklas Greindl for working on the JavaScript implementation.

Also thanks to Microsoft and AWS for financing work on MLT.

One exception: unlike MVT, MLT does not support layers where a value in a column changes type from feature to feature. ↩

MapLibre Newsletter December 2025

Sat, 03 Jan 2026 00:00:00 GMT

As we close out 2025, the MapLibre ecosystem continues to move forward across platforms, tooling, and the broader open-source mapping community. While December is traditionally a quieter month, there’s still plenty to share about performance improvements and new capabilities in MapLibre Native, GL JS, and other community-led initiatives.

None of this work would be possible without the continued support of our sponsors, whose contributions help keep MapLibre sustainable and moving forward. Thank you for supporting and here’s wishing our community a Mappy New Year 🗺️🎉.

📱 MapLibre Native

Faster, Synchronous GeoJSON updates: The latest releases for MapLibre iOS and Android allow adding GeoJSON sources which use synchronous updates. This is especially useful for time-sensitive GeoJSON layers such as the location puck (the internal location indicator layer on Android has been updated to use a synchronous GeoJSON layer). Please try it out and share your experiences. Thanks Alex Cristici for implementing this functionality.

Terrain 3D support: Jesse Crocker and Nathan Olson are cooking up a Terrain 3D implementation for MapLibre Native. Check out the work in progress here and here.

Enhanced Hillshade & Color-Relief Layers: Andrew Calcutt is working on a PR to update Hillshade Algorithms and add Color-Relief Layer support. Please have a look, try it out if you can and give his PR a +1!

Android Transform Updates: We are still gathering feedback on an Android pre-release that enables icon scaling with offsets and makes changes to the transform implementation to allow for concurrent animations. If you’re affected by these changes, please try it and help ensure there are no regressions in your app.

Releases this month:

MapLibre Node.js 6.3.0
MapLibre Android 12.3.0, 12.3.1
MapLibre iOS 6.22.0, 6.22.1

MapLibre Native with Mapterhorn terrain tiles (attribution) with basic as hillshade-method.

🌐 MapLibre GL JS

Version 5.14.0 and 5.15.0 are now available! These releases include several bug fixes related to terrain, canvas source, abort errors, GeoJSON handling and general packaging improvements. Another notable addition is support for global-state in expression visibility.

Many thanks to all the contributors in these releases: Lucas Wojciechowski, David E Disch, Ryan, Mary, Andrew Dassonville, Omkarthipparthi, Lars Maxfield

GeoJSON Improvements

Additionally, geojson-vt has been onboarded to the MapLibre GitHub organisation to support incremental tile updates for GeoJSON. We are also researching solutions to some long-standing issues in GeoJSON usage, such as handling nested and undefined properties.

MLT TypeScript

There’s an open PR to support decoding of FastPFor, which is the final missing piece for version 1.0 of the tile specification. In parallel, ongoing work is focused on performance optimizations, along with a strong emphasis on unit tests to ensure the codebase is well covered.

NPM & Tooling

We’ve moved all our packages to trusted publishing and aligned the CI workflows to make the changelog and release process consistent across most packages.

🧩 Martin

Development slowed down a bit over the past month due to the holiday season, but we still managed to ship a handful of useful improvements in the 1.1.0 and 1.2.0 releases.

Highlights include better support for automation, more flexible error handling, and a few targeted fixes and performance tweaks:

The mbtiles summary command now supports --format [json | json-pretty | text], making it easier to integrate with scripts and other automated tooling (by Yuri Astrakhan).
A new on_invalid: warn option allows invalid sources to emit warnings instead of aborting execution, giving users more control over failure behavior (by Gabe Schine).
Fixed an issue where PostgreSQL sources with auto_publish: false would incorrectly warn about all tables and functions; warnings are now limited to explicitly configured sources (by Brian Todt).
martin-cp now infers default bounds from configured sources, improving performance when copying from sparse source sets (by Brian Todt).
Discovery now supports az:// URL schemes, enabling Azure Blob Storage–based workflows (by Frank Elsinga).

Even with a quieter month, these changes help smooth out common workflows and make Martin easier to integrate into larger systems.

Screenshot from Martin demo site.

✨ MapLibre SwiftUI DSL

It’s been a few months since our last update, but the SwiftUI DSL continues to add new features and receive updates to keep pace with the latest MapLibre Native releases as well as updates from Apple.

Some highlights include:

Support for the latest SwiftSyntax versions and iOS 26
A half dozen or so new style property bindings
Moving more properties to be controlled via the environment, which should help clean up a lot of code going forward!

Looking back on the year, we’ve picked up quite a few new contributors! While we don’t yet know how this correlates to usage, it’s reasonable to call it a success. Looking forward to 2026, our process for exposing API bindings appears to be working well, so it’s time to consider an automated approach to fill in the rest of the missing bindings. Expect an update in future newsletters, or join us in the #maplibre-swiftui channel on Slack.

🪶 MapLibre Flutter

Since the last update in the September newsletter, we’ve continued to focus on good stability and cross-platform experience for developers. Version 0.3.1 and 0.3.2 have been released, bringing several notable improvements:

Moving to 100% ffi interop on Android. We are looking forward to achieving the same on iOS soon.
Support for creating map markers from Material, Cupertino or any other Flutter IconData. These icons can be displayed on the map without any delay between Flutter and the MapLibre map. For the future, support for rendering complete widgets as map markers is planned.

Another exciting release, version 0.3.3, is coming soon. A big thanks to everyone involved in the progress and development throughout 2025!

🌍 Ecosystem Spotlight

Diplomat Plugin

The OpenStreetMap Americana team has released Diplomat, a new MapLibre GL JS plugin for converting labels into different languages. Diplomat supports dual language labels and all major tile schemas.

Before: single-language labeling

After: dual-language labels with Diplomat

Map data ©OpenStreetMap contributors. Tiles by OpenMapTiles.

OpenStreetMap Website Migration

There has also been steady progress on migrating the OpenStreetMap website to MapLibre. So far, the dashboard landing page has been migrated, while many other pages are still pending.

If you’re interested in contributing to this effort, here’s the issue outlining the overall plan and remaining work.

👥 Conferences

We plan to participate and contribute to sessions/workshops in the following events this month.

FOSS4G Asia 2026, held in Nashik, Maharashtra, India, from 21–25 January 2026
State of the Map India 2026 (SOTM India), taking place on 25-January 2026
FOSDEM 2026 in Brussels on 31-January & 3-February 2026 where Bart Lowers & Frank Elsinga will be presenting a talk on State of the MapLibre Tile Format.

FOSS4G Asia Talks to watch out for:

All times are in Indian Standard Time (IST, UTC +5:30).

Talk/Workshop	Date	Time	Duration	Location	Presenter
Tile serving with MapLibre / Martin / Planetiler: base and overlays	Jan 21	14:30–16:30	2h	Room 1	Frank Elsinga
High-performance & large-scale geospatial visualisation using MapLibre and Deck.GL (with React)	Jan 22	09:00–11:00	2h	Room 1	Srijit S. Madhavan
State of the MapLibre Tile Format	Jan 23	15:00–15:30	30 min	Room 2	Frank Elsinga
Next Generation Tile Server Performance Now	Jan 24	11:00–11:40	40 min	Room 1	Frank Elsinga
Faster Maps, Smaller MapLibre Vector Tiles, and What’s Next	Jan 24	11:45–12:15	30 min	Room 1	Frank Elsinga

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Navigation: Jan 14, 2026 – 5:00–6:00 PM UTC
MapLibre Native: Jan 14, 2026 – 6:00–7:00 PM UTC
MapLibre GL JS: Jan 14, 2026 – 7:00–8:00 PM UTC

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

Jan 28, 2026 – 9:00–10:00 AM UTC

🔗 View meeting times in your local timezone.

All calls are open to everyone. Zoom links are shared in the MapLibre Slack. Not yet a member? Request an invite via the OpenStreetMap US Slack. We’d love to see you there!

MapLibre Newsletter November 2025

Tue, 02 Dec 2025 00:00:00 GMT

We open this edition by acknowledging AWS for their continued support of MapLibre during 2023–2025. Their contribution plays an important role in sustaining the growth of our open-source ecosystem.

Our gratitude goes to AWS for their continued multi-year commitment to MapLibre (2023-2025).

The highlight of this month is the landmark release of Martin v1.0, a major milestone for the project. We also bring updates across MapLibre Native and GL JS, a new video export plugin from the community, and information on upcoming community calls.

🧩 Martin

🎉 After 8 years in development, Martin v1.0 is here! 🎉

We are thrilled to announce the official release of Martin v1.0. Since joining MapLibre in 2022, Martin has evolved from a simple tile server supporting a single PostgreSQL connection into the fastest, feature-rich, open-source tile server available today.

This incredible progress is thanks to over 80 contributors who have expanded Martin’s capabilities to include:

Multiple Data Sources: Support for multiple PostgreSQL, PMTiles, and MBTiles backends.
MapLibre Ecosystem: Full support for fonts, sprites, and styles.
Powerful Features: A rich web UI, plus tools for tile generation and MBTiles manipulation.
Developer Flexibility: The ability to use Martin as a library for building custom tile-serving solutions.

A special thanks to Stepan Kuzmin, the original author, and to key contributors Yuri Astrakhan, Frank Elsinga, and Lucas, along with everyone else who made this project a success!

📱 MapLibre Native

Please help us test the new MapLibre Android pre-release, v12.3.0-pre0 (available on Maven Central). Two features need testing:
- icon placement with pitched maps (especially if you use icon-offset) and
- camera animations.
Since we don’t have a large QA team, we rely on the community to help ensure enhancements don’t inadvertently break existing apps. Please report back, even if everything worked as expected.
We made a new release of the MapLibre Android test app. If you have an Android device lying around, you can help us improve the stability of MapLibre Android by installing this app and starting the “long running test” activity. Any crashes will be automatically reported to MapLibre developers.
The test app helped us find and fix a long-standing bug of the Vulkan backend that we were not able to reproduce before. This was one of the last blockers for one of our users that wanted to usethe Vulkan build of MapLibre Android.
Releases
- MapLibre Android 12.2.0, 12.1.3, 12.1.2, 12.1.1, 12.1.0
- MapLibre iOS 6.21.1, 6.21.0, 6.20.1, 6.20.0, 6.18.0-patch0
We also recommend reading this detailed community post by Ahmed, on MapLibre performance on Android Auto.

🌐 MapLibre GL JS

We have released two major versions this month: v5.12 and v5.13. The main feature that was added as part of these versions is support for MLT (MapLibre Tiles)!

Experimental Tile Slicing

We’ve introduced an experimental feature for slicing vector tiles on the fly, this solves some precision issues with labels and improves performance for high zoom levels.
We will probably make this feature non experimental and define a different default in the next breaking change version (version 6, for which the timeline is yet to be defined), so it would be great if you could give it a try, check out the experimentalZoomLevelsToOverscale flag.

GeoJSON Optimizations & Font Updates

There were a lot of performance improvements to the GeoJSON source along side addressing a context restore blank map issue.
In these versions there was also a leap forward in term of font support by adding uncommon Chinese, Japanese, Korean, and Vietnamese characters along side allowing glyph to be removed and use the browser native text rendering capabilities, which can improve support for rendering text in all kind of languages.
Styles are no longer strictly tied to server-side glyph PBFs: they can render text using local or Web fonts whenever PBFs are unavailable. This enhances CJK text rendering, supporting bold/italic variants and resolving Japanese character misalignment.

Before	After

Example from the font improvements testing: see more cases in the GitHub comment thread

🤝 Thanks to all the contributors this month! Lucas Wojciechowski, Ryan, Lars Maxfield, Tohold, Niklas Greindl, Benedikt Vogl, Minh Nguyễn.

🎥 MapLibre GL Video Export Plugin

Brice Person has made the first release of an open-source plugin for MapLibre GL JS that enables video export with animated camera movements.

What it does:

Exports videos (WebM/MP4) directly from MapLibre GL maps
28 preset animations (orbit, drone shots, terrain-aware paths, etc.)
Waypoints system for defining points of interest
WebM VP9 recommended (royalty-free, hardware-accelerated)

Technical approach: Uses MapLibre GL JS v5.11.0+ time control API (setNow()) for deterministic frame-by-frame rendering, ensuring smooth exports without screen recording artifacts.

Resource Links:

GitHub: https://github.com/bjperson/maplibre-gl-video-export
Live demo: https://bjperson.github.io/maplibre-gl-video-export/
npm: https://www.npmjs.com/package/maplibre-gl-video-export

Feedback and contributions welcome!

License: BSD-3-Clause

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Navigation: Dec 10, 2025 – 5:00–6:00 PM UTC
MapLibre Native: Dec 10, 2025 – 6:00–7:00 PM UTC
MapLibre GL JS: Dec 10, 2025 – 7:00–8:00 PM UTC

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

Dec 31, 2025 – 9:00–10:00 AM UTC

🔗 View meeting times in your local timezone.

All calls are open to everyone. Zoom links are shared in the MapLibre Slack. Not yet a member? Request an invite via the OpenStreetMap US Slack. We’d love to see you there!

MapLibre Newsletter October 2025

Tue, 04 Nov 2025 00:00:00 GMT

We begin this edition with sincere appreciation for Radar, whose ongoing sponsorship helps sustain the MapLibre community. Welcome to the MapLibre Newsletter, October 2025 edition!

Thank you Radar for your sustained support to MapLibre (2023–2025) 🙌

Before diving into the updates, we’ve added a new .github repository, giving the MapLibre GitHub organization a fresh, welcoming README! Check it out here: https://github.com/maplibre

📱 MapLibre Native

Releases
- MapLibre Android: 12.0.0, 12.0.1
- MapLibre iOS: 6.19.2, 6.19.3
Birk Skyum contributed WebGPU support in #3899. This means now either wgpu (new) or Dawn can be used as a backend.
MapLibre Native Qt: The SDK has been updated to the latest version of MapLibre Native, which had moved more than 1000 commits ahead. As a result, there is now support for Vulkan, Metal, OpenGL 3.0, PMTiles and other upstream improvements. This is already on the main branch which can be used for self-building, and it will be part of the upcoming 4.0 release.
We kicked off the MapLibre Native hackathon. Joining late is possible. Please use the form if you want to join. Projects will be demoed at the MapLibre Native TSC Meeting on 12 November 2025.

🌐 MapLibre GL JS

We have released two major versions this month: v5.9.0 and 5.10.0. The major highlights of these versions are the support for both line-dasharray and line-gradient which looks very nice as can be seen here.

Dash with gradient

There was also the addition of time control APIs to allow creating videos, and the transformConstrain hook 🪝 to allow changing how the view is constrained, for example by allowing more padding to the map for applications that might not need a “classic” map. (Check out the GitHub issue for further details).

🙏 Thanks Brice Person, Christian Neumann, Lars Maxfield, Federico Tibaldo, Lucas Wojciechowski, Manuel Emeriau, Andrew Dassonville, Ryan Scully, Samarth Otiya, Corado Burcus for your contributions!

We are also working on integrating MLT (MapLibre Tiles) into maplibre-gl-js. We have a draft PR which you can start playing with, we are aiming for an initial support in November, and we will continue the journey of improving its performance and capabilities going forward. The TypeScript MLT decoder package pre-release can be found on npm.

Last but not least we are exploring ways to change how maplibre-gl-js over-scales vector tiles at high zoom levels. The following two interconnected PRs are a first draft on solving that, but we need more feedback from developers to know if this is the right approach and if this is something that can be useful. The main motivation around these PRs is to solve a Safari crash on mobile devices when there are a lot of lines and a lot of labels in high zoom levels (contours is the obvious example for this).

🧩 Martin

Martin v0.20.0 - the final step before 1.0 🎉

This month in Martin, we have published version v0.20.0

We’re getting close!

This release marks what we expect to be the final beta before Martin v1.0. The architecture is now locked down, and unless we uncover major bugs, this version will be re-published as v1.0 within the next week.

Huge thanks to everyone contributing code, reviews, testing, and feedback — you make Martin faster, more reliable, and more welcoming ❤️

The hallmark features in this release are:

⚡ Smarter, more flexible cache The cache is now split into multiple parts — sprites, fonts, PMTiles directories, and tiles — each with its own configurable limit.

Tip: Sprites and fonts are now cached too, speeding up vector map rendering.

Here is the effect on a small production deployment:

Performance metrics on a small production deployment
☁️ PMTiles: now for GCP, Azure, and more

Martin now supports the following pmtiles backends:
- Google Cloud and Azure object storage
- Expanded AWS and HTTP backends
- Local files as before
🧪 Experimental: server-side style rendering

You can now render MapLibre styles directly on the server to generate raster tiles. Still experimental, but great for early non-production testing.
Because of the level of maturity, we demoted the cog feature to unstable-cog. This means that it is not avaliable in the default bundle anymore, as the feature is still evolving.

If all goes smoothly, expect Martin v1.0.0 final very soon 🚀 Thanks again to everyone in the community for making this possible!

👥 Conferences

We plan to participate and contribute to sessions/workshops in the following events this month.

FOSS4G North America 2025, 3-4 Nov, 2025
SOTM EU 2025, 14-15 Nov, 2025 in Scotland. Watch out for Bart Louwers workshop!
FOSS4G Global, 17-23 Nov, 2025 in Auckland

FOSS4G Talks to watch out for:

All times are in Pacific/Auckland (NZDT).

Talk/Workshop	Date	Time	Duration	Location	Presenter
Tile serving with MapLibre / Martin / Planetiler — base and overlays (Beginner-friendly workshop)	Nov 17	13:30–16:30	3h	WF702	Yuri Astrakhan
Standalone Web Maps, No Platform Required (Beginner-friendly workshop)	Nov 18	09:00–12:00	3h	WF711	Stephanie May
Terra Draw — cross-platform drawing library for all map applications (Intermediate-level Workshop)	Nov 18	09:00	3h	WF702	Jin Igarashi
MapLibre — from data to tile rendering, in one status update	Nov 19	11:00	25 min	WG308 TE IRINGA	Yuri Astrakhan
Assessment of Display Performance & Comparative Evaluation of Web Map Libraries for Extensive 3D Geospatial Data	Nov 19	11:00	25 min	WG404	Toshikazu Seto
Implementing Interactive Indoor Maps with MapLibre and IMDF	Nov 19	15:30	25 min	WA220	Haruki Inoue
maplibre-gl-terradraw — new drawing plugin for maplibre-gl-js	Nov 19	16:00	25 min	WG404	Jin Igarashi
deck.gl State of the Union 2025: Globe View, React Widgets, and WebGPU Readiness	Nov 19	16:30	25 min	WG308 TE IRINGA	Felix Palmer
“Chef’s Kiss” Webmaps with Svelte, MapLibre & PMTiles	Nov 20	09:30	25 min	WG126	Rami DV
Fast, Free, and (Mostly) Painless: Getting Started with Open-Source Web Mapping	Nov 20	09:35	5 min	WG403	Luke Sussex
Saving lives with GIS: Engineering our open-source mapping stack	Nov 20	16:00	25 min	WG126	Stacy Rendall

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Navigation: Nov 12, 2025 – 4:00–5:00 PM UTC
MapLibre Native: Nov 12, 2025 – 5:00–6:00 PM UTC
MapLibre GL JS: Nov 12, 2025 – 6:00–7:00 PM UTC

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

Nov 26, 2025 – 9:00–10:00 AM UTC

🔗 View meeting times in your local timezone.

All calls are open to everyone. Zoom links are shared in the MapLibre Slack. Not yet a member? Request an invite via the OpenStreetMap US Slack. We’d love to see you there!

MapLibre Newsletter September 2025

Sat, 04 Oct 2025 00:00:00 GMT

Welcome to the MapLibre Newsletter, September 2025 edition!

This edition features advances in MapLibre Native, GL JS, Flutter, Martin, and more. Plus, we’ve given our roadmap section a fresh redesign. Go check it out to see what’s in progress, what’s under consideration, and what’s been released. A big thanks to Birk for driving this initiative forward. 🙌

With that note, let’s dive in!

📱 MapLibre Native

The C++ MapLibre Tiles decoder, written by Tim Sylvester, got merged this month. He also worked on the Java encoder, the integration into MapLibre Native and a new encoding style spec property for vector sources. After some last-minute optimizations this month, the MapLibre Tile Spec itself is now considered stable.

Long story short, all lights are on green you will be able to use the next-generation tile format with MapLibre Native soon (before the end of the year?). Stay tuned!
Birk Skyum has contributed a WebGPU backend for MapLibre Native. We already have dedicated backends for Vulkan, Metal and OpenGL, but the advantage of the new WebGPU backend is that it makes Native more portable.

Previously we demonstrated that MapLibre Native can run in the browser as WebAssembly by compiling the OpenGL backend to WebGL1/2 but that approach is heavy. The WebGPU backend will be significantly more performant.

Additionally, the WebGPU backend can simplify cross-platform development with frameworks like Compose Multiplatform and Flutter, by offering a single backend that can be used for all desktop/mobile/web targets.
We have enabled immutable releases. A GitHub feature that makes it impossible to tamper with release assets.
🧑‍💻 Join the MapLibre Native Hackathon!

Hack on the MapLibre Native codebase with guidance from expert contributors. Build plugins, fix bugs, add features,anything goes!

The hackathon kicks off on Oct 27, 2025, includes office hours on Nov 3 & 10, and wraps up with Demo Day on Nov 12 at the MapLibre Native monthly meeting.

Sign up here to learn, experiment, and shape the future of the project

🌐 MapLibre GL JS

September was a busy month with four new releases:5.7.1, 5.7.2, 5.7.3 and 5.8.0.

The latest one, 5.8.0, stands out, as it introduces data-driven styling for line-dasharray, a long-awaited feature and the most upvoted issue in our tracker. Thanks Lucas (@lucaswoj) for this great contribution! We are super excited someone in the community decided to work on it.

Other improvements this month include:

Fixes for raster tile fading, with more enhancements coming soon thanks to Ryan (@wayofthefuture).
Numerous fixes to global-state, primarily led by @melitele, significantly ironing out most of the related issues.

📝 MapLibre Tile Specification

The MapLibre Tile Specification project is now stable. This first version focuses on functional compatibility with MVT, with other functionality still experimental and subject to change.

MLT (MapLibre Tile) is a new vector tile format designed for efficient storage and rendering of map data, optimized for the MapLibre ecosystem.

We have added an implementation status overview page to the documentation site of the MapLibre Tile Specification. Here you can track the status of (planned) implementations and integrations, or add your own.

✏️ Maputnik

This month has been a very productive one for our small style editor.

Maputnik had recently gained the status of a “supported project” in MapLibre, so if there’s something you’d like to work on and get paid this is now possible.

Harel has been working hard to update all the libraries to their latest versions, including React to version 19. This upgrade required replacing outdated libraries that are no longer maintained and fixing issues across the existing codebase.

We also added support for more recent changes to the MapLibre Style Spec, such as globe projection and global-state, along with several lesser-known fields introduced in recent years.

This marks a strong start to Maputnik’s new status, and we believe that the more stable and widely used it becomes, the more features it will receive from this great community.

Maputnik editor interface

🪶 MapLibre Flutter

This month brings a big step forward for the MapLibre Flutter plugin: MapLibre Flutter v0.3.0 has been released.

The highlight of this release is full iOS support, enabled through native interoperability between Dart and Swift/ObjC. With this, MapLibre Flutter now runs across Android, iOS, and the web using a modern codebase.

All MapLibre SDK versions have been updated:

iOS: v6.19.1
Android: v11.13.5
Web: v5.8.0

A major ongoing goal for the package is to deliver a seamless cross-platform experience. A map style can now be added as a JSON string, via a Flutter assets path, or through a URI on all platforms. Additionally, PMTiles support on the web has been added to achieve feature parity with Android and iOS.

More functionality has made its way into this release. You can find all user facing changes in the changelog.

🧩 Martin

This month, Martin has undergone significant refactoring.

For those not following Martin’s versioning closely: before reaching v1.0, we are doing SemVer-breaking releases for each minor version (every X in 0.X.Y), since Martin is also published as a Rust library, allowing you to build your own tile server using its internals.

We’ve now refactored the core functionality into a separate library, martin-core.

Other highlights this month include:

New warnings for misspelled config keys.
A brand new logo thanks to Ryan (@wayofthefuture) 🎉.

On the road to v1.0, we are currently working on three key features:

OGC API Tiles–compliant source discovery
Server-side style raster tile rendering
PMTiles sources for more cloud providers, beyond just AWS S3

We’re on track to release Martin v1.0 by the FOSS4G conference in November. You can follow the ongoing work in this GitHub discussion.

Like other MapLibre projects, Martin has also hardened its CI and release infrastructure against supply chain attacks in this release. We are now publishing immutable, attested releases via CI instead of manually. Further details are available on Slack.

🦀 maplibre-native-rs

The MapLibre Native Rust bindings have seen a steady stream of changes to enable server-side map rendering (rasterization) for Martin and other projects.

We currently offer a single-instance Pool for rendering tiles, which already provides solid performance. MapLibre Native internally uses multithreading.

Work is ongoing to design a multi-instance Pool, and we’re actively seeking feedback. If you have complex server-side rendering use cases, we’d love to hear from you to ensure the upcoming APIs work well for your needs.

Tile rendering using maplibre-native-rs

🎉 Spatial K Onboarding

We have on-boarded Spatial K (onboarding ticket), a set of libraries for working with geospatial data in Kotlin, created by Derek Ellis and generously passed over to MapLibre for continued collective maintenance.

Spatial K includes:

An implementation of GeoJSON
A port of Turf.js written in pure Kotlin
Kotlin Multiplatform support
A Kotlin DSL for building GeoJSON objects

It is already in use by MapLibre Compose.

Expanding on Spatial K:

GeoKJSON: There is a fork of Spatial K named GeoKJSON by Sebastian Heeschen, which we will be able to upstream into Spatial K, with Sebastian’s guidance. See the ticket for the porting effort.
MapLibre Java: There is significant overlap between Spatial K and MapLibre Java, especially after the recent refactor to Kotlin by Fabian Keunecke. This work will help fill in gaps in Spatial K, enabling better alignment between the libraries. See the ticket for details.

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Navigation: Oct 08, 2025 – 4:00–5:00 PM UTC
MapLibre Native: Oct 08, 2025 – 5:00–6:00 PM UTC
MapLibre GL JS: Oct 08, 2025 – 6:00–7:00 PM UTC

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

Oct 29, 2025 – 9:00–10:00 AM UTC

🔗 View meeting times in your local timezone.

All calls are open to everyone. Zoom links are shared in the MapLibre Slack. Not yet a member? Request an invite via the OpenStreetMap US Slack. We’d love to see you there!

Results of the 2025 MapLibre Governing Board Election

Mon, 22 Sep 2025 00:00:00 GMT

We are happy to announce the results of the 2025 MapLibre Governing Board election and also welcome our newest Voting Members. A big thanks to everyone who participated in this year’s election process. Your engagement is what keeps MapLibre a strong, community-driven project.

Board Results

The following members have been elected to serve on the 2025 MapLibre Governing Board:

Yuri Astrakhan (incumbent)
Frank Elsinga (new)
Stephanie May (new)
Birk Skyum (incumbent)
Haowen You (incumbent)

MapLibre Board Members 2025

🎉 We are delighted to welcome Frank Elsinga and Stephanie May as new members of the Board, along with incumbents Yuri Astrakhan, Birk Skyum, and Haowen You.

💐 We appreciate the participation of Stefan Karschti, who contested in this year’s election and continues to be an active member of our community.

🙏 Finally, we express our sincere gratitude to Luke Seelenbinder and Petr Pridal, who have generously volunteered their time and energy as Governing Board members for three terms. Their contributions have been invaluable in strengthening MapLibre’s foundation and growth.

📊 Key Election Statistics

Total eligible voters (Voting Members): 141
Ballots cast: 92
Voter turnout: ~65% (highest since 2022)
Seats available: 5 (out of 6 candidates)
Election method: Conducted online using OpaVote, with ranked-choice voting (Meek STV).

👉 Checkout the detailed election results on GitHub.

🗳️ New Voting Members

As part of the 2025 Governing Board election process, we held a round of nominations to expand the Voting Members group. Voting Members are responsible for electing the Governing Board and voting on changes to the MapLibre Charter.

We’re pleased to welcome 19 new Voting Members this August and look forward to their contributions in shaping MapLibre’s future.

You can checkout the full list of 141 Voting Members in our GitHub documentation.

We extend our appreciation to all candidates, Voting Members, and the wider community for supporting MapLibre’s mission.

Looking forward to an exciting year ahead!

MapLibre Newsletter August 2025

Thu, 04 Sep 2025 00:00:00 GMT

August was a busy month for the MapLibre community. From welcoming new Voting Members as part of the Governing Board election process to new releases across key projects, there is plenty of progress to celebrate.

First and foremost, we extend our gratitude to Microsoft for continuing, and increasing their sponsorship for MapLibre this year. Their contribution has nearly doubled, elevating them to Gold Sponsor and providing vital support for the sustainability of our projects.

Many thanks to Microsoft for their steadfast support to MapLibre (2023-2025) 🎉

🗳️ New Voting Members

We’re pleased to welcome 19 new Voting Members this August and look forward to their contributions in shaping MapLibre’s future.

You can checkout the full list of 141 Voting Members in our GitHub documentation.

📱 MapLibre Native

Want to help test MapLibre Android? In addition to our existing continuous integration tests we are taking a crowdsourced approach to testing. We now make releases of the MapLibre Android TestApp. If you want to help, simply download the apk and install it on a Android device you have laying around. Next, open the ‘Long running Maps’ activity and let it run for up to 72 hours! Crashes are logged to our Sentry so that MapLibre developers can investigate and fix issues.

Android TestApp running the long running test (or ‘Desert Bus’)

MapLibre Android 11 was released well over a year ago, but some people are still on MapLibre Android 10.x.x. We made a release for this previous major release to bring 16 KB pages support since Google will require it for apps on the Google Play store starting November 1.
Two minor regular releases MapLibre Android 11.13.1 and MapLibre iOS 6.18.1.
MapLibre Node.js also had a release that fixes a problem where it would not render more than 32 frames.

🌐 MapLibre GL JS

Version 5.6.2 and 5.7.0 were released this month.

These releases focused mainly on some bugs fixes, especially related to the recently added global-state which probably still needs more ironing out. There was also an addition of the coveringTiles method to the public API after it was buried a bit too deep when adding the globe support in version 5.

Huge thanks to all contributors who helped make these improvements possible, we appreciate your efforts and look forward to more contributions!

🧩 MapLibre Tile Format

Work continues on the maplibre-tile-spec project as we are finalizing the specification for the 1.0 release next month. Additionally we are also preparing the Java based MVT to MLT converter for release.

Last-minute comments are still possible in this thread. Contributions and comments are highly valued!

🎉 Slint SDK Onboarding for MapLibre Native

We’re excited to share the onboarding of a new Slint SDK for MapLibre Native, made by @yuiseki.

This project provides a Slint-based integration for MapLibre Native, allowing MapLibre Native rendering to be embedded into Slint-based native GUI applications. For information on platform support, please checkout the documentation in the project repository.

Windows screenshot

macOS screenshot

🌍 Ecosystem Spotlight: Sprite Sheet Benchmarks

OSM contributor pnorman recently benchmarked three tools for generating sprite sheets: spreet (Rust), @basemaps/sprites, and sprite-one.

These tools are often used when building MapLibre styles. Results show spreet produces smaller, more efficient PNGs, especially after optimization.

👥 Conferences

MapLibre is happy to be one of the sponsors of FOSS India 2025, taking place in Bengaluru, India this September. 🎉

As part of our sponsorship, we’re giving away a limited number of free tickets to community members and contributors. Details and sign-up are in this discussion thread: MapLibre: FOSS India 2025 – ticket giveaway

📅 Event Dates: 20-21 September 2025
📍 Location: Bengaluru, India
🔗 Event Info: https://fossunited.org/indiafoss/2025

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Navigation: Sep 10, 2025 – 4:00–5:00 PM UTC
MapLibre Native: Sep 10, 2025 – 5:00–6:00 PM UTC
MapLibre GL JS: Sep 10, 2025 – 6:00–7:00 PM UTC

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

Sep 24, 2025 – 9:00–10:00 AM UTC

🔗 View meeting times in your local timezone.

All calls are open to everyone. Zoom links are shared in the MapLibre Slack. Not yet a member? Request an invite via the OpenStreetMap US Slack. We’d love to see you there!

MapLibre Newsletter July 2025

Mon, 04 Aug 2025 00:00:00 GMT

Welcome to the July edition of the MapLibre newsletter! We start with a note of gratitude to our sponsor Jawg Maps.

Sincere thanks to Jawg Maps for their ongoing commitment to MapLibre (2023–2025) 🙌

This month’s newsletter brings exciting updates across the MapLibre ecosystem, from enhanced font support for complex scripts in Native, a new frontend for Martin, to our growing presence at global conferences. We also kicked off the 2025 Governing Board election process, a great opportunity to help shape the project’s future. Read on for the latest updates and ways to get involved!

🗳️ Governing Board Elections 2025

MapLibre’s 2025 Governing Board election process has begun!

Voting Member Nominations are now open. Existing Voting Members can nominate new ones via pull request.
Governing Board Candidates can self-nominate by sharing their vision and background in the candidate discussion thread.

Date	Milestone
Aug 15, 2025	Deadline for Voting Member nominations and Board candidate registration
Aug 22, 2025	Deadline for approval of new Voting Members (via PR review)
Aug 29, 2025	Governing Board election poll closes (OpaVote)

📱 MapLibre Native

Support for Complex Scripts: We added support for the new font-faces property (see the implementation PR). This allows you to use TrueType fonts with MapLibre Native. Font files are needed for text shaping which many complex (non-latin) scripts require. Thanks goes to Alan Wei Chen, Stefan Karschti and Grab for contributing this functionality.

Crowdsourced Device Testing: Adrian Cojocaru has developed long running tests for Android and iOS. Now we are thinking about how we can actually run these. Since AWS Device Farm limits runs to 150 minutes, we are thinking about distributing an app that people can download, to run these tests on their own devices. This app would report any issues to a central place. So a crowed-sourced approach to bug hunting. More info will follow and please share your ideas!
Render Area Limiting: Yousif Aldolaijan has contributed a PR to limit the area that is rendered to, while keeping the surface area the same size. This is useful for performance reasons when navigation elements are sometimes overlapping those areas. See #3676 for the PR and discussion.
Concurrent Animations: The location component on Android and iOS takes control of animations. This means that users of the built-in location component cannot kick off your animations of their own, as it would conflict with those of the location components. Yousif is exploring concurrent animations as a possible fix for this behavior. Join the discussion if you have a similar use case or have solved this problem.
Style JSON Hook: Malcolm Toon contributed a PR (see also the issue) to add a hook to transform the style JSON when it is loaded or fed to the map view. Please join the discussion if you have another interesting use case for this.
Custom protocols: We are investigating what custom protocols similar to the MapLibre GL JS addProtocol hook would look like for Native. Malcolm has cooked up a PR. One discussion point is, if it should be synchronous or asynchronous on the platform level, if it is desirable (and feasible) to give access to the built-in resource loading to the platform level and if custom protocols should be able to do resource loading as well as transformations (or just the former). Please let us know your use cases you imagine for this functionality.
Qt backend: Birk Skyum has made several PRs to bring the Vulkan and Metal backend to the Qt platform.
macOS Metal bugfix: The Node.js platform with Metal (on macOS) stopped rendering after 32 frames. We added a flag that will set up an Objective-C autoreleasepool in the core rendering loop that fixes this issue. A new version of the maplibre/maplibre-gl-native npm package which contains this fix will be out shortly.
Releases this month:
- MapLibre Android 11.12.0, 11.12.1, 11.13.0.
- MapLibre iOS 6.17.1, 6.18.0

🌐 MapLibre Web

Version 5.6.1 was released this month with a few bug fixes. We also sorted the examples pages in the documentation, for better consistency between the page titles and their locations in the table of contents. This change might cause a few temporary broken links in Google search, but we’re sure the broken links will be a short lived problem and expect this to be resolved quickly.

📝 Style spec

We’ve added support in the style-spec for font-faces for files and urls which is a huge step forward in order to support eastern scripts and other fonts without the need to pre-process them to glyphs. The discussion around it was very good with a lot of valuable inputs. Thanks to everyone that participated!

🧩 Martin

Martin v0.18 has been released, featuring the new web UI frontend with the basic metrics, tile inspection, view styles with Mapunik as an add-on, and view sprites and fonts.

🦀 maplibre-native-rs

MapLibre Native has continued to progress steadily over the past month, with notable improvements especially for integrating into Rust projects:

You can now build with maplibre-native-rs using even more static “maplibre-core-amalgam” binaries. ICU and other previously required external dependencies are now bundled into the core libraries, greatly reducing build friction.
Platform readiness: There’s still work to be done before reaching production parity, particularly regarding macOS and Windows support.
Early groundwork is being laid for incorporating maplibre-native-rs into the Martin tile server.

We also have a new social image for this project:

Social image for maplibre-native-rs, Rust native backend of MapLibre.

✨ Community spotlight

The OpenStreetMap homepage recently introduced two new featured map layer options powered by MapLibre GL JS via maplibre-gl-leaflet. There are also ongoing discussions about whether switching from maplibre-gl-leaflet to a more “unwrapped” implementation using maplibre-gl-js directly might offer additional benefits.

👥 Conferences roundup

Over the past two months, we participated in several key events:

🇺🇸 State of the Map US: We delivered hands-on workshops and insightful talks. You can find the materials on GitHub.
🇳🇱 FOSS4G Netherlands: A great opportunity to connect with the local FOSS4G community and showcase MapLibre in action.
🇧🇦 FOSS4G Europe (Mostar): The team hosted sessions, demos, and conversations on open mapping. You can find the workshop materials on GitHub.

We’re grateful to everyone who joined us and we look forward to upcoming events including FOSS4G Oceania in Auckland and FOSS4G North America in Washington, DC.

🗓️ Monthly meetings

We continue our regular community calls on the second Wednesday of each month, with an additional session on the last Wednesday to better accommodate Asia/Oceania time zones.

Upcoming Calls

MapLibre Navigation: Aug 13, 2025 – 4:00–5:00 PM UTC
MapLibre Native: Aug 13, 2025 – 5:00–6:00 PM UTC
MapLibre GL JS: Aug 13, 2025 – 6:00–7:00 PM UTC

🌏 MapLibre Eastern Call

Held on the last Wednesday of the month at an Asia/Oceania-friendly hour:

Aug 27, 2025 – 9:00–10:00 AM UTC

🔗 View meeting times in your local timezone.

All calls are open to everyone. Zoom links are shared in the MapLibre Slack. Not yet a member? Request an invite via the OpenStreetMap US Slack. We’d love to see you there!