Garmin IMG — Binary Map Format for Garmin GPS Receivers (mkgmap, OpenStreetMap)

2026-04-0412 min read

GarminIMGGPSmkgmapnavigationhardware

Export formats: GARMIN-IMG

Garmin IMG is Garmin's proprietary binary cartridge format used across their entire GPS receiver lineup: eTrex, Oregon, Montana, GPSMAP, Edge, Drive, nüvi. It appeared in the early 2000s with the desktop MapSource utility and has been the standard for the Garmin handheld ecosystem ever since. Garmin has never published a formal spec, but by the mid-2000s the OSM community (mainly the mkgmap project under Mark Burton) reverse-engineered enough of the file structure to reliably generate .img files from arbitrary OpenStreetMap data. On osm2cdr.ru, garmin_img_exporter.py invokes mkgmap (Java CLI), feeds it a PostGIS-derived OSM PBF slice for the user-selected bbox and a set of style files — the output is a single .img ready to drop into the /Garmin/ folder on a microSD card. The format ships as Beta in osm2cdr: the Java tooling adds a build step, and not every Garmin model uniformly accepts unsigned IMG.

Map generation of Istanbul city center

History: Garmin 1990s → mkgmap → talkytoaster

Garmin was founded in 1989 in Kansas as a military and aviation GPS electronics maker, releasing the first consumer handhelds (GPS 100AVD, 1991) — initially without cartography, only coordinates and waypoints. In 1998, alongside the StreetPilot (the first car Garmin with a map screen), an internal binary map format appeared, which by late 1999 had the .img extension and a tie to the MapSource desktop app for loading maps onto devices via serial or USB. Garmin never published the spec: it was a closed binary format protecting the content business (Garmin sold City Navigator NT, TOPO Russia, BlueChart, etc. as separate $50–$200 SKUs).

Between 2004 and 2007 a group of OSM enthusiasts started reverse engineering. The first documented breakthrough was John Mechalas, who released a partial sub-files spec in 2007. In parallel Steve Ratcliffe spun up the Java mkgmap project (initially a proof-of-concept for OSM XML → Garmin IMG conversion), which by 2010 under Mark Burton's lead became production-grade tooling. mkgmap is now the de facto standard: nearly every community project that releases free Garmin maps from OSM uses it.

Those community projects include talkytoaster (UK, regular continental releases), Velomap (cycling-oriented maps by Felix Hartman), FrankM (German enthusiast, DACH releases), OpenMtbMap (mountain biking layers), OpenFietsMap (Netherlands/Belgium), and garmin.openstreetmap.nl (Netherlands daily builds). They all follow a similar workflow: pull freshest OSM extracts, run them through mkgmap with their own style rules, package the result as downloadable .img or installer-executable Windows MapSource bundles. Quality ranges from decent to outright beating paid Garmin City Navigator: many hikers prefer talkytoaster to paid alternatives.

By the 2020s, the Garmin handheld market shrank under the weight of smartphones running OsmAnd and Locus Map, but still holds niches: outdoor (fishing, hunting, multi-day hiking where Garmin lasts 25+ hours on AA batteries), cycling (Edge series), marine (GPSMAP + BlueChart), commercial aviation (Garmin avionics). IMG as a format remains very much alive and updated, and the OSM → mkgmap → .img → SD → Garmin pipeline stays one of the most popular open-source workflows in geo.

Inside IMG: subfiles (RGN, LBL, NET, NOD, TRE, TYP)

Inside, a .img file is a FAT-like disk image (Garmin uses a custom FAT, derived from FAT16) with a hierarchical sub-file structure. Each sub-file is its own data section with magic header and indexed records. The six main sub-files present in every full Garmin map set:

RGN (Region) — object geometry. Polylines (roads, rivers, contour lines), polygons (buildings, water bodies, forests), points (POIs). Coordinates in Garmin's own 24-bit signed integer grid, derived from WGS84. Each polyline / polygon / point has a type code defining its visual representation per TYP.
LBL (Labels) — all text labels. Stored separately from geometry for efficient indexing and multi-language support. Supports 6-bit and 8-bit charsets plus custom codepages for Cyrillic / CJK.
TRE (Tree) — the structural tree plus multi-level detail (zoom-aware). Each zoom level keeps its own spatially-sorted sub-array of objects, letting the device quickly find relevant objects in the current bbox without scanning the whole RGN.
NET (Network) — the road graph for routing. List of road segments with endpoint nodes and edge attributes (one-way, restricted access, road class).
NOD (Nodes) — routing nodes themselves. Junctions plus turn restrictions (no left turn, no U-turn). Without NOD, the map is displayable but not routable.
TYP (Typography/Style) — visual styling. Describes every type code from RGN: which color, which icon (for POIs), which line width (for roads), which fill pattern (for polygons). TYP can be baked into the IMG or kept as a separate file — community projects often publish TYP bundles so the user picks how their talkytoaster map looks.

Maximum single .img size is 4 GB (the FAT-derived format limit). Larger maps are split into tiles (subset .img files) packaged into a single gmapsupp.img composite that the device sees as one map.

Map generation of Kaliningrad city center

Use cases

Hiking and outdoor. Multi-day trips in zones without cell service or Wi-Fi (Caucasus, Altai, Alaska, Patagonia) are the historic native use case for Garmin handhelds. The eTrex 32x — 25+ hours on two AA batteries, IPX7 water resistance, hardware buttons (works in gloves) — still beats a smartphone in rough conditions. Touring topographic maps from talkytoaster / OpenAndroMaps with 10-meter contour intervals are precisely why hikers buy Garmin over a phone.

Bike touring. The Edge series (530, 830, 1040) are the most advanced bike computers on the market, and they accept IMG maps over USB. Velomap (Felix Hartman) and OpenFietsMap (Netherlands/Belgium) are built specifically for cyclists: bike lanes highlighted, gravel roads emphasized, route planning weighted toward calm roads. IMG is ideal for bike touring: one file for all of Europe, loaded in under a minute over USB-C.

Hunting, fishing, off-road. The Montana series and GPSMAP 64–66 are the favorite platforms of hunters and off-road drivers. Hunt overlays with custom polygon zones, marine charts via BlueChart Mobile, custom POI for fishing spots. Off-the-shelf IMG maps from FrankM or talkytoaster cover huge regions; OSM-driven generation through osm2cdr lets you cook a map for any narrow area (a specific forestry district, say) focused on the POI subset you want.

Marine. GPSMAP plus BlueChart is its own world, where IMG carries marine nav charts. While BlueChart itself is a closed Garmin product, the OSM community produces free marine maps via mkgmap with marine-aware style rules (OpenSeaMap data → IMG output). Not a replacement for certified charts in professional navigation, but workable for recreational sailing.

Recreational aviation. Light aviation, paragliding, parasailing — VFR maps on a handheld Garmin (eTrex, GPSMAP) with custom IMG carrying airspace boundaries. Not certified, but used as backup / cross-check.

Pros / Cons (vs OsmAnd OBF, vs TomTom OV2, vs raw GPX)

Strengths. Runs on dedicated GPS devices with 25+ hours autonomy and hardware buttons — vital on trips where a smartphone with OsmAnd dies in 8 hours. On-device routing (with proper NOD) works without internet. Vector format — scales without quality loss. Topographic contour support on Oregon/Montana handhelds. A huge community library of pre-built maps (talkytoaster, Velomap and friends) covers most of the world for free. Multi-language support via LBL. Compact: a 1.5 GB IMG covers all of Europe with routing.

Weaknesses. Proprietary closed format — Garmin can change the structure and break backward compatibility (this has happened very rarely in 20 years, but the risk is non-zero). Java dependency: mkgmap requires a JVM, which complicates CI/CD and Docker builds (the worker image gains ~150 MB for a Java runtime). 4 GB FAT limit on a single .img — large regions (all of Russia at detail) must be split into tiles. Not every Garmin model accepts unsigned IMG equally: old eTrex 10/20 may refuse community maps; newer models usually work but Garmin periodically tightens firmware checks. TYP styling is its own reverse-engineered sub-format with its own tooling (typdecomp/typc/typcompiler), not casual-user friendly. Not for smartphones — for those there's OsmAnd OBF covering the same use case with a far more open ecosystem. Versus TomTom OV2 — IMG is incomparably more powerful (OV2 is POI-only, no routing/geometry) but also much heavier to produce. Versus GPX — different classes entirely: GPX is for tracks and waypoints; IMG is the basemap itself.

Workflow in OSM2CDR

In osm2cdr, garmin_img_exporter.py is wired in as a Beta exporter (stable enough for production, but the Java tooling makes it heavier than pure-Python exporters). The pipeline:

Step 1: OSM data extraction. The backend, via local_osm_loader.py, pulls the relevant slice from local PostGIS (planet table) for the user's bbox. PostGIS → osmosis-compatible PBF conversion uses ST_AsBinary plus a custom serializer (we resave PostGIS rows as OSM PBF for compatibility with mkgmap, which expects either XML or PBF on input).

Step 2: mkgmap conversion. The worker container fires mkgmap (Java 17 runtime) with config: - --style-file=osm2cdr-default.style — our own style file (OSM tags → Garmin type codes) - --country-code=276 (default Germany; configured by bbox centroid) - --route — turns on NOD generation for routing - --draw-priority=25, --family-id=12345, --product-id=1 — Garmin metadata - --gmapsupp — produce the composite gmapsupp.img at output

Step 3: TYP injection. A pre-built TYP file (our osm2cdr-default.typ, compiled from source via typcompiler) is attached to the resulting .img. TYP can vary by style — we ship four presets: default, mountain (outdoor focus, contour emphasis), velo (bike lanes highlighted), marine.

Step 4: Validation. mkgmap.jar --check-styles plus our own smoke test: open .img through GDAL OGR (driver IMG), confirm layers are parseable. The user receives one .img plus an optional .zip with TYP and an instruction text.

Beta-pipeline limitations: - Roundtrip time: 30–90 seconds for a typical 10×10 km urban bbox (mkgmap is CPU-bound) - Large bboxes (>200×200 km) may exceed worker timeout (240 s); tiling is recommended - Custom POI category selection is not exposed in UI yet (only default mapping); roadmap item - Java dependency adds ~150 MB to worker image, which we accept

Alternative: power users who want to tweak style files / TYP can use the /api/render CLI export with format=garmin-img&style=mountain and raw download of the resulting .img without UI.

Map generation of Krasnodar city center

FAQ

How do I load .img onto my Garmin? Plug the Garmin into the computer over USB (it mounts as USB Mass Storage). Copy gmapsupp.img to the Garmin/ folder on the microSD card or internal storage (depends on model). Safely eject the USB, reboot the Garmin — under Setup → Map → Map Information you should see the new map. If it isn't there, see the next question.

The map doesn't show up in the menu — what now? Three typical causes: (1) the file is in the wrong folder — must be exactly Garmin/gmapsupp.img (or Garmin/CustomMaps/ on some models); (2) family-ID / product-ID conflict with an already-installed map (the device shows only one map per family-ID active — disable the old one in Setup → Map → Map Information → Configure Maps); (3) the model doesn't accept unsigned IMG — old eTrex 10/20 and some nüvi series may refuse. For (3) — try a different model or use Garmin Custom Maps KMZ (open, supported on most devices).

Does routing work, or just display? Routing works only if the .img contains a NOD sub-file. Our osm2cdr export with the default config includes --route and generates NOD — so pure on-device routing works. Quality depends on OSM road network completeness in the area and on road-class weights in our style file. If routing performs poorly for a region, open an issue and we'll fix it.

Can mkgmap be used without osm2cdr? Yes. mkgmap is an open-source Java tool, free, documented at mkgmap.org.uk. For full customization (your own style file, your own TYP, your own country-code mappings) — grab an OSM extract from Geofabrik, install mkgmap, run it. osm2cdr is a convenient UI wrapper for casual users who don't want to wrestle with Java CLI and just want a ready .img in a minute.

Which Garmin models are recommended for community IMG? As of 2026 the best-supported models for unsigned community IMG: eTrex 22x/32x (handhelds, budget), Oregon 700/750t (touchscreen, premium hiking), Montana 700/750i (large screen, off-road), GPSMAP 66s/66i (flagship handheld, marine + topo), Edge 530/830/1040 (bike computers). Old eTrex 10/20/30, nüvi (auto), some Drive series — less predictable.

Conclusion

Garmin IMG is one of the rare proprietary formats for which the open-source community has built such a high-quality pipeline (mkgmap + talkytoaster + Velomap + our osm2cdr exporter) that, for practical purposes, it has become as-open-as-it-gets without Garmin formally publishing the spec. If you're a hiker, cyclist, hunter, or just someone with a Garmin handheld on long trips, IMG from OSM data beats paid City Navigator NT in most use cases — especially when you factor in that OSM updates daily while Garmin City Navigator updates once a year for money.

If your backpack carries a Garmin Edge / eTrex / Oregon — try exporting a map for the region you need right now on the /formats/garmin-img/ page: just a bbox on the map and a couple of minutes.

Sources

mkgmap project — mkgmap.org.uk
OpenStreetMap wiki on Garmin formats — wiki.openstreetmap.org/wiki/OSM_Map_On_Garmin
talkytoaster maps — talkytoaster.co.uk
Velomap by Felix Hartman — velomap.org
OpenMtbMap — openmtbmap.org
GPSrChive Garmin tutorials — gpsrchive.com