TAK 12 min read

Serving vector tiles to ATAK and WinTAK: from style to offline basemap

TAK clients want raster tiles, your data lives as vector tiles, and the field has no bandwidth. How to render a MapLibre style into tile pyramids, size a package for an area of operations, and choose between MBTiles, PMTiles and data packages.

On this page
  1. What TAK clients actually read
  2. The tile pyramid, and why zoom 18 hurts
  3. Pipeline: vector tiles → style → raster pyramid
  4. MBTiles vs PMTiles vs data packages
  5. Distribution and updates
  6. Takeaways

Most modern basemaps are vector tiles: compact Mapbox Vector Tile (MVT) archives styled at render time by MapLibre or Mapbox GL. Most TAK deployments need those same maps on Android tablets in ATAK and on laptops in WinTAK, often with no network at all. Bridging the two is a rendering and packaging problem, and getting it wrong produces either a 40 GB tablet or a blurry map.

What TAK clients actually read

ATAK and WinTAK are raster-first map engines. Out of the box they consume:

  • Online tile sources described by a small XML file (a “map source” or tile.xml) pointing at an XYZ, WMS or WMTS endpoint.
  • Offline raster archives: MBTiles and GeoPackage containing PNG/JPEG tiles, plus legacy SQLite and cache formats.
  • Overlays: KML/KMZ, GeoJSON (via import), GPX, shapefiles and elevation (DTED) for terrain tools.

What they do not do natively, at the time of writing, is style MVT vector tiles on the device the way a MapLibre app does. Plugins exist and the situation improves with each release, but for a fleet of devices you cannot upgrade on demand the reliable path is: keep the vector tiles and the style as the source of truth, and render raster pyramids from them for the field.

The tile pyramid, and why zoom 18 hurts

Web Mercator tiles quadruple with every zoom level. For a 50 × 50 km area of operations the counts look harmless until zoom 16, then explode. The table uses tile widths at the equator; at 45° latitude tiles are about 30% narrower on the ground, so counts rise further.

Tile pyramid for a 50 by 50 kilometre area at zoom 12, 14, 16 and 18z12z14z16z18same 50 × 50 km, four zoom levels
ZoomTile widthTiles≈ Size
z129.8 km361 MB
z142.4 km4418 MB
z16611 m7k118 MB
z18153 m108k1.8 GB
Tile counts and approximate package sizes for one area of operations at four zoom levels (≈18 KB per PNG topo tile; imagery tiles are 2–4× larger).

Two conclusions follow. First, cap the maximum zoom per use case: z14–15 is enough for vehicle navigation and situational awareness, z16–17 for dismounted operations in built-up areas, z18+ only for small target areas. Second, mix styles by zoom: a light topo style to z14 across the whole AO, imagery only inside named objectives.

Pipeline: vector tiles → style → raster pyramid

  1. 01

    Build or obtain the vector tiles

    OpenStreetMap-derived tiles from planetiler or tippecanoe, your own PostGIS layers via ST_AsMVT, or a commercial archive. Store them as an MVT MBTiles or PMTiles file — this is the asset you version and keep.
  2. 02

    Design the style for print, not for screens

    A MapLibre style JSON tuned for rasterisation: higher-contrast roads, fewer labels at low zoom, no hover or interactive layers, fonts and sprites served locally. Raster tiles cannot re-flow labels, so what you render is what the operator gets.
  3. 03

    Render the pyramid headlessly

    A MapLibre GL Native renderer (through tileserver-gl or a small Node/Python service) draws each tile of the requested extent and zoom range to PNG/JPEG and writes it into a raster MBTiles. Render at 512 px and downsample, or use the @2x variant for high-DPI tablets.
  4. 04

    Write metadata and validate

    Fill the MBTiles metadata table (name, format, bounds, minzoom, maxzoom, type). ATAK uses it for the layer name and extent; missing bounds mean the layer shows up but cannot be zoomed to.
  5. 05

    Package and distribute

    Ship as a TAK data package (a zip with a manifest) through TAK Server, or side-load into the device's imagery folder. See below.
render-ao.shShell
1# 1. Serve vector tiles + style on localhost (no internet needed)
2docker run --rm -d --name tiles -p 8080:8080 \
3 -v "$PWD/data:/data" maptiler/tileserver-gl \
4 --config /data/config.json # points at ao.mbtiles + topo-print.json
5
6# 2. Render a raster MBTiles for the AO bbox, z10–16, 512px tiles
7python render_pyramid.py \
8 --source "http://localhost:8080/styles/topo-print/512/{z}/{x}/{y}.png" \
9 --bbox 72.45,22.95,72.72,23.15 --minzoom 10 --maxzoom 16 \
10 --format png --out out/ao-topo-z10-16.mbtiles
11
12# 3. Check the metadata ATAK relies on
13sqlite3 out/ao-topo-z10-16.mbtiles "SELECT name, value FROM metadata;"
Serve the vector tiles and style locally, then pull the raster pyramid for the AO. Any XYZ-speaking renderer works; the point is that the style is the single source of truth.
metadata.sqlSQL
1INSERT OR REPLACE INTO metadata (name, value) VALUES
2 ('name', 'AO North – Topo (print style)'),
3 ('format', 'png'),
4 ('type', 'baselayer'),
5 ('minzoom', '10'),
6 ('maxzoom', '16'),
7 ('bounds', '72.45,22.95,72.72,23.15'),
8 ('center', '72.585,23.05,12'),
9 ('attribution', '© OpenStreetMap contributors · rendered 2026-09'),
10 ('version', '2026.09.1');
The metadata rows worth getting right. `type=baselayer` makes ATAK treat it as a basemap; `overlay` stacks it above one.

For connected devices, the same style becomes an online map source — one XML file the operator imports once:

topo-print.xmlXML
1<?xml version="1.0" encoding="UTF-8"?>
2<customMapSource>
3 <name>Topo (print style)</name>
4 <minZoom>4</minZoom>
5 <maxZoom>16</maxZoom>
6 <tileType>png</tileType>
7 <tileUpdate>None</tileUpdate>
8 <url>https://tiles.example.org/topo-print/{$z}/{$x}/{$y}.png</url>
9 <backgroundColor>#000000</backgroundColor>
10</customMapSource>
An ATAK/WinTAK map source pointing at the rendered XYZ endpoint. Cap maxZoom to what you actually rendered.

MBTiles vs PMTiles vs data packages

MBTiles (raster)PMTilesTAK data package
What it isSQLite file of z/x/y tiles + metadataSingle-file archive read by HTTP range requests; no server logicZip with a manifest: MBTiles/GeoPackage, KML, map sources, elevation
TAK supportNative in ATAK and WinTAK (import to imagery)Not read natively — serve through a tiny proxy or convert to MBTiles for offlineNative: imported by Mission Package tool or pushed by TAK Server
Best atOffline basemaps on the deviceCheap online serving from object storage / CDN, no tile serverDistribution: one artefact per AO with everything the unit needs
UpdatesReplace the file (or attach a diff-rendered overlay)Replace the file; clients fetch new rangesVersioned packages via Data Sync; devices pull the new one
Watch outLarge files on FAT-formatted SD cards (4 GB limit)Browser-first ecosystem; TAK needs the proxy hopManifest UIDs must be stable or devices duplicate layers

In practice the three are layers of one workflow, not rivals: PMTiles for serving the rendered pyramid online with zero infrastructure, MBTiles for the offline copy on the device, and a data package to get that MBTiles — plus overlays and elevation — onto a hundred devices consistently.

Distribution and updates

  • Sizing: one package per AO per style, named with zoom range and render date. Keep individual files under 2 GB so they transfer and verify quickly.
  • TAK Server Data Sync / missions: attach the package to a mission; subscribed devices receive it and later versions automatically.
  • Scheduled re-renders: when the vector source or the style changes, re-render only the affected zoom range and publish a new version; the manifest UID stays the same so the client replaces rather than duplicates.
  • Side-loading fallback: for air-gapped units, the same MBTiles copied to atak/imagery/ works without a server.

We have shipped this pipeline enough times to turn parts of it into products: Vector To Raster renders vector tile styles to raster MBTiles, Offline Map Data Generator builds area-of-operations packages, and Map Data Generator TilePackage targets the Esri tile package formats for ArcGIS-based units.

TAK data packages & offline basemapsAO basemap packages, tile.xml sources, overlays and elevation — built on a schedule or per request.Vector To RasterOur app for rendering vector tile styles into raster MBTiles for TAK and other offline clients.Offline Map Data GeneratorPackage basemaps for an area of operations, ready for ATAK, WinTAK and iTAK.Map Data Generator TilePackageThe same workflow producing Esri tile packages for ArcGIS field apps.

Takeaways

Takeaways

  • 01Keep vectors and the style as the source of truth; render raster pyramids for TAK from them so every update is reproducible.
  • 02Cap zoom per use case and mix styles by zoom. z14–15 for vehicles, z16–17 for dismounted work, imagery only inside objectives.
  • 03MBTiles on the device, PMTiles online, data packages for distribution — one workflow, three containers.
  • 04Metadata and manifest UIDs are not optional. Bounds make the layer zoomable; stable UIDs make updates replace instead of duplicate.

Start a project

Have a project in mind? Let's build it.

Share your requirement and get an obligation-free consultation, a technology recommendation, and a quote within 48 business hours.

Chat on WhatsApp