Native memory leak and crash when panning map with dynamic polygon layers

[MAXBAF1]

🐞 Native memory leak and crash when panning map with dynamic polygon layers

Hi!
I’ve encountered a native memory leak issue when using MapLibre Compose while dynamically rendering a large number of polygons (hexagonal cells) that cover the entire map.

When I actively move (pan or zoom) the map, native memory usage keeps growing until the app eventually crashes.
This is clearly visible in the Android Profiler — the native heap steadily increases during continuous interactions.
It seems like some native resources (layers, tiles, or geometry buffers) might not be released properly during frequent camera movements or map updates.

I created a minimal reproducible project where this behavior can be easily observed:
👉 https://github.com/MAXBAF1/HexMapTest

Below are logs, profiler screenshots, and a short video showing the issue:

📄 Logs:
log1.txt
log2 full.txt

🖼️ Profiler screenshots:

🎥 Video demonstration:
https://drive.google.com/file/d/11YPr1o4PzAnqLw1eBELsycGnVMA5DfCA/view?usp=sharing

---

Steps to reproduce

1. Clone and open the sample project above.
2. Launch the app — it renders a grid of hexagonal cells that fully cover the visible map area.
3. Move or zoom the map continuously for 1–2 minutes.
4. Observe native memory usage in Android Studio Profiler — it keeps increasing until the app crashes.

---

Expected behavior

Memory should remain stable or be reclaimed when cells/layers are removed or replaced.

Actual behavior

Native memory usage keeps growing with map interactions and eventually leads to an OOM crash.

---

Environment

Component	Version
MapLibre Compose	0.10.4
Mapbox Maps SDK (dependency)	11.7.0-rc.1
H3	4.3.0
Kotlin	2.2.0
Android Gradle Plugin	8.10.0
Compose BOM	2024.09.00
lifecycle-runtime-ktx	2.9.1
activity-compose	1.10.1
Device	POCO X7 Pro
Android Version	Android 15
Renderer	OpenGL
Build Type	Debug
Android Studio	Android Studio Narwhal 3 Feature Drop

---

Additional info

The issue becomes apparent only when the map is moved actively for a while — during static use, memory usage remains stable.
Based on profiler traces, it appears that native memory (possibly GPU buffers or internal geometry data) is not released even after layers are removed or replaced.

Could you please check whether this might be a native resource leak related to frequent layer updates or camera movement in the Compose integration?

Thanks a lot for your work on this project 🙏

[sargunv]

On Android, native resources are managed by the MapLibre Native SDK for Android: https://github.com/maplibre/maplibre-native

This library is a Kotlin wrapper of that one.

It looks like you're also using another native library to generate the data for the computed source. Have you confirmed the memory leak relates to MapLibre Native resources, not resources from that library?

[MAXBAF1]

To further demonstrate that the issue is caused by native memory allocation inside MapLibre, I’d like to share another error that I encounter frequently in my main project (not in the minimal demo I previously linked).

In this project, everything initially works correctly — the map renders smoothly, and native memory usage might even stay stable for a while.
However, at a completely random moment, usually during a zoom or pan action, MapLibre suddenly tries to allocate an impossible amount of memory, leading to a native crash.

Here’s an example of that crash:
alloc.txt

The key part here is this line:

malloc(2533309150593032) failed: returning null pointer

This shows that the renderer attempted to allocate ~2.5 petabytes (2,533,309,150,593,032 bytes) of memory — which is obviously impossible on any Android device.
This indicates a severe internal overflow or invalid size calculation happening in the native rendering layer, likely related to vertex or buffer size computations when rendering large or frequently updated geometries.

The subsequent std::bad_alloc confirms that this request reached the native allocator and failed catastrophically, crashing the render thread.

The H3 library (com.uber:h3:4.3.0) is used only to compute polygon coordinates (hexagonal cells) before converting them into GeoJSON features passed to MapLibre.
It doesn’t manage or allocate GPU buffers, nor does it retain native memory after producing coordinate lists — so it’s very unlikely to trigger a multi-petabyte allocation in libc.

The fact that the exception occurs inside:

org.maplibre.android.maps.renderer.MapRendererRunnable.run(Native Method)

further supports that this happens deep within the native rendering loop, not in the Compose or Kotlin layers.

---

Environment details:

Component	Version
MapLibre Compose	0.10.4
MapLibre Android	12.0.0

[sargunv]

Looks like this is definitely happening inside MapLibre Native. I'd recommend reporting the bug, with that alloc.txt, to https://github.com/maplibre/maplibre-native.

[sargunv]

Based on profiler traces, it appears that native memory (possibly GPU buffers or internal geometry data) is not released even after layers are removed or replaced.

Do you have the data indicating this?