Chaos and Order

💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

> "A map is not just a visualization, it is the richest data structure on Earth, combining coordinates, time, and metadata. Geospatial in 2026 is no longer the exclusive domain of GIS specialists." — Overture Maps Foundation, 2025 Annual Report

The geospatial stack used to be dominated by three companies — ESRI ArcGIS, Mapbox, and Google Maps — through the early 2020s. But the formation of the Overture Maps consortium in 2022, the rise of Protomaps and PMTiles in 2023, and deck.gl's transition to the Linux Foundation in 2024 have rapidly opened the field. As of May 2026, the modern geospatial stack is a rich ecosystem split into six layers: data sources, rendering, databases, indexes, routing, and geocoding.

This post walks through OpenStreetMap, Overture Maps, Mapbox, Google Maps Platform, MapLibre GL JS, Mapbox GL JS v3, deck.gl, Kepler.gl, Leaflet, OpenLayers, CesiumJS, PostGIS 3.5, DuckDB Spatial, H3, S2, Geohash, OSRM, Valhalla, GraphHopper, pgRouting, Nominatim, Pelias, Photon, PMTiles, MVT, Cesium 3D Tiles, and regional map data from Korea and Japan — all in one place.

1. The 2026 Geospatial Stack — 6 Layers

A geospatial system can be split into six big layers by responsibility.

| Layer | Representative Products | Role |

|---|---|---|

| Data Source | OpenStreetMap, Overture Maps, Mapbox, Google, Apple, HERE, TomTom | Raw road, building, POI data |

| Tile Format | MVT, PMTiles, XYZ, WMTS, Cesium 3D Tiles | Wire format from server to client |

| Tile Server | TileServer GL, MapTiler, Stadia Maps, OpenMapTiles, GeoServer | Hosts and generates tiles |

| Renderer | MapLibre GL JS, Mapbox GL v3, deck.gl, Leaflet, OpenLayers, CesiumJS | Browser rendering library |

| Spatial DB & Index | PostGIS, DuckDB Spatial, SpatiaLite, H3, S2, Geohash | Coordinate-based query, join, aggregation |

| Service | OSRM, Valhalla, Nominatim, pgRouting, Mapbox Directions | Routing, geocoding, matrix services |

Data sources split into **open (OpenStreetMap, Overture Maps)** and **commercial (Google, Apple, HERE, TomTom, Mapbox)**. Renderers split into **2D vector (MapLibre, Mapbox GL)**, **2D raster (Leaflet)**, **WebGL big data (deck.gl, Kepler.gl)**, and **3D globe (CesiumJS)**. The choice usually comes down to three axes: data volume, interactivity, and licensing.

The defining 2026 trend is **escaping vendor lock-in**. After Mapbox GL JS v2 moved from BSD-3 to a proprietary license in 2020, the MapLibre fork became the de facto standard, and PMTiles replaced the entire tile-server infrastructure with a single static file.

2. OpenStreetMap — The Root of All Open Maps

OpenStreetMap (OSM, `openstreetmap.org`) was started in 2004 by Steve Coast as a wiki-style map database. As of 2026 it has over 11 million registered mappers and more than 10 billion nodes. The license is ODbL (Open Database License) — data is free to use, but share-alike means derivative datasets must also be ODbL.

The core data model has just three primitives:

- **Node**: a single lat/lon point (e.g., a cafe location)

- **Way**: an ordered list of nodes (road, building outline)

- **Relation**: a group of nodes and ways (subway line, administrative boundary)

Each object carries key-value tags. A road has `highway=primary`, a building has `building=residential`, a cafe has `amenity=cafe`. The tag schema is free-form with tens of thousands of keys, but knowing the core 200 unlocks most queries.

There are three ways to consume OSM data. Download the full **planet.osm** (about 1.5 TB raw, 90 GB compressed pbf). Grab country or regional extracts from **Geofabrik** (`download.geofabrik.de`). Or query the **Overpass API** (`overpass-api.de`) for ad-hoc data. Large-scale analytics typically import a pbf into PostGIS and query with SQL.

OSM's weakness is uneven data quality. Major cities like Seoul, Tokyo, and London are nearly perfect, but smaller Korean cities or parts of Southeast Asia often lack road names. Commercial services therefore augment OSM with Overture Maps or Mapbox.

3. Overture Maps — A Big Tech Open Map Consortium

Overture Maps (`overturemaps.org`) launched in December 2022 as a Linux Foundation project founded by AWS, Microsoft, Meta, and TomTom, with Esri joining in 2023. The goal is "OSM's freedom plus commercial-grade quality equals fully open foundational map data." Since the first GA release in April 2024, new versions ship quarterly, and v2026.04.30 is the latest as of May 2026.

Overture organizes data into five themes:

- **Places**: ~50 million POIs (restaurants, shops, public facilities)

- **Buildings**: ~2.8 billion building footprints worldwide

- **Transportation**: road and rail networks (OSM-based plus augmentation)

- **Base**: administrative boundaries, land cover, infrastructure

- **Addresses**: address data (added in 2024)

The format is **GeoParquet** — Apache Parquet with a geospatial extension. Distributed query engines (DuckDB, BigQuery, Athena) can query directly, and files hosted on S3 support partial reads, making petabyte-scale data tractable.

-- Query Overture Maps Places directly with DuckDB (no download)

INSTALL spatial;

INSTALL httpfs;

LOAD spatial;

LOAD httpfs;

SELECT

names.primary AS name,

categories.primary AS category,

ST_AsText(geometry) AS location

FROM read_parquet('s3://overturemaps-us-west-2/release/2026-04-30.0/theme=places/type=place/*')

WHERE bbox.xmin BETWEEN -122.5 AND -122.3

AND bbox.ymin BETWEEN 37.7 AND 37.8

AND categories.primary = 'restaurant'

LIMIT 100;

Overture's biggest contribution is **GERS (Global Entity Reference System)** — a permanent ID system that lets you link OSM, commercial data, and Wikipedia entries for the same entity. In 2026, commercial players like Kakao Mobility, Mapbox, and Esri have started attaching GERS IDs to their own data.

4. Mapbox vs Google Maps Platform — The Commercial Duopoly

The commercial map market is effectively a duopoly between Mapbox and Google Maps Platform. The 2026 pricing and feature differences look like this.

| Item | Mapbox | Google Maps Platform |

|---|---|---|

| Free tier | 50K map loads / month | $200 credit / month (about 28,500 loads) |

| Per 1,000 loads | $0.50 | $7 (Dynamic Maps) |

| Style customization | 100% via Studio | Partial via cloud-based styles |

| Offline | Mapbox SDK only | Limited |

| Satellite | Mapbox Satellite | Google Satellite (Photorealistic 3D) |

| Routing | Directions API | Routes API |

| Geocoding | Geocoding API | Geocoding API |

| Autonomous-driving data | Mapbox AVS | Google HD Maps |

**Mapbox** (`mapbox.com`) was founded in 2010 and switched GL JS v2 to a proprietary license in 2020, but its data catalog and Studio design tool remain best in class. Mapbox GL JS v3 shipped in 2024 with 3D terrain, lighting, and model imports, and v3.10 in 2025 added direct PMTiles and deck.gl integration.

**Google Maps Platform** (`mapsplatform.google.com`) is more expensive but ships strong differentiators like Street View. Their **Photorealistic 3D Tiles** released in 2024 follow the Cesium 3D Tiles standard, so they render in CesiumJS, deck.gl, or MapLibre.

Both vendors have raised prices repeatedly since 2024, driving rapid adoption of self-hosted **PMTiles + MapLibre + Overture** stacks.

5. MapLibre GL JS — The Open Standard Forked from Mapbox

MapLibre GL JS (`maplibre.org`) was forked in December 2020 from the last BSD-3 version of Mapbox GL JS (v1.13). As of 2026 it sits at v5.0.0, with AWS, Meta, Microsoft, Stadia, and MapTiler as core sponsors.

The API is nearly identical to Mapbox GL JS, so migration is trivial. Change `import mapboxgl from 'mapbox-gl'` to `import maplibregl from 'maplibre-gl'`, swap commercial Mapbox style and tile URLs for self-hosted or open alternatives, and you are done.

const map = new maplibregl.Map({

container: 'map',

style: 'https://api.maptiler.com/maps/streets-v2/style.json?key=YOUR_KEY',

center: [126.9780, 37.5665], // Seoul City Hall LngLat

zoom: 12,

pitch: 45,

bearing: -17.6,

})

// Add 3D building layer

map.on('load', () => {

map.addLayer({

id: '3d-buildings',

source: 'openmaptiles',

'source-layer': 'building',

type: 'fill-extrusion',

minzoom: 14,

paint: {

'fill-extrusion-color': '#aaa',

'fill-extrusion-height': ['get', 'render_height'],

'fill-extrusion-base': ['get', 'render_min_height'],

'fill-extrusion-opacity': 0.8,

})

MapLibre's strengths are **fully open source, no API key required, self-hostable, and Mapbox-GL compatible**. The weaknesses are **lack of a Studio-equivalent design tool** and **mobile Native SDKs that trail Mapbox**. MapLibre Native v11 released in 2025 narrowed the iOS/Android gap considerably.

6. Mapbox GL JS v3 — 3D Lighting and Model Imports

Mapbox GL JS v3 was a major update announced in September 2023. It pushes beyond simple 2D vector maps into game-engine-class 3D rendering. As of May 2026, v3.10 is the latest.

Key new features:

- **Mapbox Standard style**: a basemap that adapts to time of day and weather

- **Dynamic Lighting**: shadows and lighting based on sun position and time

- **3D Models**: place glTF/glb assets on the map (3D POI markers)

- **Globe Projection**: automatic globe view when zoomed out

- **Atmospheric Effects**: fog, aerial perspective, stars

- **Custom Layers (WebGL/WebGPU)**: embed deck.gl or Three.js code directly

Pricing is unchanged from v2 — 50K free monthly loads, $0.50 per 1,000 after. But the Mapbox Standard style carries telemetry that prevents self-hosting.

The choice between MapLibre and Mapbox GL v3 is clear. **Low traffic, design freedom matters** → Mapbox. **High traffic or self-hosting matters** → MapLibre. Visual-effects-heavy apps like games or AR favor Mapbox; infrastructure-heavy work favors MapLibre.

7. deck.gl — WebGL Visualization at Scale

deck.gl (`deck.gl`) was open-sourced by Uber in 2016 and moved to the Linux Foundation in 2022. As of May 2026 the latest is v9.1. Its core strength is **rendering hundreds of millions of points at 60fps** using GPU-optimized code paths.

The central concept is **Layer** — 80+ built-in layers like `ScatterplotLayer`, `LineLayer`, `HexagonLayer`, `GridLayer`, `H3HexagonLayer`, `TripsLayer`, `Tile3DLayer`, all GPU-accelerated. Unlike other map libraries, deck.gl does not draw a basemap on its own. It overlays on top of MapLibre, Mapbox, or Google Maps.

// Visualize 1M points with deck.gl + MapLibre

const map = new maplibregl.Map({

container: 'map',

style: 'https://demotiles.maplibre.org/style.json',

center: [-122.4194, 37.7749],

zoom: 11,

})

const deck = new Deck({

canvas: 'deck-canvas',

initialViewState: {

longitude: -122.4194,

latitude: 37.7749,

zoom: 11,

pitch: 30,

controller: true,

layers: [

new ScatterplotLayer({

id: 'taxi-pickups',

data: 'https://example.com/taxi-1m.json',

getPosition: (d) => [d.lon, d.lat],

getRadius: 50,

getFillColor: [255, 140, 0, 180],

pickable: true,

}),

})

Another deck.gl strength is **React integration** (`@deck.gl/react`) and **Jupyter integration** (`pydeck`). Data scientists prototype in Python and ship the same artifact to the web. The WebGPU backend added in 2024 is 2-3x faster than the WebGL path.

8. Kepler.gl — No-Code UI on Top of deck.gl

Kepler.gl (`kepler.gl`) is a no-code geospatial analytics tool released by Uber in 2018, built as a React application on top of deck.gl. As of 2026 it sits at v3.1, allowing analysts to drag-and-drop data into visualizations without writing code.

Supported formats include CSV, JSON, GeoJSON, Shapefile, KML, Arrow, and GeoParquet — virtually every standard. Once you upload, Kepler infers column types and suggests appropriate layer types (Point, Heatmap, Hexbin, Arc, Line, Polygon).

The killer feature is **time animation**. Upload data with timestamps and you get an automatic timeline UI that plays change over time like a video. It is the de facto standard for traffic, disaster, and epidemiology data analysis.

Kepler can be self-hosted (`@kepler.gl/react` embeds in any React app) and Uber operates a free hosted instance at `kepler.gl/demo`. The hosted version keeps data entirely in the browser and never uploads it, which makes it safe for sensitive data.

9. Leaflet — The Simplest, Longest-Lived Web Map

Leaflet (`leafletjs.com`) was created by Vladimir Agafonkin in 2011 and remains at v1.9.4 in 2026. It has barely changed in 15 years, and its simplicity and reliability keep it broadly used.

Leaflet is designed around **raster tiles** (XYZ, TMS, WMTS). Vector tile support exists via plugins like `leaflet.vectorgrid` but is not first-class — for high-zoom or dynamic styling, MapLibre is the right choice.

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

L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {

attribution: 'OpenStreetMap',

}).addTo(map)

L.marker([37.5665, 126.9780])

.addTo(map)

.bindPopup('Seoul City Hall')

.openPopup()

Leaflet's strengths are a **~40KB bundle**, **dead-simple API**, and **a rich ecosystem of 1,200+ plugins**. The downside is no GPU acceleration, so performance falls off above 10K points. Government, public sector, and small business maps still default to Leaflet.

10. OpenLayers — Enterprise OGC Standards Support

OpenLayers (`openlayers.org`) was started by MetaCarta in 2006 and is at v10.5 in 2026. It is heavier than Leaflet (~250KB) but supports the widest swath of OGC (Open Geospatial Consortium) standards, making it the de facto choice for government, public sector, and enterprise GIS.

Supported formats include WMS, WMTS, WFS, WCS, XYZ, TMS, GeoJSON, TopoJSON, KML, GML, GPX, MVT — essentially every geospatial standard. Coordinate systems can be transformed freely by EPSG code (with `proj4js` bundled in).

const map = new Map({

target: 'map',

layers: [

new TileLayer({ source: new OSM() }),

new TileLayer({

source: new TileWMS({

url: 'https://www.gis.go.kr/wms',

params: { LAYERS: 'cadastral', TILED: true },

}),

view: new View({

center: fromLonLat([126.9780, 37.5665]),

zoom: 14,

projection: 'EPSG:3857',

}),

})

OpenLayers pairs naturally with OGC servers like GeoServer and MapServer. Korean V-World, Japanese GSI, and European INSPIRE portals are nearly all OpenLayers + GeoServer.

11. CesiumJS — 3D Globes and Earth Visualization

CesiumJS (`cesium.com/platform/cesiumjs`) is a 3D Earth visualization library originally built by AGI in 2011, at v1.130 as of 2026. It is the standard for NASA, aerospace, autonomous flight, and digital twins.

The cornerstone is **Cesium 3D Tiles** — a 3D geospatial format proposed by Cesium in 2017 and adopted as an OGC standard in 2019. It streams entire city 3D buildings, point clouds, and meshes with LoD (Level of Detail). Google Photorealistic 3D Tiles, Bentley, and Esri ArcGIS all follow this format.

const viewer = new Viewer('cesiumContainer', {

terrainProvider: await createWorldTerrainAsync(),

})

// Load Google Photorealistic 3D Tiles

const tileset = await viewer.scene.primitives.add(

await Cesium3DTileset.fromIonAssetId(2275207)

)

viewer.camera.flyTo({

destination: Cartesian3.fromDegrees(139.7670, 35.6814, 1500),

})

CesiumJS does not draw a basemap directly. It relies on Cesium ion (`cesium.com/ion`) or self-hosted 3D Tiles servers. There is a free tier but heavy use is expensive, so self-hosting is the norm. The digital-twin market has grown rapidly since 2025, pushing CesiumJS adoption up sharply.

12. PostGIS 3.5 — The Spatial Database Standard

PostGIS (`postgis.net`) is a PostgreSQL spatial extension created by Refractions Research in 1998, at v3.5 in May 2026. It is **the de facto spatial DB** — Mapbox, Foursquare, Kakao Mobility, and Uber all use PostGIS somewhere in their stack.

PostGIS follows the OGC SQL/MM standard, so function names are standardized across vendors. Key functions:

-- 1) Distance between two points in meters (EPSG:4326)

SELECT ST_Distance(

ST_GeographyFromText('POINT(126.978 37.5665)'), -- Seoul City Hall

ST_GeographyFromText('POINT(139.767 35.6814)') -- Tokyo Station

); -- ~1,158,300 meters

-- 2) Points inside a polygon

SELECT * FROM poi

WHERE ST_Within(

geom,

ST_MakeEnvelope(126.9, 37.5, 127.1, 37.6, 4326)

);

-- 3) Nearest N (KNN index)

SELECT name, ST_Distance(geom, target) AS distance

FROM cafes

ORDER BY geom <-> ST_GeomFromText('POINT(126.978 37.5665)', 4326)

LIMIT 10;

-- 4) Clustering (DBSCAN)

SELECT

ST_ClusterDBSCAN(geom, eps := 100, minpoints := 5) OVER () AS cluster_id,

name

FROM incidents;

PostGIS's power comes from **GIST indexes** — an R-tree variant that brings spatial queries to O(log n). A one-line `CREATE INDEX idx_geom ON poi USING GIST (geom)` makes spatial queries on a million-row table run in under 1 ms.

New in 3.5: **vector tile generation** (`ST_AsMVT`), **cloud-optimized rasters**, and **GeoParquet read/write**. You can produce MVT tiles directly from the database and stream them to clients without a separate tile server.

13. DuckDB Spatial — Embedded Analytics Spatial DB

DuckDB Spatial (`duckdb.org/docs/extensions/spatial`) is a DuckDB extension released in 2023, and as of 2026 v1.4 it is the fastest-growing GIS tool. It supports nearly all OGC functions PostGIS does, with the differentiation of **single-file embedded operation plus direct Parquet/GeoParquet queries**.

The killer use case is **querying massive GeoParquet datasets like Overture Maps without downloading**.

-- DuckDB joins Overture Maps with your own data, both directly from S3

INSTALL spatial;

INSTALL httpfs;

LOAD spatial;

LOAD httpfs;

WITH my_stores AS (

SELECT id, name, lon, lat

FROM read_csv('s3://my-bucket/stores.csv')

nearby_places AS (

SELECT

s.id AS store_id,

p.names.primary AS poi_name,

p.categories.primary AS category,

ST_Distance_Sphere(

ST_Point(s.lon, s.lat),

ST_GeomFromWKB(p.geometry)

) AS distance_m

FROM my_stores s,

read_parquet('s3://overturemaps-us-west-2/release/2026-04-30.0/theme=places/*') p

WHERE p.bbox.xmin BETWEEN s.lon - 0.01 AND s.lon + 0.01

AND p.bbox.ymin BETWEEN s.lat - 0.01 AND s.lat + 0.01

)

SELECT * FROM nearby_places WHERE distance_m < 500;

DuckDB Spatial is **the data scientist's PostGIS** — petabyte-scale queries on a laptop. Use PostGIS when you need transactions and real-time updates, DuckDB for batch analytics.

14. H3 — Uber's Hexagonal Spatial Index

H3 (`h3geo.org`) is Uber's hierarchical hexagonal spatial index, open-sourced in 2018. It starts with 122 equilateral triangles plus hexagons across the Earth's surface and recursively subdivides through 16 resolutions. The latest is H3 v4.2, and essentially every mobility and logistics company uses it.

H3's key advantage is **near-uniform area and distance between cells** — neighboring cell centers are equidistant, which keeps averages and aggregations clean. Unlike square grids, hexagons have six equidistant neighbors, which suits flow analysis too.

Each H3 cell is a 64-bit integer that encodes both resolution (0-15) and location. Average area per resolution:

|---|---|---|---|

| 0 | 4.25M km² | 1,107 km | Continent-scale |

| 5 | 252 km² | 8.5 km | Metro area |

| 7 | 5.16 km² | 1.2 km | Neighborhood |

| 9 | 0.105 km² | 174 m | City block |

| 11 | 2,150 m² | 25 m | Building |

| 15 | 0.9 m² | 0.5 m | Pixel |

// 1) lat/lng → H3 cell ID (resolution 9, ~150m hexagons)

const seoulCityHall = latLngToCell(37.5665, 126.9780, 9)

// → '8930e0a0107ffff'

// 2) Cell boundary (for drawing on a map)

const boundary = cellToBoundary(seoulCityHall)

// → [[lat, lng], ...] 6 vertices

// 3) 1-ring neighbors (6 cells around)

const neighbors = gridDisk(seoulCityHall, 1)

// 4) Area in m²

const area = cellArea(seoulCityHall, 'm2')

H3's real value is **aggregation efficiency**. Aggregating 1M GPS points by hexagon is a single `GROUP BY h3_cell`, and zooming out is a one-step resolution coarsening. Uber's ETA computation, Foursquare's visit frequency analysis, and Kakao Mobility's demand forecasting all run on H3.

15. S2 — Google's Quadtree-Based Spatial Index

S2 (`s2geometry.io`) is Google's spatial index system, open-sourced in 2017. It projects the Earth onto a cube and recursively subdivides each face with a quadtree. Google Maps, Google Earth, and Niantic's Pokemon GO and Ingress all run on S2.

S2 vs H3 comparison:

| Property | S2 | H3 |

|---|---|---|

| Shape | Square (quadtree) | Hexagon |

| Resolution levels | 30 (0-30) | 16 (0-15) |

| Cell size variance | Varies with latitude | Nearly uniform |

| ID | 64-bit integer | 64-bit integer |

| Hilbert curve sorted | Yes | No |

| Neighbor count | 4 | 6 |

S2's key strength is **Hilbert-curve-ordered IDs** — adjacent IDs are spatially adjacent cells, which makes database range queries (`WHERE s2_id BETWEEN x AND y`) efficient. H3 lacks this guarantee and needs an R-tree.

Pick S2 when you need integer-coded coordinates (games), or when Google Maps interop matters. Most analytics workloads have richer use cases on H3.

16. Routing Engines — OSRM, Valhalla, GraphHopper, pgRouting

Routing solves "shortest path A to B," but on road graphs with hundreds of millions of nodes, real-time computation requires preprocessing and custom algorithms. The major 2026 open-source routing engines:

|---|---|---|---|

| OSRM | C++ | Contraction Hierarchies, fastest (1 ms) | BSD-2 |

| Valhalla | C++ | Multimodal (walk/bike/car), dynamic options | MIT |

**OSRM** (`project-osrm.org`) is the fastest engine, using Contraction Hierarchies (CH) to route across the world in under 1 ms. The downside is sparse options — custom toll avoidance or time-of-day traffic is hard.

**Valhalla** (`valhalla.github.io`) was built by Mapbox in 2015, acquired by Mapzen in 2021, and moved back to the open-source community in 2024. It models walk, bike, and drive on one graph and supports request-time options (avoid roads, time-weighted costs), which is why mobility companies favor it.

**pgRouting** (`pgrouting.org`) runs inside PostGIS over SQL. It is not the fastest, but you can attach routing directly to your own road data via SQL, which is invaluable inside enterprise logistics systems.

-- pgRouting Dijkstra between two nodes

SELECT * FROM pgr_dijkstra(

'SELECT id, source, target, cost FROM road_segments',

source_node := 1234,

target_node := 5678,

directed := true

);

17. Geocoding — Nominatim, Pelias, Photon

Geocoding converts "address → coordinates" or coordinates back to an address (reverse geocoding). Commercial APIs (Google, Mapbox) are expensive, so self-hosting is common.

**Nominatim** (`nominatim.org`) is OSM's official geocoder, using PostGIS-backed full-text search. It is simple and stable but search quality is modest — full strings like "Gangnam Station Line 2" work better than just "Gangnam Station."

**Pelias** (`pelias.io`) is a modular geocoder built by Mapzen and open-sourced in 2018. It blends OSM, Overture Maps, Geonames, and WhosOnFirst. Elasticsearch-backed, with the best search quality but a heavier infrastructure footprint.

**Photon** (`photon.komoot.io`) is Komoot's OSM-based geocoder using Elasticsearch with Java and Lucene. Faster than Nominatim with better results, so indie devs favor it.

// Geocode against the public Photon instance

const res = await fetch(

'https://photon.komoot.io/api/?q=Seoul City Hall&limit=5&lang=en'

)

const json = await res.json()

// json.features is a GeoJSON FeatureCollection

Quality gap vs commercial APIs is real. Mapbox Geocoding handles synonyms, typos, and multilingual queries well, while Google Geocoding excels at business locations. Use commercial if accuracy matters; Photon when cost matters.

18. Tile Formats — MVT, PMTiles, XYZ, WMTS

Tile formats define how data ships from server to client. The major 2026 formats:

**MVT (Mapbox Vector Tile)** was introduced by Mapbox in 2014 and adopted as an OGC standard in 2017. It uses Protocol Buffers and a z/x/y directory layout. Clients request tiles at the right zoom and the GPU renders every object inside.

**PMTiles** (`protomaps.com/docs/pmtiles`) is a single-file tile format created by Brandon Liu at Protomaps in 2022. Instead of millions of files in directories, it packs every tile into one large file and uses HTTP Range Requests to read only what is needed. The result is **a global map with no tile server, hosted as a static file on S3, R2, or GCS**.

// PMTiles + MapLibre — a global map with no tile server

const protocol = new Protocol()

maplibregl.addProtocol('pmtiles', protocol.tile)

const map = new maplibregl.Map({

container: 'map',

style: {

version: 8,

sources: {

protomaps: {

type: 'vector',

url: 'pmtiles://https://example.com/planet.pmtiles',

layers: [/* ... */],

})

**XYZ/TMS** are the oldest raster tile formats, with the `{z}/{x}/{y}.png` URL pattern. **WMTS** is the OGC standard for raster tile protocols and is common in government GIS portals.

The 2026 trend is **rapid PMTiles adoption** — Protomaps publishes the entire world's OSM data as a single ~100 GB PMTiles file, and Overture Maps now ships PMTiles distributions too.

19. Protomaps — PMTiles and an Open Global Map

Protomaps (`protomaps.com`) is an open-source project started by Brandon Liu in 2022 and is the inventor of the PMTiles format. By 2026 PMTiles is effectively the next-gen tile standard.

Protomaps' core proposition is **hosting a global map without a tile server**. The traditional pipeline `OSM → PostGIS → tilemaker → TileServer GL → CDN` becomes `OSM → planetiler → planet.pmtiles → S3/R2`. Costs that were thousands of dollars per month drop to tens.

Protomaps offers **free hosted global PMTiles** at `protomaps.com/builds`. It rebuilds OSM weekly into a ~100 GB PMTiles on R2 that anyone can download or reference directly by URL.

Another Protomaps strength is **Basemaps designs** at `protomaps.com/basemaps`. It ships eight base styles (light, dark, white, grayscale, black, naturalist, etc.) that can be customized via a single JSON.

20. Korean Maps — V-World, Naver Maps, Kakao Maps

Korea restricts export of maps at scales of 1:5,000 or higher for national security reasons, which leaves Google Maps and Mapbox with sparse Korean data. Instead, MOLIT's V-World and Naver/Kakao Maps are de facto standards.

**V-World** (`vworld.kr`) is a free public map platform operated by Korea's Ministry of Land, Infrastructure and Transport. It serves aerial imagery, cadastral maps, administrative boundaries, and the new-address system over OGC standards (WMS, WFS, WMTS). One million requests per day are free; beyond that, apply for free quotas.

**Naver Maps API** (`navermaps.github.io`) is Naver's map SDK with JS, iOS, Android, and REST support. After the free quota the per-unit pricing is 30-50% cheaper than Google, and Korean POI quality is the best in the country.

**Kakao Maps API** (`apis.map.kakao.com`) is Kakao's map SDK with JS, iOS, Android, and REST. Kakao Mobility data makes road and traffic information particularly strong, and the routing APIs are extensive.

// Naver Maps JS v3 — Seoul City Hall marker

ncpClientId = 'YOUR_CLIENT_ID'

const map = new naver.maps.Map('map', {

center: new naver.maps.LatLng(37.5665, 126.9780),

zoom: 14,

})

new naver.maps.Marker({

position: new naver.maps.LatLng(37.5665, 126.9780),

map,

title: 'Seoul City Hall',

})

Strengths and weaknesses summary:

|---|---|---|---|

For Korean services, **back office / public = V-World, consumer apps = Naver/Kakao**. For global apps, **Mapbox/MapLibre + Overture Maps** is the usual answer.

21. Japanese Maps — GSI, Yahoo, ZENRIN, MIERUNE

Japan does not restrict map exports, so Google Maps and Apple Maps data quality is excellent, but the public-data and self-built solution ecosystem is still active.

**GSI (Geospatial Information Authority of Japan)** (`gsi.go.jp`, `cyberjapandata.gsi.go.jp`) is the public map service of Japan's Geospatial Information Authority. It offers topographic maps, aerial imagery, elevation, and volcanic activity data as WMTS/XYZ tiles for free. Commercial use is allowed with attribution.

**Yahoo!Japan Maps API** (`developer.yahoo.co.jp/webapi/map`) is Yahoo Japan's map SDK. Japanese POI quality is high and 50K requests per day are free.

**ZENRIN** (`zenrin.co.jp`) is Japan's largest map data company and the data provider for essentially every Japanese automotive navigation system. Commercial licensing is required, but data quality is unmatched within Japan.

**MIERUNE** (`mierune.co.jp`) is a Hokkaido-based open GIS company that ships MapLibre, PMTiles, and OSM-based solutions. Their Japanese language support is strong, and they open-source GSI data integration tools.

// GSI standard map + MapLibre

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 Japan',

layers: [{ id: 'gsi', type: 'raster', source: 'gsi' }],

center: [139.7670, 35.6814],

zoom: 12,

})

For Japanese services, the typical split is **public = GSI, consumer = Yahoo/Google/Apple, automotive = ZENRIN**.

22. Use Cases — Logistics, Delivery, Real Estate, Autonomous Driving

How does the geospatial stack actually compose in real industries?

**Logistics and delivery**: Coupang, Uber Eats, and DoorDash typically run road data = OSM with internal augmentation, routing = self-hosted Valhalla, visualization = MapLibre + deck.gl, spatial DB = PostGIS, ETA prediction = H3-cell-level ML, and rider/driver matching = S2 or H3 neighbor search.

**Real estate**: Zillow, Redfin, Zigbang, and Dabang typically use basemap = Mapbox or self-hosted PMTiles, POIs = Overture plus their own crawls, walking distance = OSRM, listing clustering = deck.gl HexagonLayer, and spatial search = PostGIS + GIST index.

**Autonomous driving**: Tesla, Waymo, and Cruise build their own HD Maps but use OpenStreetMap plus their fleet's mapping data as the baseline. In-vehicle visualization is typically a custom engine, but back-office systems run CesiumJS + 3D Tiles. HERE Technologies and TomTom dominate the autonomous HD Map market.

**Urban planning and digital twins**: Singapore's Virtual Singapore, Dubai's Smart Dubai, and Seoul's Digital Twin all combine CesiumJS + Cesium 3D Tiles + custom BIM data, running infrastructure simulation, solar irradiance analysis, and traffic simulation on one platform.

**Emergency services**: US 911 and Korean 119 are GIS-heavy. They combine ESRI ArcGIS Pro + custom road data + real-time communications to dispatch nearest resources via H3 or pgRouting from the incident location.

23. Coordinate Systems and Projections — EPSG:4326 vs 3857 vs 5179

The most common geospatial pitfall is **coordinate-system confusion**. The same place has completely different numbers depending on the CRS.

**EPSG:4326 (WGS84)** is the GPS standard, expressing lat/lng in degrees. (Seoul City Hall ≈ 126.978°E, 37.566°N). All GeoJSON and OSM source data are in 4326.

**EPSG:3857 (Web Mercator)** is the planar projection Google Maps introduced, with X/Y in meters. (Seoul City Hall ≈ 14,135,830 m, 4,517,790 m). Nearly all web tiles are rendered in 3857, so client-side distance calculations often use it.

**EPSG:5179 (Korea 2000 / Unified TM)** is Korea's standard CRS, used by public GIS like V-World. Distance distortion in the Korean region is small, which suits surveying and cadastral data.

**EPSG:6668 (JGD2011)** is Japan's standard geodetic system used by Japan's GSI. **EPSG:4612 (JGD2000)** is also common in Japan.

Conversion uses PostGIS `ST_Transform(geom, target_srid)` or JavaScript `proj4js`.

-- EPSG:5179 (Korea TM) → EPSG:4326 (WGS84) conversion

SELECT

ST_AsText(ST_Transform(geom, 4326)) AS lonlat,

ST_AsText(geom) AS tm_5179

FROM cadastral

LIMIT 5;

24. Migration Scenario — Escaping Mapbox

Since 2024, migrations from Mapbox to self-hosted or MapLibre have surged. The typical steps:

**Step 1: Swap the SDK** — replace the `mapbox-gl` package with `maplibre-gl`. API compatibility is 95%+, so most projects only need to change import statements.

**Step 2: Replace styles** — swap the official Mapbox styles (`mapbox://styles/mapbox/streets-v12`) for alternatives from MapTiler, Stadia, or Protomaps. Design your own with `maputnik.github.io` if needed.

**Step 3: Host your tiles** — replace Mapbox-hosted tiles with self-hosted PMTiles. Build PMTiles from OSM with `planetiler` (~3 hours) and upload to R2 or S3.

**Step 4: Replace ancillary APIs** — Mapbox Geocoding → Photon or Pelias, Mapbox Directions → OSRM or Valhalla, Mapbox Static Images → your own server or MapTiler.

The cost impact is dramatic. At 1M loads per month, Mapbox costs about $475 (50K free + 950K × $0.50 per 1,000), while R2/S3 + Cloudflare hosting costs $5-20 a month. The trade-off is more in-house infrastructure work.

25. Wrap-up — Picking a 2026 Geospatial Stack

In one line, the 2026 geospatial stack is **open-source ascendant, with single-file PMTiles going mainstream**. The Mapbox-monopoly era is over, and Overture Maps + MapLibre + Protomaps + PostGIS together cover nearly every use case at near-zero cost.

A selection guide:

| Scenario | Recommended Stack |

|---|---|

| Small web map (low traffic) | Leaflet + public OSM tiles |

| Modern vector web map | MapLibre + MapTiler/Stadia + custom style |

| Large-scale data viz | MapLibre + deck.gl + H3 aggregation |

| 3D city / digital twin | CesiumJS + Cesium 3D Tiles |

| Self-hosted global map | Protomaps PMTiles + R2/S3 |

| Government / public GIS | OpenLayers + GeoServer + WMS/WFS |

| Korean services | Naver/Kakao Maps + V-World augmentation |

| Japanese services | GSI + Yahoo/Mapbox + ZENRIN |

| Data analytics | DuckDB Spatial + Overture Parquet |

| Operational DB | PostGIS + H3 index column |

The final reminder: **do not forget data licensing**. OSM is ODbL share-alike, Mapbox has its own license, Google's ToS forbids caching. License violations can shut down your service, so always run legal review before launching a product.

26. References

- OpenStreetMap — `https://www.openstreetmap.org`

- OSM Wiki Map Features — `https://wiki.openstreetmap.org/wiki/Map_features`

- Overture Maps Foundation — `https://overturemaps.org`

- Overture Maps Documentation — `https://docs.overturemaps.org`

- Mapbox — `https://www.mapbox.com`

- Mapbox GL JS — `https://docs.mapbox.com/mapbox-gl-js`

- Google Maps Platform — `https://mapsplatform.google.com`

- Google Photorealistic 3D Tiles — `https://developers.google.com/maps/documentation/tile/3d-tiles`

- MapLibre — `https://maplibre.org`

- MapLibre GL JS — `https://maplibre.org/maplibre-gl-js`

- deck.gl — `https://deck.gl`

- Kepler.gl — `https://kepler.gl`

- Leaflet — `https://leafletjs.com`

- OpenLayers — `https://openlayers.org`

- CesiumJS — `https://cesium.com/platform/cesiumjs`

- Cesium 3D Tiles — `https://github.com/CesiumGS/3d-tiles`

- PostGIS — `https://postgis.net`

- DuckDB Spatial — `https://duckdb.org/docs/extensions/spatial`

- H3 Geo — `https://h3geo.org`

- S2 Geometry — `https://s2geometry.io`

- OSRM — `https://project-osrm.org`

- Valhalla — `https://valhalla.github.io`

- GraphHopper — `https://www.graphhopper.com`

- pgRouting — `https://pgrouting.org`

- Nominatim — `https://nominatim.org`

- Pelias — `https://pelias.io`

- Photon — `https://photon.komoot.io`

- Protomaps — `https://protomaps.com`

- PMTiles — `https://docs.protomaps.com/pmtiles`

- MapTiler — `https://www.maptiler.com`

- Stadia Maps — `https://stadiamaps.com`

- V-World — `https://www.vworld.kr`

- Naver Maps API — `https://navermaps.github.io`

- Kakao Maps API — `https://apis.map.kakao.com`

- GSI Japan — `https://www.gsi.go.jp`

- Yahoo!Japan Maps API — `https://developer.yahoo.co.jp/webapi/map`

- ZENRIN — `https://www.zenrin.co.jp`

- MIERUNE — `https://www.mierune.co.jp`