The map on openstreetmap.org is made of pictures: square raster images, rendered on a server, that your browser tiles into a world. Vector tiles invert that arrangement. The server ships data, geometries and attributes clipped into the same squares, and your device draws the map itself, following a style document that says roads are this wide, water is this blue, labels bend along rivers. That inversion is why a vector map can rotate smoothly, restyle itself into a night mode instantly, and relabel itself in another language without a single new image. This guide explains the system end to end: the tile, the specification, the style, the renderers that draw it, the generators that produce it from OpenStreetMap data, and what it costs.
Home / GIS and Open Map Data for Beginners
OpenStreetMap Vector Tiles: Data Tiles, a Separate Style, and Client Rendering

Photo: Alicia Christin Gerald / Pexels
Data Plus Style: The Vector Tile Checklist
Check off each step as you finish it. Your progress stays on this page.
0 of 7 complete
0% done
Raster Against Vector: Two Ways to Ship a Map
| Raster tiles | Vector tiles | |
|---|---|---|
| What crosses the network | Finished images (PNG) | Geometry and attribute data (MVT) |
| Who draws the map | The server, once, for everyone | The client, on every device |
| Restyling | Requires re-rendering every image | Swap the style document |
| Rotation and tilt | Awkward, images are flat | Natural, geometry is real |
| Labels in another language | Baked into the image | Drawn from name data at view time |
| Device demand | Minimal | A capable GPU and modern browser or app |
Neither is obsolete. Raster tiles are simple, cache beautifully, and work on anything; OpenStreetMap's own tile servers, the subject of our tile server guide, still serve them worldwide. Vector tiles win where interaction matters: smooth zoom that never blurs, styles that adapt, maps that respond. Most modern map apps you have used recently are vector under the glass, whether or not they say so.
The MVT Specification: One Format Underneath
The industry converged on the Mapbox Vector Tile specification, an open spec whose version 2.1 was released on January 19, 2016, and which remains the reference the ecosystem implements. An MVT tile encodes layers (roads, water, buildings, places), each holding features with geometries drawn in a local tile coordinate grid and attributes carried as key-value pairs. The encoding uses Protocol Buffers, which is why vector tiles carry the .pbf extension, a pure coincidence of plumbing: an MVT .pbf and an .osm.pbf share an encoding library and nothing else, as our PBF format guide explains. Because the spec is open and stable, tiles from one generator render in another vendor's library, and a style written for one source can often be retargeted to another. That interoperability, more than any single product, is why vector won.
The Style Document: The Map's Other Half
A vector tile by itself has no look at all. The style document, a JSON file in the Mapbox Style Specification family, supplies it: an ordered list of layers, each naming a source layer, a filter, and paint properties. Order is drawing order; filters decide that motorways appear from zoom 6 and residential streets from zoom 12; paint decides widths that grow with zoom, colors, label fonts, and halo. Two consequences matter for beginners. First, the same data can wear any number of styles: a hiking style that shouts contours and mutes motorways and a delivery style that does the opposite can drink from one tile source. Second, the style is a document you maintain, with versions, bugs, and taste, closer to a stylesheet for a website than to a picture. When a vector map looks wrong, the fix is usually in the style, not the data, and that separation is the system's deepest difference from raster, where look and data are baked together on the server.

Renderers: MapLibre, Mapbox GL, and Tangram
The drawing is done by a renderer library running on the client. MapLibre GL JS is the open-source community fork that carries the web ecosystem today; Mapbox GL JS is its commercial ancestor; Tangram, from Mapzen's lineage, is the other established web renderer, with its own scene-file styling. On mobile, MapLibre's native SDKs do the same job inside apps. All of them consume MVT tiles plus a style document and produce the map on the GPU, which is why vector maps animate at the speed of a video game: the device is literally running one. Choosing among renderers is a licensing, ecosystem, and feature decision, but the concepts transfer whole, because the tile format and the data-versus-style split are shared. Learn those two ideas and every renderer is a dialect of a language you already speak.
Generators: Tilemaker, Planetiler, and the Hosted Route
Somebody has to cut OpenStreetMap data into tiles. Tilemaker builds vector tiles directly from an .osm.pbf file with a Lua-driven configuration, a favorite for self-hosting a region. Planetiler builds them fast, planet-scale included, with profiles in Java or configuration. Hosted providers run the same class of pipeline as a service and hand you a tile URL and a style, trading money for not operating anything. The choice mirrors the rest of this site's advice about infrastructure: generate your own when the region is small, the updates are occasional, and the learning is worth it; buy hosted when the map is a product surface and your hours belong elsewhere. Either way the input is the same PBF data our download guide fetches, and the output is tiles plus the need for a style.
The Honest Costs
Vector tiles are not a free upgrade. Client rendering needs a capable device: old phones and cheap hardware draw raster happily and vector reluctantly, and a public-service map with an everyone mandate may rationally stay raster. The style is a maintenance surface: a raster map's look is someone else's finished picture, while a vector map's look is your document, your bugs, your font licensing, your label collisions at the zooms nobody tested. Tiles are bigger in aggregate logic: a tile set plus styles plus fonts plus sprites is a small system to version and deploy, where raster is a pile of images and a cache. And print is raster's home ground: a vector web map exports to paper through extra steps that a rendered image does not need. None of this argues against vector. It argues for choosing it with eyes open, for the interactive jobs it is genuinely better at, which in 2026 is most of the maps people touch.
Where OpenStreetMap Itself Stands
The main OpenStreetMap site still serves raster tiles, while the ecosystem around it, the renderers, the hosted providers, the mobile SDKs, has largely gone vector, and the project's own basemap ecosystem increasingly offers vector options alongside the classic raster ones our basemaps guide surveys. For a newcomer the practical takeaway is simple: when you embed or build with OSM today, you will likely meet vector tiles first, and the concepts in this article, data tile, style document, client renderer, are the price of admission. Pay it once and the modern map stack stops being a mystery: it is the old stack with the drawing moved from the server into your hand.
Zoom, Overzoom, and Why Vector Never Blurs
A raster map zoomed past its images' native resolution goes soft, because there is no more picture to show. A vector map cannot blur in that way: the geometry is real at every scale, so the renderer simply draws it larger, and labels and lines stay crisp as far in as you care to go. Tile sets are still generated to a maximum zoom, beyond which renderers overzoom the deepest tiles, stretching their data with full sharpness but no new detail: the street you see at extreme zoom is exactly as accurate as it was at the tile's native zoom, drawn bigger, which is honest magnification rather than invention. This property changes how vector maps age on a page: an embedded raster map at the wrong zoom looks broken, while a vector map at any zoom looks intentional. It also changes the data discipline for generators: detail simplified away at low zooms cannot reappear at high ones, so a tile pipeline's generalization choices are editorial decisions about what the map may ever say, made once, in the generator's configuration.
The Supporting Cast: Glyphs and Sprites
Two asset families travel with the tiles and surprise every first-time self-hoster. Glyphs are the font files the renderer uses to draw labels: because text is rendered on the client, the letters themselves must be served, as signed distance field glyph ranges in PBF form, for every font and script the style uses. A map whose labels render as boxes or vanish is usually a glyph problem, not a data problem. Sprites are the icon images, road shields, point-of-interest symbols, the maki-style pictograms, delivered as a sprite sheet image plus a JSON index describing each icon's position in it. Tiles, style, glyphs, sprites: four pieces, versioned together, and a deployment that updates one without the others produces the characteristic half-broken map, new data wearing old icons, that every vector practitioner learns to recognize. Hosted providers bundle all four invisibly, which is their quietest value; self-hosting means owning the bundle, which is its honest cost.
Trying It as a Reader: What to Notice
You can feel the difference this article describes without building anything. Open a modern vector-based map (the MapLibre demo maps, or any major provider's current web map) beside the classic raster map on openstreetmap.org and perform the same three gestures on both. Zoom in slowly and watch the vector map's labels hold their size and sharpness while the raster map steps through its image scales. Rotate or tilt where the interface allows and notice which map treats the world as geometry and which as wallpaper. Then switch the vector map's style if the demo offers it, night mode is the usual showcase, and register that nothing was re-downloaded as pictures: the same data simply dressed differently. Those three sensations, sharpness at every zoom, real rotation, instant restyle, are the entire argument for the technology, and they are why the ecosystem moved. The raster map's counter-argument is on the same screen: it loaded instantly, on anything, with nothing to configure, and for a great many jobs that remains the argument that wins.
Related Guides
If this page answered part of the question, these GIS guides cover the rest of the same ground:
- OpenStreetMap PBF: The Binary Format the Planet Travels In: The raw data format vector tiles are generated from.
- Embed an OpenStreetMap Map: The Iframe, the URL, and the Libraries: Putting a rendered map, raster or vector, into your own page.
- OpenStreetMap Tile Server: How the Classic Raster Stack Works: The server-rendered alternative this article compares against.
- OpenStreetMap uMap: Layers, Imports, and a Backup: The no-code route to a custom OSM map, for readers who do not need tiles of their own.
- OpenStreetMap Custom Style: Writing Your Own osm-carto Style in CartoCSS: The raster tradition’s styling system, for contrast with the vector style document.
Frequently Asked Questions
What is a vector tile?
It is a square of map data, not a picture: geometries and attributes for the roads, water, buildings, and places in that square, encoded in the Mapbox Vector Tile format. The device receiving it draws the actual map by applying a style document.
How do vector tiles differ from the tiles on openstreetmap.org?
The main site serves raster tiles, finished images rendered on a server. Vector tiles ship the underlying data and let the client render it, which enables smooth zoom, rotation, restyling, and labels drawn in the viewer's language. The main site's approach is simpler and works on any device; vector is more capable and more demanding.
What is the MVT specification?
The Mapbox Vector Tile specification is the open format nearly all vector tiles use. Version 2.1 was released on January 19, 2016. It defines how layers, features, geometries, and attributes are encoded inside a tile using Protocol Buffers, which is why the files end in .pbf.
What is a style document and why does it matter?
It is a JSON document that tells the renderer how the data should look: which features appear at which zooms, in what order, with what colors, widths, and labels. Because style is separate from data, one tile source can power many differently styled maps, and most visual fixes happen in the style rather than the data.
How do I make my own vector tiles from OpenStreetMap data?
Use a generator such as Tilemaker or Planetiler on an .osm.pbf extract, then serve the tiles with a style document through a renderer such as MapLibre GL JS. Hosted providers offer the same pipeline as a service if you prefer not to run it yourself.
Photo credits: Alicia Christin Gerald (Pexels); Tima Miroshnichenko (Pexels). Photos are served from this site; follow the credit to the library page for the original.