Meshtile

C++ HTTP tile server that computes RF signal coverage for Meshtastic mesh network nodes using the NTIA ITM (Longley-Rice) propagation model and SRTM elevation data, then serves blended signal-strength tiles as 256x256 PNGs.

Build

Requires: libcurl, zlib, a C++17 compiler.

mkdir build && cd build
cmake ..
make -j$(nproc)

CMake auto-downloads all third-party dependencies via FetchContent (NTIA ITM, cpp-httplib, nlohmann/json, lodepng).

Usage

./meshtile [options]

Server Options

MeshMapper Regions

Node and noise floor data are fetched from MeshMapper regional instances. Each instance uses a short prefix as its subdomain (e.g. den.meshmapper.net, oma.meshmapper.net). Use --region to select which instance to pull from:

./meshtile --region den    # Denver (default)
./meshtile --region oma    # Omaha
./meshtile --region pnw    # Pacific Northwest
./meshtile --region yyc    # Calgary

The full list of available regions is at meshmapper.net. The --nodes and --noise-data flags override the region-based URLs if you need a custom source.

ITM Propagation Parameters

Display Options

Example

./meshtile --port 9090 --climate 6 --clutter-height 2 --colormap plasma

All effective parameters are logged at startup, whether set explicitly or left at defaults.

Endpoints

Google Earth

In Google Earth: hamburger menu > Map Style > Add Tile Overlay > http://host:port/tiles/{z}/{x}/{y}.png

Caching

• Per-node signal grids are cached to disk at ~/.cache/meshtile/<region>/grids/
• Rendered tile PNGs are cached to disk + memory at ~/.cache/meshtile/<region>/tiles/
• HGT elevation tiles are cached at ~/.cache/mesh3d/hgt/ (shared with mesh3d)
• Changing any ITM or RF parameter automatically invalidates cached grids on next run

Docker

docker build -t meshtile .
docker run -v meshtile-cache:/data/.cache -p 8080:8080 meshtile --region den

Or with Docker Compose:

services:
  meshtile:
    image: stevenlafl/meshtile
    ports:
      - "8080:8080"
    volumes:
      - meshtile-cache:/data/.cache
    command: ["--region", "den"]

volumes:
  meshtile-cache:

docker compose up

The cache volume persists signal grids and HGT elevation data across container restarts, avoiding expensive recomputation. Each region gets its own cache namespace within the volume.

Memory Usage

Signal grids and elevation data are memory-mapped from disk rather than loaded into RAM. This means runtime memory usage is low (~30 MiB at idle) and the OS automatically pages in only the data needed for active tile requests.

However, initial grid computation (first run or after parameter changes) requires temporary RAM for each node being computed. Use --threads to control how many nodes compute simultaneously and limit peak memory:

# Low memory (~256 MiB): compute one node at a time
./meshtile --threads 1

# Default: uses all CPU cores (faster, but higher peak RAM)
./meshtile

As a rule of thumb, each concurrent computation thread can use ~50-100 MiB. Once grids are cached, subsequent startups use minimal RAM regardless of thread count.

How It Works

1. Fetches the node list from the meshmapper API (or local JSON)
2. For each node, loads SRTM HGT elevation data and runs ITM point-to-point propagation for every grid cell within max_range km
3. Signal grids are cached per-node; when a new node appears, only its grid is computed and only overlapping tiles are invalidated
4. At render time, overlapping grids are blended (strongest signal wins) and mapped through the selected colormap
5. Tiles are served as standard XYZ slippy map PNGs with CORS headers

Dependencies

License

MIT. See LICENSE for details.

Third-party dependency licenses are listed in THIRD_PARTY_LICENSES.