Skip to content
Published on

Map & Geospatial Tools 2026 — Mapbox / MapLibre / deck.gl / Leaflet / ProtoMaps / Felt / OSM Deep Dive

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

1. The 2026 Map Tool Landscape — Commercial / Open Source / Data / Visualization

The geospatial tooling landscape in 2026 looks very different from five years ago. Mapbox closing GL JS v3 (Sept 2023) under its own BSL license pushed the open-source camp to fork into MapLibre, deck.gl became the de facto standard for big-data visualization with WebGPU support, collaborative editors like Felt emerged, and ProtoMaps invented a new paradigm: "host the entire world's vector tiles as a single static file."

The big picture splits into four categories.

  • Commercial SaaS — Google Maps Platform, Mapbox, Stadia Maps, Carto, ArcGIS Online, Kakao Maps, Naver Maps, TMAP, Yahoo Maps
  • Open-source libraries — MapLibre GL JS 5, Leaflet 1.9, deck.gl 9, OpenLayers 10
  • Open data + routing — OpenStreetMap, ProtoMaps, OSRM, Valhalla, GraphHopper, Japan GSI, Korea V-World
  • Visualization / analytics / journalism — Kepler.gl, Datawrapper, Felt, QGIS 3.40, ArcGIS Pro, Mapeo, Mapillary

Two events dominated 2024 to 2026. First, Mapbox switched GL JS v3 to BSL 1.1 (Business Source License) in Sept 2023, ending the open era and forcing the open-source split to MapLibre. Second, ProtoMaps made PMTiles a practical "drop one file in S3 / Cloudflare R2 and you have vector tiles" workflow, crashing the entry barrier for self-hosting.

This guide tours every one of those tools at a May 2026 snapshot. Beginners can decide where to start; seniors can decide what to add to the next project.

2. Mapbox GL JS v3 Split (Sept 2023) — Open Goes to MapLibre

Mapbox GL JS was open source (BSD-3) from v1 in 2014, switched to a proprietary license at v2 in December 2020, and tightened to BSL 1.1 at v3 in September 2023 — alongside major new features like the Standard Style, 3D terrain, the Light API, and globe projection.

The core BSL 1.1 condition is simple: do not use this code to build a commercial mapping service that competes directly with Mapbox. Using a Mapbox API key in a normal website or app is still free. Building "another Mapbox" with this code is a license violation. And the GL JS v3 source is no longer freely forkable on GitHub.

The headline features of Mapbox GL JS v3 are:

  • Standard Style — a new default style with 3D buildings, lighting model, and time-of-day color shifts
  • Mapbox Lights — day/dusk/night lighting presets, shadow simulation
  • 3D Terrain — DEM-driven 3D relief
  • Globe Projection — round globe instead of flat plane when zoomed out
  • Custom Layers — write your own WebGL shader layers
  • Vector Tiles 2.0 — Mapbox's own vector tile format
import mapboxgl from 'mapbox-gl'

mapboxgl.accessToken = 'pk.eyJ1Ijoi...'

const map = new mapboxgl.Map({
  container: 'map',
  style: 'mapbox://styles/mapbox/standard',
  center: [127.0, 37.5], // Seoul
  zoom: 11,
  projection: 'globe', // new v3 default
})

map.on('style.load', () => {
  map.setConfigProperty('basemap', 'lightPreset', 'night')
  map.setFog({ color: 'rgb(186, 210, 235)', range: [0.5, 10] })
})

Pricing in 2026 is per monthly active user (MAU): 25,000 MAU free, then about $1 to $5 per additional 1,000 MAU depending on plan. Small sites are effectively free; high-traffic services can hit tens of thousands of dollars per month. If price or license is a problem, MapLibre in the next chapter is the top alternative.

3. MapLibre GL JS 5 (June 2025) — The Open Standard

MapLibre is the open-source project that started in December 2020 by forking the last BSD release of Mapbox GL JS v1. It runs as a Linux Foundation project with governance by AWS, Meta, MapTiler, Microsoft, Stadia Maps, and others.

MapLibre GL JS 5 shipped in June 2025 as the successor to v4 (2024), with these headline changes:

  • Globe projection officially shipped — near-parity with Mapbox's globe
  • 3D terrain stabilized — went GA after a v4 beta
  • Vector tile style spec compatible with Mapbox Style Spec 1.x, plus MapLibre extensions
  • WebGL2 as default — WebGL1 fallback dropped, faster rendering
  • Full TypeScript rewrite complete
  • Experimental WebGPU support — a few layer types can run on a WebGPU backend
import maplibregl from 'maplibre-gl'
import 'maplibre-gl/dist/maplibre-gl.css'

const map = new maplibregl.Map({
  container: 'map',
  style: 'https://demotiles.maplibre.org/style.json', // free demo style
  // or a self-hosted style
  // style: 'https://your-cdn.example.com/style.json',
  center: [126.978, 37.566], // Seoul City Hall
  zoom: 12,
  projection: 'globe', // new in MapLibre 5
})

// Code is largely compatible with Mapbox GL JS
map.on('load', () => {
  map.addSource('points', {
    type: 'geojson',
    data: '/poi.geojson',
  })
  map.addLayer({
    id: 'points-layer',
    type: 'circle',
    source: 'points',
    paint: {
      'circle-radius': 6,
      'circle-color': '#3b82f6',
    },
  })
})

MapLibre's real value is "you can decouple the tile server." Mapbox bundles the client library with the tile service; MapLibre ships only the client and lets you bring any tile source.

Tile hosting options:

  • MapTiler Cloud — MapLibre-friendly SaaS, includes Korea and Japan styles
  • Stadia Maps — Mapbox-replacement SaaS based on OpenStreetMap
  • ProtoMaps PMTiles — self-hosted (next chapter)
  • AWS Location Service — AWS-native
  • Self-operated — tileserver-gl, Martin, t-rex and other open tile servers

If you are starting a project in 2026 with no compelling reason to need Mapbox specifically (detailed SF / NYC 3D buildings, Standard Style cartography), the default is MapLibre + MapTiler or MapLibre + ProtoMaps.

4. deck.gl 9 — WebGL/WebGPU Visualization

deck.gl is the large-scale data visualization library Uber open-sourced in 2016 (Carto now maintains most of the core). Where a traditional map library tops out at "a few markers on a map," deck.gl targets "hundreds of thousands of points and tens of thousands of polygons rendered on the GPU in one frame."

deck.gl 9 (2025) brought these headline changes:

  • Official WebGPU support — 2 to 4 times faster than WebGL on supported layers
  • React 18 concurrent mode compatibility
  • Layer modules split for better tree shaking (30% bundle reduction)
  • New GeoArrow integration — render Apache Arrow data directly

Notable layer types:

  • ScatterplotLayer — points
  • HeatmapLayer — heatmaps
  • HexagonLayer — hex-bin aggregation
  • ArcLayer — arcs between two points (shipments, movement)
  • TripsLayer — time-series path animation
  • TerrainLayer — 3D terrain
  • TileLayer — slippy map tiles
  • MVTLayer — Mapbox Vector Tiles
  • H3HexagonLayer — Uber H3 index hexagons

The most common pattern is to layer deck.gl on top of MapLibre or Mapbox.

import { DeckGL } from '@deck.gl/react'
import { HexagonLayer } from '@deck.gl/aggregation-layers'
import { Map } from 'react-map-gl/maplibre'
import maplibregl from 'maplibre-gl'

const INITIAL_VIEW_STATE = {
  longitude: 127,
  latitude: 37.5,
  zoom: 11,
  pitch: 45,
  bearing: 0,
}

const layers = [
  new HexagonLayer({
    id: 'hexagon-layer',
    data: '/taxi-pickups.json',
    getPosition: (d) => [d.lng, d.lat],
    radius: 200,
    elevationScale: 4,
    extruded: true,
    pickable: true,
    coverage: 0.88,
  }),
]

export function MapView() {
  return (
    <DeckGL initialViewState={INITIAL_VIEW_STATE} controller={true} layers={layers}>
      <Map mapLib={maplibregl} mapStyle="https://demotiles.maplibre.org/style.json" />
    </DeckGL>
  )
}

deck.gl works standalone, but is usually mounted on top of a base map (MapLibre / Mapbox / Google Maps). Google Maps Platform has officially supported deck.gl's GoogleMapsOverlay since v9.

When to pick deck.gl — over 1,000 points, or any time-series, 3D extrusion, or hex aggregation requirement. For 10 markers, Leaflet still wins.

5. Leaflet 1.9 — The Classic, Still Here

Leaflet is the open-source map library Volodymyr Agafonkin (then a Mapbox employee, now full-time OSM) released in 2011. It's the smallest, simplest, and least dependent option. Version 1.9 shipped in June 2022 and remains the last major release; a 1.9.5 patch in October 2025 keeps it functional in 2026.

Leaflet's core traits:

  • 39 KB gzipped — the lightest
  • Zero dependencies — pure JS
  • Raster-tile (image-tile) first — vector tiles are a plugin
  • An overwhelming plugin ecosystem — hundreds of plugins
import L from 'leaflet'
import 'leaflet/dist/leaflet.css'

const map = L.map('map').setView([37.5665, 126.978], 13)

L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
  maxZoom: 19,
  attribution: '© OpenStreetMap contributors',
}).addTo(map)

L.marker([37.5665, 126.978])
  .addTo(map)
  .bindPopup('Seoul City Hall')
  .openPopup()

(The z, x, y in that URL template are the standard slippy-map tile placeholders that Leaflet fills in for you.)

Pick Leaflet when — under 100 markers, plain OSM styling is enough, and you want minimum bundle size and minimum dependencies. Government sites, school admin pages, and small-business store locators are still Leaflet's sweet spot.

Avoid Leaflet when — you need 3D, globe projection, dynamic vector-tile styling, or tens of thousands of data points. Go to MapLibre or deck.gl for those.

6. Google Maps Platform — The General-Purpose Standard

Google Maps Platform is still number one for general consumer use in 2026. "Where is this cafe" style consumer maps, general routing (excluding autonomous driving), Street View, and POI (point of interest) accuracy — Google still leads all three by a wide margin.

Notable changes from 2024 to 2026:

  • Maps JavaScript API v3 — the de facto standard
  • Maps API for Web Components (2024) — web components like gmp-map
  • Photorealistic 3D Tiles (2023 to 2026) — full 3D cities from satellite + aerial photos (Seoul, Tokyo, NYC and other major metros)
  • AI Place Details (Gemini integration) — AI summaries on POIs
  • Official deck.gl GoogleMapsOverlay support
<!-- New web-component approach -->
<script async src="https://maps.googleapis.com/maps/api/js?key=API_KEY&libraries=maps,marker&v=beta"></script>

<gmp-map center="37.566,126.978" zoom="14" map-id="DEMO_MAP_ID">
  <gmp-advanced-marker position="37.566,126.978" title="Seoul City Hall"></gmp-advanced-marker>
</gmp-map>

Pricing is the steepest. As of 2026: $200 monthly free credit, then $7 per 1,000 Map Loads, $17 per 1,000 Place Details, $5 per 1,000 Directions. Small sites are free; high-traffic services can easily hit tens of thousands per month.

Pick Google Maps when — building a consumer-facing service (delivery, real estate, store locator) where POI accuracy moves revenue. Otherwise MapLibre is almost always cheaper and freer.

7. OpenStreetMap + OSRM / Valhalla / GraphHopper — Open Data + Routing

OpenStreetMap (OSM) is "the Wikipedia of maps," running since 2004. In 2026 OSM has roughly 11 million registered mappers and billions of nodes, ways, and relations — the largest open geospatial dataset in the world.

OSM data itself is licensed under ODbL (Open Database License) and is used in many forms:

  • Tiles — OSM.org default tiles, Stadia, MapTiler, or self-hosted (PMTiles)
  • Routing — OSRM, Valhalla, GraphHopper
  • Geocoding — Nominatim, Pelias, Photon
  • Analytics — Overpass API, QGIS, GeoPandas

The three major routing engines compared:

EngineLicenseStrengthsHosting
OSRMBSD-2C++, fastest, car-centricosrm.org (rate-limited free)
ValhallaMITMapbox/Tesla origin, multi-modal, elevation-awareStadia Maps, FOSSGIS
GraphHopperApache-2.0 (core)Java, bike/walk/truck, strong in EuropeGraphHopper.com SaaS

A quick OSRM bring-up looks like this:

# Spin up OSRM with Korea data via Docker
docker run -t -v $PWD:/data ghcr.io/project-osrm/osrm-backend osrm-extract -p /opt/car.lua /data/south-korea-latest.osm.pbf
docker run -t -v $PWD:/data ghcr.io/project-osrm/osrm-backend osrm-partition /data/south-korea-latest.osrm
docker run -t -v $PWD:/data ghcr.io/project-osrm/osrm-backend osrm-customize /data/south-korea-latest.osrm
docker run -t -i -p 5000:5000 -v $PWD:/data ghcr.io/project-osrm/osrm-backend osrm-routed --algorithm mld /data/south-korea-latest.osrm

# Routing query
curl "http://localhost:5000/route/v1/driving/126.978,37.566;127.045,37.501?geometries=geojson"

Valhalla handles bike / walk / truck / car in one engine and adds elevation-aware routing. GraphHopper is strong in Europe and shines for bicycle routing.

OSM + open routing engines are popular with mid-to-large services that find Google Maps pricing painful but can run their own infrastructure — logistics, delivery, and B2B fleet tracking.

8. Felt — Collaborative Map Editor (Series B 2024)

Felt is the collaborative map editor founded in 2021 by Sam Hashemi (ex-Carbon Five, 18F). It pitches itself as "the Figma for maps" and raised a $36M Series B in April 2024 led by Felicis (with Andreessen Horowitz and others).

Core value props:

  • Browser-native collaboration — share a link, edit together, leave comments
  • GIS features as SaaS — upload shapefiles / GeoJSON / KML / CSV and visualize immediately
  • Anchors — text + map interactive stories
  • API + embed — drop a one-liner into any site
<iframe
  width="100%"
  height="600"
  frameborder="0"
  title="Felt Map"
  src="https://felt.com/embed/map/Your-Map-Slug-AbCdEf123"
  allow="fullscreen"
></iframe>

The target users are urban planners, NGO data analysts, academic researchers, and journalists — "people who want to tell stories with maps but don't have a GIS degree." The learning curve for ArcGIS or QGIS is too steep for most of them, so they go to Felt.

Pricing in 2026: free for individuals on public maps, Pro at $15/month for private maps and larger files, Team / Enterprise on quote. US municipalities and environmental NGOs are core customers.

Pick Felt when — non-developer teams need to combine a map, some data analysis, and sharing without writing code; or when a marketing page just needs an embed and you want to skip the engineering time.

9. ProtoMaps — Single-File Static Vector Tiles (PMTiles)

ProtoMaps is the open-source project Brandon Liu kicked off in 2022, defining a single-file vector-tile format called PMTiles. Over 2024 to 2025, PMTiles became the de facto self-hosting vector-tile standard, and in 2026 Cloudflare officially supports it via R2 integration.

Core value:

  • Single file — the whole world (zoom 0 to 15) is about 100 GB as one file
  • HTTP Range Requests for partial download — the client only fetches what it needs
  • Static hostable — S3, R2, GitHub Pages, Vercel — anywhere with Range Request support
  • Zero server infrastructure — no DB, cache, or load balancer

A typical workflow:

# 1. Install PMTiles CLI
brew install protomaps/tap/pmtiles
# or grab a binary from GitHub Releases

# 2. Download a world-wide or region-specific PMTiles file
pmtiles download world.pmtiles \
  --bbox=126.5,37.4,127.5,37.8 \  # Seoul metro
  --maxzoom=14 \
  --source=https://build.protomaps.com/world.pmtiles

# 3. Upload to R2 or S3
aws s3 cp seoul.pmtiles s3://your-bucket/

# 4. Configure CORS and verify Range Request support

import maplibregl from 'maplibre-gl'
import * as pmtiles from 'pmtiles'

// Register the PMTiles protocol
const protocol = new pmtiles.Protocol()
maplibregl.addProtocol('pmtiles', protocol.tile)

const map = new maplibregl.Map({
  container: 'map',
  style: {
    version: 8,
    sources: {
      protomaps: {
        type: 'vector',
        url: 'pmtiles://https://your-cdn.example.com/seoul.pmtiles',
        attribution: '© OpenStreetMap, © Protomaps',
      },
    },
    layers: [
      /* import the ProtoMaps default style and use it here */
    ],
  },
  center: [127, 37.5],
  zoom: 11,
})

The biggest draw of ProtoMaps is cost. Serving worldwide tiles at 1 TB per month works out to about $15 in Cloudflare R2 (R2 has zero egress, so it's basically just the storage bill). The same traffic on Mapbox would be $5,000+ per month.

With the self-hosting barrier crashing, the 2026 default for new projects is shifting to "MapLibre + ProtoMaps PMTiles + R2."

10. Stadia Maps / Carto / Kepler.gl / Datawrapper — Analytics + Journalism

A quick run-down of the analytics and journalism toolkit.

Stadia Maps — A Mapbox-alternative SaaS launched in 2018, OpenStreetMap-based, MapLibre/Leaflet-friendly. Pricing is roughly 1/3 to 1/2 of Mapbox, and the company leans heavily into GDPR / EU data governance — popular with European customers. Since 2025 they have offered the classic Stamen Design styles (Toner, Watercolor, Terrain) free of charge.

const map = new maplibregl.Map({
  container: 'map',
  style: 'https://tiles.stadiamaps.com/styles/alidade_smooth.json',
  // or alidade_smooth_dark, outdoors, osm_bright, stamen_toner, stamen_terrain
})

Carto — A Spanish-origin analytics-plus-maps SaaS founded in 2012. They also maintain deck.gl. Their core feature is running geospatial analytics inside cloud data warehouses (Snowflake, BigQuery, Databricks, Redshift). Real estate, telecom, and retail location analytics are their strongholds. IPO chatter surfaced in 2024, but as of 2026 they remain private.

Kepler.gl — Uber's geospatial data exploration tool, open-sourced in 2018. Drop in a CSV or GeoJSON and you get instant deck.gl-powered visualization, no code required. Use it directly in the browser at https://kepler.gl, or embed it in Jupyter / Streamlit.

# Using Kepler.gl inside Jupyter
from keplergl import KeplerGl

map_1 = KeplerGl(height=600)
map_1.add_data(data=df, name='taxi')
map_1

Datawrapper — A German-born chart-and-map SaaS. The first choice for choropleth maps at the New York Times, The Guardian, Der Spiegel, and the SBS data-journalism team in Korea. Pricing: free for up to 10,000 chart impressions/month and a Custom tier for major media. Zero lines of code, automatic design consistency, and full accessibility (screen reader friendly).

Datawrapper workflow:
1. Upload CSV or connect Google Sheets
2. Pick a region (Korean provinces, Japanese prefectures, US states, world, ...)
3. Configure colors / legend / tooltip
4. Publish — iframe embed or SVG export

These are the tools journalists and data analysts reach for first when they need to "tell a story with a map."

11. Mapeo — Offline Mapping (Digital Democracy)

Mapeo is the offline mapping tool the nonprofit Digital Democracy has been building since 2018. It was created to help Amazonian indigenous communities map illegal logging, mining, and river contamination in their own territories and to collect evidence.

Core values:

  • Fully offline — works in the jungle, desert, or remote mountains with no Internet
  • P2P sync — exchange data over Wi-Fi Direct and local networks (built on the Hypercore Protocol)
  • Data sovereignty — no cloud, data lives only on user devices
  • iOS / Android / desktop — multi-platform

The stack is Electron + React Native + Hypercore + osm-p2p-db. In 2025 the next generation, Mapeo Next, went into beta — a lighter rewrite on a single React Native codebase.

Typical scenarios:

  • Indigenous territory monitoring in the Amazon, Congo, and Indonesia
  • Human rights monitoring in conflict zones
  • Environmental NGO field data collection
  • Wildlife conservation in areas without connectivity

Mapeo is not a commercial tool, but in the "mapping without Internet" category it is effectively the only credible option. Adjacent OSM tools include OsmAnd (offline OSM viewer), OpenMapKit (offline data collection), and KoBoToolbox (offline surveys).

12. QGIS 3.40 / ArcGIS Pro — Desktop GIS

The two giants of desktop GIS remain QGIS (open source) and ArcGIS Pro (Esri's commercial product).

QGIS 3.40 — The Long-Term Release (LTR) shipped in October 2024. It is still the recommended stable build in 2026, with the next LTR (3.46) planned for late 2026.

Highlights of QGIS 3.40:

  • 800+ processing algorithms (vector / raster / mesh / point cloud)
  • Native support for PostGIS / Oracle Spatial / SQL Server / SpatiaLite
  • Python console + PyQGIS API for full automation
  • 3D viewer (built on Qt 3D)
  • Mobile companions — Mergin Maps, QField
  • Cloud-native data — Cloud Optimized GeoTIFF (COG), STAC, PMTiles directly supported
# PyQGIS example — intersect two layers
from qgis.core import QgsProcessingFeedback
import processing

result = processing.run(
    'native:intersection',
    {
        'INPUT': '/path/to/layer1.gpkg',
        'OVERLAY': '/path/to/layer2.gpkg',
        'OUTPUT': '/path/to/intersection.gpkg',
    },
    feedback=QgsProcessingFeedback(),
)

ArcGIS Pro — Esri's 64-bit next-generation desktop GIS. As of 2026 the current version is 3.5. US/Canadian federal agencies, the military, municipalities, and large enterprises use it as their standard.

QGIS vs ArcGIS Pro:

CriterionQGIS 3.40ArcGIS Pro 3.5
LicenseGPL (free)$700 to $5,000 per year
Processing speedGoodExcellent (very large datasets)
3D / visualizationGoodExcellent
Plugin ecosystem1500+ (open)Esri marketplace
Support / trainingCommunityOfficial Esri
Cloud integrationSTAC, PMTiles, COGArcGIS Online

Students, researchers, and nonprofits standardize on QGIS; government, military, and large enterprise standardize on ArcGIS Pro.

13. Mapillary — Meta's Street View

Mapillary is the open street-view project that launched in Sweden in 2013. Facebook (now Meta) acquired it in June 2020, and the core dataset remains openly licensed under CC BY-SA post-acquisition.

Core value:

  • Anyone can upload imagery from car / bike / foot / helmet cameras
  • AI automatically extracts signs, lane lines, and road furniture
  • OSM mappers feed those signals back into OSM updates
  • API exposes imagery and extracted features for free (with quotas)

In 2026 roughly 3 billion images are on the platform, with especially dense coverage in OSM-active regions of Europe, Japan, and parts of Korea. It is the open alternative to Google Street View — and a training-data source for autonomous-driving companies.

// Embedding the Mapillary JS Viewer
import { Viewer } from 'mapillary-js'
import 'mapillary-js/dist/mapillary.css'

const viewer = new Viewer({
  accessToken: 'YOUR_MAPILLARY_ACCESS_TOKEN',
  container: 'mly-viewer',
  imageId: '498763468214164',
})

The OSM + Mapillary combination is especially valuable where Google Street View is missing or outdated.

14. Korea — Kakao Maps / Naver Maps / TMAP SDK

Google Maps is not number one in Korea. Korean law (the Act on the Establishment, Management, etc. of Spatial Data) restricts the export of high-precision map data, so Google's routing and several other features are limited inside Korea. As a result, Korean services use Kakao, Naver, or TMAP SDKs.

Kakao Maps SDK — Kakao's map API. JS / Android / iOS all supported. Strong at routing, place search, and coordinate transforms. Free up to a quota, then paid. The de facto standard for real estate, restaurant discovery, and delivery services.

<script src="//dapi.kakao.com/v2/maps/sdk.js?appkey=YOUR_KAKAO_KEY"></script>
<script>
  const container = document.getElementById('map')
  const options = {
    center: new kakao.maps.LatLng(37.566, 126.978),
    level: 3,
  }
  const map = new kakao.maps.Map(container, options)
</script>

Naver Maps API — Part of NAVER Cloud Platform. Search, routing, coordinate transforms. Along with Kakao, one of the two Korean heavyweights. Tightly integrated with Naver Real Estate and Naver Place.

TMAP SDK — SK Telecom's flagship navigation product. The top choice for car routing in Korea, especially for real-time traffic. Less about basic map rendering, more about vehicle and transit routing.

Comparison of the Korean trio:

FeatureKakao MapsNaver MapsTMAP
Basic map displayExcellentExcellentGood
POI searchExcellentExcellentGood
Car routingGoodGoodExcellent (top)
Transit routingExcellentExcellentGood
Walking routingExcellentExcellentGood
PricingFree (limited) + paidFree (limited) + paidPaid
Global coverageKorea-centricKorea-centricKorea-centric

Selection is simple:

  • Consumer-facing service — Kakao Maps or Naver Maps (taste + user familiarity)
  • Car routing as the core — TMAP
  • Global + Korea — MapLibre + ProtoMaps globally, delegate Korea to Kakao Maps

For public data, V-World (Ministry of Land, Infrastructure and Transport) provides aerial imagery, administrative boundaries, and cadastral data for free.

15. Japan — GSI Maps / Yahoo Maps / ZENRIN / MapFan

Japan is a different story again. Google Maps is strong but does not dominate. A combination of unique road and address systems and several large domestic players keeps multiple tools in active use.

GSI Maps (Geospatial Information Authority of Japan) — The official map operated by GSI. Free aerial photos for Tokyo's 23 wards, standard tiles, color-blind-friendly tiles, and elevation data. Standard at schools, government, and research institutes. Tile URLs plug straight into MapLibre / Leaflet.

const map = new maplibregl.Map({
  container: 'map',
  style: {
    version: 8,
    sources: {
      gsi: {
        type: 'raster',
        tiles: ['https://cyberjapandata.gsi.go.jp/xyz/std/{z}/{x}/{y}.png'],
        tileSize: 256,
        attribution: 'GSI Tiles',
      },
    },
    layers: [{ id: 'gsi-layer', type: 'raster', source: 'gsi' }],
  },
  center: [139.692, 35.689], // Shinjuku, Tokyo
  zoom: 12,
})

(The z, x, y here are the standard slippy-map tile-coordinate placeholders.)

Yahoo Maps (Japan) — Yahoo Japan's mapping service, with search share rivaling Google Maps within Japan. APIs are part of the YOLP (Yahoo! Open Local Platform).

ZENRIN — Japan's leading address data company. Google Maps Japan licenses ZENRIN's address data (since 2019 Google has been collecting some of its own as well). Hotels, real estate, and insurance — verticals where precise addresses drive revenue — license ZENRIN data directly and embed it into their systems.

MapFan / NAVITIME — Car and transit-routing SaaS. Japan's transit transfers (timetables, service updates) are intricate, which keeps specialist SaaS like NAVITIME competitive.

Selection guidance:

  • Consumer-facing service (restaurants, real estate) — Google Maps Japan or Yahoo Maps
  • Precision addressing drives revenue — license ZENRIN
  • Transit routing — NAVITIME API
  • Public / academic / research — GSI Maps
  • Open + cost-conscious — MapLibre + ProtoMaps, with GSI tiles for select layers

16. Who Should Pick What — General / Analytics / Journalism / Offline

Finally, a per-user-type stack recommendation.

General web/app (markers, basic search):

  • Global — Google Maps Platform (when POI data matters) or MapLibre + ProtoMaps (when cost matters)
  • Korea — Kakao Maps or Naver Maps
  • Japan — Yahoo Maps or Google Maps Japan
  • Minimum dependencies — Leaflet 1.9 + OSM tiles

Large-scale data visualization (1,000+ points, heatmaps, time series):

  • MapLibre + deck.gl 9 (open, free, fastest WebGPU path)
  • Or Mapbox GL JS v3 + deck.gl (when you need Mapbox cartography)
  • End-to-end analytics workflow — Carto (analytics inside Snowflake / BigQuery)

Data journalism / choropleth:

  • Datawrapper (zero code, automatic design, full accessibility) — top pick
  • Felt (interactive + collaborative) — runner-up
  • Observable + d3 + topojson (heavy customization) — third option

Desktop GIS / spatial analytics:

  • QGIS 3.40 LTR (open, free) — top pick for students, researchers, nonprofits, startups
  • ArcGIS Pro — standard for government, military, large enterprise
  • GeoPandas + Jupyter — code-first analytics for data scientists

Routing / directions SaaS:

  • Self-hosted + cost-optimized — OSRM (fastest) or Valhalla (multi-modal)
  • Global SaaS — Mapbox Directions, Google Directions, Stadia Routes, GraphHopper SaaS
  • Korean car routing — TMAP SDK
  • Japan transit — NAVITIME

Offline / no-Internet:

  • Mapeo (Digital Democracy) — human rights monitoring, environmental NGOs, indigenous mapping
  • OsmAnd — general offline OSM viewer
  • OpenMapKit + KoBoToolbox — field surveys + mapping

Street view / streetscape data:

  • Google Street View — general-purpose leader
  • Mapillary (Meta) — open, OSM-integrated
  • Kakao Roadview / Naver Street View — Korea
  • Yahoo Maps imagery — Japan

Self-hosted / cost-optimized:

  • MapLibre GL JS 5 + ProtoMaps PMTiles + Cloudflare R2 — the new 2026 default
  • Cost math: 1 TB/month on R2 is roughly $15, the same traffic on Mapbox is $5,000+

The map tooling of 2026 is richer, cheaper, and freer than five years ago. Mapbox tightening its license ironically grew the MapLibre + ProtoMaps open ecosystem, and deck.gl's WebGPU support raised the ceiling of what is possible in a browser. Pick the right tool for your project and draw your data on top of the 2026 map.

References

Discuss on Twitter • View on GitHub