walkers 0.52.0

slippy map widget for egui
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

# Walkers, a map widget for Rust

![made in Europe](https://img.shields.io/badge/made_in-Europe-blue)
[![crates.io](https://img.shields.io/crates/v/walkers.svg)](https://crates.io/crates/walkers)
[![docs.rs](https://img.shields.io/docsrs/walkers/latest)](https://docs.rs/walkers/latest/)

Walkers is a slippy maps widget for [egui](https://github.com/emilk/egui), 
similar to very popular [Leaflet](https://leafletjs.com/), but written in Rust.
It compiles to native applications as well as WASM. See the **[online demo here](https://podusowski.github.io/walkers/)**.

![Screenshot](https://raw.githubusercontent.com/podusowski/walkers/main/screenshot.png)

It supports [OpenStreetMap](https://www.openstreetmap.org), [mapbox](https://www.mapbox.com/), 
and compatible tile servers as well as off-line tiles using the [PMTiles](https://protomaps.com/pmtiles/) format.

Before deploying your application, please get yourself familiar with the
[OpenStreetMap usage policy](https://operations.osmfoundation.org/policies/tiles/), 
and consider donating to the [OpenStreetMap Foundation](https://supporting.openstreetmap.org/).

## Quick start

Walkers has three main objects. `Tiles` downloads images from a tile map provider
such as OpenStreetMap and stores them in a cache, `MapMemory` keeps track of
the widget's state and `Map` is the widget itself.

```rust
use walkers::{HttpTiles, Map, MapMemory, Position, sources::OpenStreetMap, lon_lat};
use egui::{Context, CentralPanel};
use eframe::{App, Frame};

struct MyApp {
    tiles: HttpTiles,
    map_memory: MapMemory,
}

impl MyApp {
    fn new(egui_ctx: Context) -> Self {
        Self {
            tiles: HttpTiles::new(OpenStreetMap, egui_ctx),
            map_memory: MapMemory::default(),
        }
    }
}

impl App for MyApp {
    fn update(&mut self, ctx: &Context, _frame: &mut Frame) {
        CentralPanel::default().show(ctx, |ui| {
            ui.add(Map::new(
                Some(&mut self.tiles),
                &mut self.map_memory,
                lon_lat(17.03664, 51.09916)
            ));
        });
    }
}
```

You can see a more complete example [here](https://github.com/podusowski/walkers/blob/main/demo/src/lib.rs).

## Running the demo

### Native

To run demo application locally, use a default cargo run target.

```sh
cargo run
```

### Web / WASM

```sh
cd demo_web
trunk serve --release
```

### Android

You need to have [Android SDK](https://developer.android.com/) and
[cargo-ndk](https://github.com/bbqsrc/cargo-ndk) installed.

```sh
cd demo_android
make run-on-device
```

## Vector and offline maps

To see experimental **vector maps** support in action, you need to obtain some `.pmtiles`
files and put them into the directory from where you run the native demo. One way of
doing that is to download an extract from
[Protomaps](https://docs.protomaps.com/guide/getting-started).

```sh
pmtiles extract https://build.protomaps.com/20250928.pmtiles --bbox 16.802768,51.036355,17.209205,51.180686 wroclaw.pmtiles
```

## Mapbox support

To enable **mapbox** layers, you need to define `MAPBOX_ACCESS_TOKEN` environment
variable before building. You can get one by creating a
[mapbox account](https://account.mapbox.com/).