Skip to content

Why MapLibre GL

There are several ways to put a map in a Flutter app. This page compares the three most widely used ones, so you can pick the right one; other packages exist, including other MapLibre-based ones, so a look at pub.dev is worth it too. If another library fits your project better, use it.

Capability flutter-maplibre-gl flutter_map google_maps_flutter
Renderer MapLibre Native (C++/GPU) Flutter canvas Google Maps SDK
Offline maps ✔ Android & iOS ● Via plugin ✘ No
Custom vector styles ✔ Full spec ● Limited ● Cloud styling
GeoJSON support ✔ Full + live update ● Via plugins ● Limited
Data-driven styling ✔ Expressions ✘ No ✘ No
Clustering ✔ Native ● Via plugin ● Marker clustering
Heatmaps ✔ Yes ✘ No ✘ No
3D extrusion ✔ Yes ✘ No ● Limited
PMTiles ✔ Built-in ● Via plugin ✘ No
Vector tiles ✔ Yes ● Via plugin ✘ Not as your own source
Open tile sources ✔ Yes ✔ Yes ● As overlays; key for the base map
Web support ✔ GL JS ✔ Yes ✔ Yes
License ✔ BSD-3 ✔ BSD-3 ● Plugin BSD-3, SDK proprietary
Tile cost ✔ Free options ✔ Free options ✔ Free options
Desktop (Windows, macOS, Linux) ✘ Not a target ✔ Yes ✘ No
Flutter widgets inside the map ✘ Overlay only ✔ Yes ✘ Overlay only
Built-in POI, traffic and Street View data ✘ Bring your own ✘ Bring your own ✔ Yes
Native setup required ● Permissions only ✔ None ● Key and permissions

✔ supported  ·  ● partial / via plugin  ·  ✘ not available

Choose flutter-maplibre-gl when

You need any of these, and they are hard or impossible elsewhere:

  • Offline maps. Users download regions and keep using the map with no connection.
  • Custom styling. White-label maps, dark mode, brand colors, show or hide individual layers.
  • Large datasets. Tens of thousands of GeoJSON features rendered on the GPU without dropping frames.
  • Data-driven styling. Color roads by speed limit, size circles by population, all evaluated per feature at render time.
  • PMTiles. Self-host your tile data as a single file with no tile server.
  • An open stack. No vendor lock-in and no API key when you use open tile providers.
  • Advanced cartography. 3D buildings, hillshade, heatmaps, terrain.

Choose flutter_map when

flutter_map is the right call when:

  • You want pure Flutter rendering with no native code, including smooth desktop support without platform-view overhead.
  • You need to overlay arbitrary Flutter widgets directly inside the tile layer.
  • Your map is simple: raster tiles plus a handful of markers.
  • You target Linux, macOS or Windows desktop, which this package does not support.
  • Your team wants to avoid native iOS and Android setup.

flutter_map renders raster tiles (PNG/WebP) by default: vector styles, expressions and GPU-accelerated vector rendering are not part of the core package, though community plugins such as vector_map_tiles add vector tile rendering on top.

Choose google_maps_flutter when

google_maps_flutter fits when:

  • Users expect the Google Maps look and brand.
  • You already run a Google Maps Platform billing account and key.
  • You need Google-specific features: Street View, Places integration, Google traffic.
  • Your organization mandates Google services.

Pricing and quotas change, so check Google Maps Platform pricing for the current terms; as of August 2026 the mobile Maps SDKs carry no map-load billing, though an API key and a billing account are still required. The plugin exposes no offline download API, and styling goes through Google's cloud-based map styling or a style JSON rather than the MapLibre style spec.

Performance at scale

Rendering 10,000 point features is where the architectural difference shows:

Aspect flutter-maplibre-gl flutter_map google_maps_flutter
Approach Vector tiles + GPU Raster tiles + canvas Raster tiles + SDK
10k points ✔ Native cluster/layer ● Plugin, cost grows per feature ● Marker clustering
Where features are drawn ✔ GPU, native engine ● Flutter canvas ● Google Maps SDK

All rendering is delegated to the native MapLibre engine, which runs on the GPU. The Flutter layer only manages configuration. The difference is architectural rather than a benchmark result: see Architecture. Measure with your own data and target devices before deciding.

For the full platform-by-platform breakdown, see the Feature Matrix.