EpicRide, the desktop client

EpicRide is the browser client for the work you would rather not do on a phone: planning a route properly, editing a track, writing up a trip. It runs at epicride.fastgis.eu and talks to the same API as everything else.

:::caution Being written This page describes what the client is and how it is put together. Screen-by-screen walkthroughs are still to come. :::

The client opens on a Dashboard of what you are riding rather than on a map. That is the front of a bigger idea with its own page: events — a time, a roster and the library records you ride, at four sizes from a solo trip to a rally.

The client's biggest single tool has its own page: the roadbook editor — a WYSIWYG editor for FIA-layout rally roadbooks with OpenRally export and print.

First steps: the tour and Help

The first time your account opens the planner, a short tour points at five parts of the window, one card at a time, each beside its part with the part outlined:

The route planner: add points with the place search (a name or coordinates) or a click on the map, and the route is drawn between them; its briefing below lists the gates, the surface and the stops.
The rail: the planner's tools (Plan, Discover, My data, Draw).
The layers: everything the map can show, with its legend.
The Library: your saved routes, tracks and places.
The elevation profile: the route's height and grades.

Next (or Enter, or →) goes on, ← goes back, and Skip or Escape ends it. The tour runs once per account, not once per browser: after you finish or skip it, it does not come back in this browser or any other.

Help, at the top right, is a menu: Ask for help (the in-app support chat), Show the tour (the tour again, from any page), Keyboard shortcuts and The guide. The last two open the Help widget, which has three tabs:

Keys: the list of keys (see The window from the keyboard). ? always opens the widget on this tab.
Tour: Start the tour, or Show beside one of its five steps to start from there. It says Seen once your account has seen the tour.
Guide: the pages of this guide for the room you are in (the planner or the Library) and The whole guide. Each link opens in a new browser tab: the guide does not open inside the window.

The Help widget sits in the right column like any other and can dock under the map. Docked with other widgets, its own tabs sit inside its tab of the dock.

How it looks

The window comes in two themes, light and dark graphite: neutral greys with no blue tint, flat panels a step lighter or darker than what they sit on, and thin lines between them. By default it follows your computer (Auto): light by day, dark at night if your system switches; Preferences › Appearance › Theme pins one. Teal is the one colour that means on — the selected chip, the primary button, the tool you are using, the room you are in — and amber is for counts and for anything in doubt. Red is kept for what is closed and for actions that delete. A state such as passable or closed is a tinted tag: a deep tint of its colour with bright words on it.

Two typefaces share the work. Widget titles, labels, tags and every figure (distances, times, coordinates, the attribute table) are set in Hasklig, whose digits all have the same width, so a column of numbers lines up and a changing value does not shift its neighbours. Buttons and running text are in Source Sans 3. Both are open fonts (SIL Open Font License) served with the app.

Icons are one set everywhere: Tabler line icons (MIT licence), drawn as small vector pictures in the colour of the text beside them, so a disabled button greys its icon and a selected tool tints it. They replace the emoji and the hand-drawn marks the window used to carry; an icon never stands alone for a screen reader, because the button it sits in has a name and a tooltip.

What the window draws on the map keeps the map's own colours in either theme: the route stays blue and the way back purple, the stops, pins and zones keep their marks, and the roadbook's sheet is white paper with black ink, as it prints.

UI scale (Preferences › Appearance) makes the panels, controls and text smaller or larger in four steps — Compact 90 %, Standard 100 %, Large 110 %, Larger 125 % — while the map keeps its own size. At a larger step the window has room for fewer columns, so it may show one side column where it showed two.

Map colours (Preferences › Map) chooses how the route, the ground under it and the gates are coloured: Standard, or Colour-blind safe, colours that stay apart for red–green colour blindness. A line colour you set yourself in Lines and markers stays yours in both. A gate on the route says its state by shape as well as colour — a circle when it is passable, a diamond when it is in doubt, a red square when it is closed — so colour is never the only cue.

How it fits together

EpicRide is a single-page app in front of its own small gateway, which sits between the browser and the FastGIS API rather than the browser calling the API directly. The gateway holds the session, so an API key never reaches the page.

The gateway is configured by the DESKTOP_GW_* variables — DESKTOP_GW_UPSTREAM names the API it proxies to, DESKTOP_GW_REDIS_URL holds its sessions, DESKTOP_GW_SECRET_KEY signs them. It answers GET /healthz with {"ok":true,"service":"desktop-gateway"}.

The planner's window

The planner is a window you arrange yourself, the way a desktop GIS works:

Two columns of widgets beside the map. The left one holds the work — the Route planner with its Route briefing, and the tools you pick from the rail at the far left (Discover: loops, curvy roads, dirt passages, places, beaches, practice grounds, wild camp and more, as one list — each tool with its mark, its name and a line on what it does; a row opens the tool below the list, ↑ ↓ move and Enter opens; My data: GPX files and the TET library; Draw: the vector editor; Layers brings the layer list forward). The right one holds what you look at: Layers on the map, the Attribute table (see The attribute table), the Elevation profile, a rider report you click on the map, and the map tools' own widgets, Identify and Measure (see Map tools), and Help.
Every bar between two areas drags, across or up and down, and takes the arrow keys when it has the focus. A double-click (or Enter) on a column's bar hides that column; the tab it leaves at the window's edge brings it back.
Every widget folds from its title bar, hides with its ✕, and moves by its grip: drag it anywhere in either column, or pick the grip up with Enter and use ↑ ↓ (order) and ← → (column), then Enter to put it down. A folded widget says what it holds in its title bar (Identify the place, Measure the total, the layer list how many layers are on).
Tabs inside a widget. Four widgets show views of one thing as tabs under their title bar: the Route planner (Stops, Options, Advanced), the Elevation profile (Elevation, Road class, Surface), the Library's item panel (Overview, About, Sharing) and Help (Keys, Tour, Guide). Tab reaches the open tab, ← → move between tabs and show them, and the arrows inside a tab work as in any widget. Escape inside a tab goes back to its tab. Each tab keeps its own folds. The tab each widget shows is saved with the window and with a project; a project saved before the tabs opens on the first tab.
The dock under the map. The wide, flat widgets — the elevation profile, the attribute table, Measure and Help — open beside the map like every other, and each carries ⬓ Dock under the map in its title bar. Under the map, one widget keeps its own title bar; two or more become one dock with a tab per widget: one height, one bar to resize it, one fold. Click a tab, or give the tabs the focus (Tab) and use ← →; ◨ Move beside the map next to the open tab sends it back to its column. Dragging such a widget by its grip shows a place at the map's foot, Drop to dock under the map; from the keyboard, pick the grip up with Enter and press ↓ at the bottom of its column to dock it, ↑ to bring it back. F, M, P and ? open their widget's tab, and View lists the dock with the columns. The table's profile under a selected line stays inside the table's tab.
A widget can float over the map — only when you do it. Every widget of both columns has Float over the map in its title bar (the icon beside Hide), and Shift+F does the same from inside the widget; View lists a Float row per widget and Dock all widgets back. Floating, the widget keeps its content and its focus; its column keeps a dashed row at its place, with the button to bring it back, and the same button on the widget now reads Dock back. Drag it by its title bar; size it by any edge or corner (at least 280 × 160 px, at most the map less 12 px a side; in a window that draws one column, at most 70 % of the map). It works with a mouse, a finger or a pen. A part of its title bar, 96 px at least, always stays on the map. The last one you touched is on top. From the keyboard, Tab to the widget's title and press ← to reach the grip, press Enter to pick it up, move it 16 px with the arrow keys, size it from its bottom right corner with Shift+arrows, and put it down with Enter, Space, Tab or Escape. Escape on a floating widget first takes the focus to its title (after closing whatever is open in it); Escape on the title docks it back. Tab reaches a floating widget in the place its column keeps for it. The place and the size are saved with the window and with a project — not shared, not in a GPX; a project saved before opens docked. The map's toolbars, the rail, the top bar, the status line and the dock under the map never float; a widget in that dock goes to a column first. If the map becomes smaller than 320 × 200 px the widgets are drawn docked, and come back where you left them when it grows.
Both columns keep every widget usable. Each widget has a smallest useful height (the profile 160 px, the layer list four rows). When a column cannot give each open widget that much, widgets fold to their title bars: on the right first what the map gave you (Identify, Measure, a report), on the left the tools and the route briefing; the oldest first, the profile, the layer list and the route planner last; the one you opened last never. Opening a folded one folds the next oldest. Nothing of your arrangement changes: the sizes you set come back as soon as there is room. The columns keep their widths in a wide window; the map takes the rest.
Discover, one tool at a time. Opening a tool — from the Discover list or from its own title bar — folds the other Discover tools open in that column to their title bars, each with its count and kept (50 kept): what it found is still there when you open it again. A tool you moved to the other column stays open.
The map's tools are toolbars docked on its edges, never floating over it: Layers (slope, curvature, dirt density, dirt passages, live traffic, the TET network, live riders — those of them you keep in Preferences › Map, in the layer list's order; the dirt passages chip's ▾ opens its settings in the layer list) and Map tools (zoom, north up, identify, measure, draw, report). Drawing adds an Editing toolbar of its own, and the weather timeline a Weather one on the map's bottom edge (see The weather timeline). Drag a toolbar's grip and it snaps to the nearest edge, or pick the grip up with Enter and press an arrow key; each one folds to its name. A status line under the map shows the position under the pointer, the measured distance and the map's short notes.
View in the top bar shows or hides any column, widget or toolbar, and resets the window.
Both columns stay open while the map keeps 480 px beside them at their widths (at the default 380 + 420 px, from about 1,350 px wide). In a narrower window one side column is open at a time — the one you opened last; the other waits as its tab at the edge — the rail shows its icons and the Layers toolbar starts folded. Narrow a column and the other comes back (at 1280 px wide, 340 + 300 px leave the map 570 px); widen the window and both come back as you left them. A column you opened is never hidden while both fit. The top bar's pages that do not fit go under More ▾ at the end of its row (at 1024 px: Roadbook, Stories, Friends, Preferences): ↓, Enter or a click opens it, ↑ ↓ move, Enter opens a page, Escape closes it. When it holds the page you are on it is marked as that page's button would be.

The arrangement is kept in this browser, per account, and comes back after a reload.

Preferences and your account

Two pages, each with its sections in a list at the left and the section at the right, the way System Settings and QGIS's Options are laid out:

Preferences — the top bar's Preferences, or the rail's ⚙ — is the app's: what the planner does by default and how the window looks.
- Map: the default basemap (the phone's catalogue), and Map layers the planner offers: a box per map layer your plan has, in the layer list's order, every one ticked until you untick some. See Layers on the map.
- Map also has Map colours: Standard or Colour-blind safe (see How it looks).
- Appearance: the Theme (Auto, Light, Dark), the UI scale, and the language. Theme and scale are kept with your account, so another computer opens the same way; the language is kept in this browser, and the switch in the top bar is a shortcut to the same choice.
- Planner: the default profile a new plan starts on, and the routing values your account keeps — Gates and closures, Max detour, how long a dirt-first route is checked against your dirt profile, and the wild camp search's distances from buildings and roads. These are one value each: the route widget's Options tab and the Wild camp tool change the same ones for the ride you are planning.
- Rider reports (when your plan has them): who sees a report you send.
- Lines and markers: the colour, width and pattern of the route, the way back of a round trip, imported tracks and route groups, and the waypoints' colour and size.
- Offline: what is planned for an installable desktop app.
Account — your account name in the top bar — is yours: You (display name, home region, bio, units; who you are signed in as, and your email), Garage, Riding profiles (what My profiles was), Devices, Your data and, last and in red, Delete my account.

From the keyboard: ↑ ↓ move along the list (Home, End to its ends), Tab goes into the section, Escape comes back to the list. The section is in the address (/me/preferences/planner, /me/account/garage), so a link opens it and a reload keeps it; each page opens on the section you had open last. In a window narrower than 1,024 px the list becomes a row above the section, and ← → move along it. The old addresses /me/settings and /me/modes open Preferences and Account › Riding profiles.

Layers on the map

The Layers on the map widget (Y brings it forward) is the one list of everything the map can show, in three groups:

My layers — what you put on the map: the planned route, the plan's GPX files, imported tracks, library items shown for comparison, your drawing layers and your measurements. Each has an eye, a swatch in its own look, zoom to (⌖), its attribute table (▦, on a drawing layer and on a layer from the library or a file: see The attribute table), and its style (🎨): colour (a row of swatches, ← → along them, or any colour written as #rrggbb), width, line pattern (solid, dashed, dotted, dash-dot), the fill of an area, opacity, and for points a symbol (circle, square, triangle, diamond, star, pin) and a size. Reset goes back to the layer's own look. The list is the drawing order: the top row is drawn on top. Drag a row by its grip (⠿), or pick the grip up with Enter and move it with ↑ ↓; a layer you add after that goes on top. When library items are on the map, ▦ Library layers on the map above the list opens one table of all of them.
Map layers — the map layers the planner offers you: every data layer the rider app can show unless you left it out in Preferences › Map, under the app's names and in the app's order: speed cameras, gas stations, beaches, practice grounds, slope shading, curvature, dirt density, dirt passages, live traffic, the weather timeline, advisory zones, draft areas and rider reports, then the desktop's own TET network, riders live and street-level photos. A layer that is on shows its legend under its row — the curvature and slope ramps, the dirt grades (on Dirt passages; Dirt density says what its hexagons are), traffic by severity, the weather's colours, the zones' tiers, the kinds of rider report. ⚙ opens a layer's settings: the opacity of slope, curvature and the TET network, and the dirt passages' profile, view and filters (the same ones as the Dirt tool). The dirt layer is two rows with an eye each: Dirt density, the hexagons you see zoomed out, and Dirt passages, the lines from zoom 8; either can be on without the other, and a layer list or project saved before the split comes back with both on if its one dirt switch was. Curvature and dirt draw on both sides of a border: the dirt rows read one archive that holds every country's passages, and curvature draws each country's archive the view reaches, so a view of eastern Norway shows Norway's roads and Sweden's. Gas stations and beaches follow the map's centre (within 30 km; zoom in to load them). Practice grounds follow it too, wider (within 100 km, from zoom 7), each pin coloured by who may ride there: green open to the public, amber members only, grey access not stated; click one to open its card in the Practice grounds tool. Speed cameras ask first: ticking them shows the wording that puts the legal check on you, and only Show speed cameras on the map turns them on. Street-level photos draws where Panoramax and Mapillary have pictures of the road as thin, see-through lines. Zoomed out, those are the cameras' own tracks: Panoramax's in green from zoom 6, Mapillary's in teal from zoom 10. From zoom 14 the layer draws one line per road instead, on OpenStreetMap's own road geometry, with every drive folded into it: green where Panoramax has pictures of that road, teal where Mapillary has, indigo where both have. That matched coverage is derived from the pictures' metadata and served under ODbL 1.0, credited to OpenStreetMap, Mapillary and Panoramax; the pictures themselves stay the contributors' own. Click a line to see the picture nearest your click in the Street-level photos widget, or drag the 📸 camera from Map tools onto the map (the lines show while you drag, even with the layer off) and drop it where you want to look (see Map tools). Its legend says when Mapillary is paused for the rest of the day (the pictures it already sent still show). The pictures are the contributors' own, under CC BY-SA 4.0; the widget names the contributor under every one. More layers… at the end of the group opens Preferences › Map, where the rest are.
Basemap — which basemap the map shows; on our own (Adventure · Europe & Africa, the one the rider app has), day or night, Nature detail (tree types and wetlands close in) and Badge density (how many food and lodging badges a town shows). Preferences › Map keeps your default basemap. The old Adventure · Norway is gone: a project or settings saved on it open on Europe & Africa, by day or by night as they were.

Choose the map layers the planner offers. Preferences › Map › Map layers the planner offers has a box per map layer your plan has, every one ticked until you untick some; Tab goes from box to box and Space ticks or unticks one. Your choice is kept with your account, so another browser shows the same list. A layer you untick leaves the list, the Layers toolbar and the map. A layer you left out that something else switches on still shows, for this session only: the Dirt tool's Show dirt passages on the map, W for the weather timeline, a project you open with the layers it was saved with. That layer is then in the list until you reload; your choice in Preferences is unchanged. V and the 📸 camera open a street-level picture whether the photos layer is offered or not.

Drawings are layers. What you draw goes into a drawing layer: the first drawing makes one called Drawings, and + Drawing layer makes another and asks its name. Each is a row of the list — name it (🏷), style it, hide it, draw into it (✎ switches the editor on), delete it (asked first; undo in the editor brings it back). The editor shows which layer you are drawing into, and a feature moves to another layer from its card, keeping its fields. Your measurements are a layer too, with an eye and a style; the Measure widget still lists each one.

Map tools: identify, measure, draw

The Map tools toolbar's four tools are one at a time: switching one on — identify, measure, draw, report, the attribute table's select box, or a tool's "pick a place on the map" — switches off the one that was on, and its button un-presses.

Identify (ⓘ) arms a click: point at the map and the Identify widget lists what is there — the height and the ground's slope, on our own basemap what land it is (forest and its kind, meadow, wetland, a protected area — information, never a permission to ride or camp), and, on your planned route, its kilometre, height, grade, surface, posted limit and the time to get there (the profile's marker and card move to that place); then each of the app's layers with what it has at that point (a rider report, a dirt passage, a result, a track, a drawing, an advisory zone…), each feature with its attributes and an Open that does what a click on it would; and the basemap's own features (roads and tracks, land cover, protected areas, barriers, contour lines…). Copy and Share give the whole answer as text, starting with the place's coordinates (Share uses your system's share menu, or copies the text with a map link). I does the same at the cross in the middle of the map without arming the tool. The widget's ✕ clears the answer and its pin. Under the coordinates, Identify says how many street-level photos lie within 50 m, with Open, and offers Open in Google Street View ↗. When the point is on your route, Google opens facing the way the route runs.
Street-level photos (📸, V) opens the picture nearest the cross in the middle of the map, within 50 m, in the Street-level photos widget. A click on the layer's lines, the camera dragged from the toolbar and dropped on the map, or Identify's Open does the same at that place. A 360° picture can be dragged to look around (the arrow keys turn it while it has the focus). A flat one zooms with the wheel and pans with a drag. ◀ ▶, or ← → while the widget has the keyboard, step to the previous and next picture of the same drive, keeping the direction you were looking. Two round arrow buttons stand over the bottom of the picture, on a ring drawn on the road, and point at those pictures as you look around; click one, or reach it with the keyboard and press Enter or Space, to go there. A drive that jumps far gets no arrow. The map follows you: each new picture brings its camera to the middle of the map, zoomed in to at least street level. A marker on the map shows where the camera stood, its cone turning as you look around. Face the route turns a 360° picture to the way your planned route runs there; it works within 30 m of the route. Under the picture are its source, contributor, date and licence, each linking to its page (a Mapillary picture also carries Mapillary's logo). Below that, Open in Google Street View ↗ opens Google's own pictures of the same place in a new tab, facing the same way: Google's coverage is the most complete, but its terms do not allow it inside a map like ours. Copy and Share give the place, the source, the contributor and the date, with the picture's link. The ✕ or Esc closes the picture and its marker. The same Google link is on every stop's card in the route's briefing (start, vias, destination), facing along the route.
Follow the route rides your planned route in street-level photos. Turn it on with the switch in the Street-level photos widget, or with the 📸 in the elevation profile's title bar, which also brings the widget forward. The profile's cursor then drives the picture: point at the profile, at the route line on the map, at a briefing item, or walk the profile with ← →. The widget shows the picture nearest the cursor, within 30 m of the route, and a 360° picture faces the way the route runs. The picture changes once the cursor rests for a moment, so a sweep across the profile asks only for where it stops. ◀ ▶, ← → in the widget and the arrows in the picture now step to the previous and next picture along the route, from either source, and move the profile's cursor and the map's pin with them. Under the picture is its place on the route (km 182.4 of the route), and how far ahead of the cursor it is when none was right there. Where the next 500 m of the route have no pictures, the widget says Off the route, with Google's link at that place and Jump ahead, which looks on along the route, a kilometre at a time, for the next stretch with pictures and takes the cursor there. The ✕, Esc or the switch turns it off; so does clearing the route.
Measure (M) brings the Measure widget forward. Click to add points; while you measure, the line follows the pointer from the last point, with the length from that point and the total beside the pointer. A double-click (or Enter on the map) finishes a path; a click on the first point closes an area. The widget lists every measurement — each segment with the running total, and the perimeter and area of a closed one — with Copy, Share, zoom to, delete and Keep as a drawing. Esc takes back the line being measured, then switches the tool off; measurements stay on the map until you delete or clear them, and a project keeps them.
Draw (D) switches the vector editor on and adds the Editing toolbar, which holds every action of the editor, each with a key: select and move points (S), add a point (1), draw a line (2), draw an area (3), split a line at a point (X), delete (Del), zoom to the selected feature (Z), make a line a track of the plan (T), save the selected feature to the library — or back to the library record or track it came from (L) —, discard the changes of a feature opened from a track or the library (Q), save all the drawings as a GeoJSON file under a name you choose (E), undo and redo (Ctrl Z, Ctrl Shift Z; ⌘ on a Mac), and, while drawing, finish (Enter or a double-click) and cancel (Esc). While a line or an area is being drawn it follows the pointer from the last vertex. These keys answer only while the editor is on; ? lists them. What you draw goes into the drawing layer the editor names (see Layers on the map).

The attribute table

The Attribute table widget (F, or ▦ on a layer's row) shows a layer's features as rows and their attributes as columns, as a desktop GIS does. Each layer has its own table; several open as tabs, and ＋ beside the tabs opens another layer's.

The tables there are. A drawing layer: a row per feature, a column per field its features have, then each one's kind, length and area. A library item shown on the map: its record's name, category, date, km, duration, tags and stars (its description and its last change can be shown too). A set of points: a row per point, with its place. And Library layers on the map: every library item on the map in one table, to compare them.
Sort, filter, search. Press a column's name to sort by it: up, down, then not sorted. Under each name is a filter: words the cell contains, =x for exactly x, >10, <5 or 10..20 for numbers, - for an empty cell. A field you typed numbers into sorts and compares as numbers. The search box looks in every column shown. ▥ chooses which columns show and in what order.
Linked to the map both ways. The selected rows are drawn in yellow on the map. A click on a feature of a layer whose table is open selects its row (Shift, Ctrl or ⌘ adds it), and the table scrolls to it. ⬚ selects with a box dragged on the map: a map tool like the others (one at a time), it stays on until you press it again or Esc. ⌖ zooms to the selected rows, ◧ shows only them, and the selection can be made all rows, inverted or cleared. With one line selected, its elevation profile is under the table, with its length, climb and descent; pointing at the profile marks the place on the line.
Editing. Enter or a double-click edits a cell; Enter keeps the value and Esc leaves the cell as it was. ✎ sets one column of every selected row at once. On a drawing layer each edit is one undo step (↶ ↷, or Ctrl Z with the focus in the table), and ▥ is the table manager: add a field to every feature, rename a field across the layer, delete one (asked first). A library item's name, description, tags and stars are saved to your library straight away; if the item changed somewhere else since it was read, the table reads it again instead of overwriting it, and says so. Kind, length, area, dates and km are worked out, not typed.
Copy, Share and CSV give the rows and columns shown: Copy pastes into a spreadsheet's cells, CSV is a file a spreadsheet opens.
From the keyboard the grid is one Tab stop. The arrows move between cells, Home and End go to the first and last column, Ctrl Home and Ctrl End to the first and last row, Page Up and Page Down a page. Space selects a row or takes it out, Shift ↑ ↓ selects several, Ctrl A every row shown. On a column's name Enter sorts; on a filter it types into it. ↑ from the column names goes back to the table's toolbar.

A project keeps which tables are open, their columns and their sort. It does not keep the selection, the filters or the search.

The Library

Library in the top bar is a second room of the same window: the same map, with the Library's own widgets around it and its own arrangement. What you arrange here (a column's width, a widget moved or hidden, the View menu) stays the Library's, and the planner's window stays as you left it.

The map is the library; the list is its index. The Results widget on the left lists what your library holds, and the map draws every listed item in the colour of its category (the same colours as in the rider app): its line when you are zoomed in, and numbered clusters and start points when you are zoomed out. The rail at the far left switches between All items, your Collections and the Trash, opens Import (below) and Links, and brings the layer list forward.

Where it looks. This map area lists what touches the map as it is now, and asks again once your pan or zoom has settled (one ask for the view you stop at, not one for every step of the pan). Typing in the search looks everywhere; clearing the text goes back to the map's area. One click on This map area or Everywhere changes it either way. If the server asks you to slow down, the items stay on the map and in the list, a quiet Waiting for the server… note shows, and the room asks again by itself a few seconds later.
Places and coordinates. While you type in the search, Places sits above the list: the cities, roads, addresses and other places named like what you typed, ranked from the area the map shows (as the planner's place search ranks them), each with its kind and its distance from the map's centre. Three show at first; More places shows up to ten. A road the map data holds in pieces is one row that frames the whole road. Best match or Nearest (the rider app's two orders) is remembered in this browser. Coordinates work too, latitude first: 60.30, 5.47, 60.30 N 5.47 E (with N, S, E and W the order is free) or degrees and minutes such as 60°18'N 5°28'E; the row names the nearest place. Picking a place takes the map there and marks it with a red pin until your next search; the box empties and the list shows what your library holds in that map area. Enter on a coordinate goes there, and Shift+Enter goes to the first place. Something written like a coordinate that is not one (a first number over 90: longitude first is not read) is said in words, and nothing is searched.
Category chips with counts. Each chip shows how many items of that category the current scope holds. A category with nothing here is dimmed, not removed. A tag filter and the sort order sit beside the scope.
Never a silent cut. At most 500 items are listed and drawn at once. When your query matches more, the header says so ("500 of 1,240 items"): zoom in, search or choose a category to see the others.
Linked both ways. Point at a row and its line lights up on the map; point at a line and its row lights up and scrolls into view. A click on a row selects the item and fits the map to it, and the list stays as it is, so you can go on to the next row. A click on the map selects the item under it; a click on a cluster zooms into it.
Selecting several. Ctrl (or ⌘) adds an item or takes it out, in the list and on the map. Shift selects a range in the list and adds an item on the map. The ⬚ button of the Library toolbar arms a select box: drag it on the map and the items inside are selected (Shift adds them); Esc puts it down. Selected items are drawn in yellow, as selected rows are in the attribute table.
The eye. The eye at the start of a row shows or hides its item on the map without selecting it; the header counts what is hidden, with Show all.
The item, beside the list. As soon as one item is selected — a row, or a line or a point on the map — the Selection panel in the right column shows it; there is no separate page for an item any more. It is a widget like the others: fold it, move it, hide it (✕; the next item you select brings it back). The panel shows:
- its name (✎ renames it in place: Enter saves, Esc leaves it), its category and date;
- its figures: length, time, ascent and descent, the height range, and the highest point — click it and the map eases there, with the profile walked to the same place and a pin on the line;
- its off-road share, under the figures: "42 % unpaved · 18 km gravel · 4 km dirt", the same number the planner gives a route, measured by the server for every line in your library without your asking. It says not matched to the road network for a line the engine matched too little of (under half its length), and not yet measured for one the server has not reached yet — never a 0 % it does not know. The share is also a badge at the right of each row in the list;
- what can be done with it, in one bar: Load into planner (over a plan already there, the planner says it replaced that plan, with Undo; its arrow ▾ holds the other way in, Send to planner as layers), Send to phone, More ▾ with the rest grouped — On the map: zoom to it, edit its geometry, make or open a roadbook; File: export as GPX or GeoJSON; Organise: duplicate, add to a collection, attach to an event, run full stats — and Delete apart at the right (restore, in the trash);
- under the action bar, three tabs. The name, the figures and the action bar stay above them whichever is open:
- Overview: its elevation profile, linked to the map both ways (point at the profile and a dot marks the place on the item's line; point at the line and the profile's marker moves there; from the keyboard the profile walks along the item with ← →), or what a collection holds; and your stars;
- About: the description and the tags, each edited in place and saved straight away (if the item changed somewhere else since it was read, on your phone or in another window, it is read again and nothing is overwritten: look at it and try again); its links (the track a roadbook was made from, where a recorded ride comes from; a linked item opens in the panel); the AI trip story for a recorded ride;
- Sharing: the collections it is part of, whether it is on your phone, who it is shared with (a link to copy once, update or stop), the public map, and the leaderboard of a trail that has one. The tab is greyed out when none of that applies to the item.
The item in the panel is read in full and drawn at full detail on the map; the other items stay light. An item you have opened is marked ✓ in the list.
Several selected. The panel then offers Show only these (the map draws the selected items alone), Zoom to them, Clear, and only what applies to every one of them: send to the planner as layers, send to phone, duplicate, export, share, attach to an event, run full stats, delete.
Send to planner as layers. The selected items (one or many) join the planner's layer list, under Library layers on the map: lines and points to look at while you plan, never part of the route. You stay in the Library, so you can send more; a note says how many went, which were there already and which could not be read, with Go to the planner. An item is never added twice: sending it again shows it if you had hidden it. Items in the planner's layers say so in the panel. A saved project keeps them by reference and reads them again from the library when it is opened.
Send to phone. The selected items (one or many, up to 20 at a time; a collection counts as one and opens with its items) go to your own phones as one notification, Open on your phone, in the language the desktop is in. A tap on it opens them in the app: a planned route in its planner, ready to ride; any other single item in its Library, selected; several items fitted on its map. An item shared with you goes too, and opens through the share. You stay in the Library; a note says how many of your phones it reached and what opens there. When it reached none, the note says why and what to do: no phone is signed in to the app with this account (sign in there, allow notifications, send again); your phones have the app's notifications off (where to switch them on); the server cannot send to phones right now; an item can no longer be read (deleted, or no longer shared with you: nothing is sent); or you sent too often (six a minute, sixty a day; it says when to try again). If the note says it was sent and nothing shows on the phone, a Focus or Do not disturb there is holding it: allow the app in it. Escape or ✕ puts the note away. Nothing is copied: the phone reads the items from your library, so it needs a connection when you tap.
Run full stats. The figures above are measured for you, so you rarely need this; it re-measures the surface of the lines you have selected (up to 500 at a time) when you have edited one, or when a line was measured before the engine knew that ground. A note says how many went to the server and how many were skipped (anything that is not a line of your own); the figures appear on the rows the next time the list reads your library.
Fit the map to the results (⤢ on the Library toolbar) brings everything the list holds into view.
The route planner's data. The Library and the planner share one map. In the Library the planner's content — the route and its stops, your files, comparison layers, drawings, the tools' results — is put away, so the map shows your library alone, with the map's own layers. The first button of the Library toolbar brings it onto the map here too; your choice is remembered in this browser. Back in the planner everything is as you left it.
List or table. Table shows the same result as a table, a row per item and a column per field (name, category, date, km, duration, tags, stars, and % unpaved): sort by a column, filter under each header, save the rows as CSV, and edit a name, the tags, the stars or the description in the cell. What the server measured of each line is there as columns too — % unpaved, the paved, gravel, dirt and unknown kilometres, ascent, descent, the highest point, and when the surface was measured; the share is shown and the rest wait behind the columns panel. They sort as numbers and filter like them (>50, 10..40, - for the lines not measured yet), and they go into the CSV as they are shown. The same columns are on Library layers on the map in the planner's attribute table. An edit is saved to your library straight away; if the item changed somewhere else since it was read, it is read again and nothing is overwritten. The table's selection is the map's.
From the keyboard. / goes to the search. ↓ in the search goes to the first place, ↑ ↓ move along the places, Enter goes there, Esc (or ↑ on the first) comes back to the box, and ↓ past the last goes on to More places and the list. The list is one stop of the window: ↑ ↓ move through the rows and the map follows, Enter opens the item in the panel and moves the keyboard there (Esc brings it back to the row), Space switches its eye, S selects it or takes it out, Shift+↑ ↓ select from the last row chosen and Ctrl A selects every row. A opens Import and export. I (identify), M (measure), Y (layers) and ? (Help, on its keys) work here as in the planner.

Collections

A collection is a named group of your items: a trip, a season, an event. An item can be in any number of collections, and a collection keeps its items in the order you give them. It has no line of its own: on the map it is its items.

Make one from the selection. Select one item or several, then Add to collection… in the Selection panel. One field does both: type to find one of your collections, or type a new name and choose New collection. ↑ ↓ choose, Enter adds, Esc closes. An item that was in it already stays where it was, and the note says so; Open the collection goes there.
Collections on the rail lists them, each with how many items it holds. In All items a collection is listed too when one of its items is in view. A collection's eye shows or hides all its items on the map at once.
Inside a collection. Enter on a collection (or Open inside in the panel) lists its items in the collection's own order, numbered on the map. The trail at the top goes back (Backspace), and its eye shows or hides the whole collection. Move an item with Alt+↑ ↓ or drag it by its grip (⋮⋮); take it out with Delete or its ✕: it stays in your library. If the collection changed somewhere else since it was read, the new order is not saved: it is read again and the list says so.
In the panel. A collection shows what it holds, in order; an item shows the collections it is part of. Each opens in the panel. Send to planner as layers and Export on a collection act on its items. Delete on a collection puts the collection alone in the trash: its items stay.
Keep on my phone. A switch in the panel marks an item, or a collection with its items, for your phone. An item kept through a collection says so. Taking an item out of a kept collection keeps it on the phone, so nothing disappears from a phone without you asking.
Sharing a collection shares its items with it, in order, by the rule for each item (a TET trail's line is not handed on). A link to a collection shows its items, each with its own GPX where it may be shared.
The table has a Collections column (by name), an On phone column and a Public column.
In QGIS a collection is a layer of its own, library:<id> (and library:<id>:line and :point when it holds lines and points), on the same /ogc connection as your library.

On the public map

A collection of yours can go on the public map, the public OGC API at oapi.fastgis.eu, where anyone can read it without a key, in QGIS or any OGC API - Features client. Turn on Publish on the public map in the collection's panel (or select several collections and choose Publish on the public map in the panel). Before anything goes public, the panel asks, and lists the collection's items under what the public will see of each:

Drawn as saved: planned routes, curvy roads, MTB trails, roadbooks.
Trimmed: recorded rides, waypoints and captures, with your privacy zones and the ends of each ride removed. A ride that is too short after that, or a point inside a zone, is withheld.
Listed without its line: TET trails, imported tracks, bookmarks and signals, by name only.

Publish puts it on; Cancel or Esc leaves it off. While it is public, the row says Public, and the panel says since when and shows the public link with Copy link. Items you add later are public too. Turning the switch off (or Take off the public map) takes it off at once, without asking. Putting the collection in the trash also takes it off, and Restore brings it back unpublished. Only you, the collection's owner, can publish it: a rider you shared it with cannot.

Import and export

Import on the rail (or A) opens Import and export in the left column.

Files. Drop GPX, GeoJSON, KML, KMZ or FIT files on the box, or anywhere on the map, or press Choose files; several at once. Nothing is saved yet: the server reads each file as it came and answers what it would create, which is shown in Preview: what will be created in the right column and drawn dashed on the map (point at a row and its line lights up, and the other way round).
Several tracks in one file. When each track starts where the one before it ended (within 2 km), as the days of one ride do, the file becomes one item that keeps each track as a part of its own: the preview says "3 tracks · kept as one item", and the map draws the days without a line between them. When the tracks lie apart, as the trails of a TET country file do, each track becomes an item of its own ("17 tracks · one item each"), keeping its own name. A switch on the row changes it before you save. One GPX track made of segments far apart (more than 2 km between one and the next) is also one item that keeps them as parts. Waypoints become waypoint items, linked to the line.
What it becomes. Each row shows the name of the one item (from the track, the file or its title; change it before saving), tags to add (comma-separated; on every item the file makes), the category (imported, its points waypoint), the length and the number of points.
Already in your library. A file whose line you already keep, point for point (in either direction), is marked already in your library, with Open it, and is left unticked; split into one item per track, the file is marked so when every track is there already, and says how many are when only some are. The same file twice in one import is marked too. Tick it to save it anyway.
Save saves the ticked rows. Each row then says saved, with Open it and Move to the trash to undo the import. Clear empties the list (saved items stay in the library).
Files to hand out. Any other file, such as a briefing PDF, a photo of the start or a ZIP of entry forms, is kept as it is, to attach to an event so its riders can open it. Drop it on the second box or press its Choose files; several go up one after another, each with its progress. The rules are said before the pick and checked before a byte is sent: at most 60 MB a file, and 1 GB for your files together (files in the trash count). Programs, installers, scripts, web pages, SVG and XML are refused, and a GPX, KML, GeoJSON or FIT file is sent to Files above instead. What the server refuses on reading the file is said in words on its row. Show my files lists your files from everywhere: a file has no place on the map, so This map area never shows it.
A file in the Library. A file's row says what it is and how big ("PDF · 2 pages · 1.4 MB"). Its panel has Open: a PDF or a picture opens in a new tab, anything else is saved. When the browser gives no tab, the file is saved and the panel says so. A file is attached to an event like any record; it is not copied or sent to the phone.
A web address of a file. Paste the address of a GPX, GeoJSON, KML, KMZ or FIT file and press Preview: the server reads it (public addresses only) and it is listed and drawn like a file, with nothing saved until Save.
Items made of several tracks. In the Library every item made of several tracks is drawn by its tracks, without the straight lines between them; the item open in the Selection panel at full detail.
Export. Choose Selection (what is selected in the list or on the map) or The list (everything the list shows), then GPX, GeoJSON, KML or Zip, and press Export: one file with every item, lines as tracks (an item made of several tracks keeps them apart) and points as waypoints (GeoJSON keeps the name, category and tags; KML opens in Google Earth); Zip gives one GPX file per item, for one item as for many. One item is named after itself; several are named after the library and the date. Export in the Selection panel writes one file in the same way. Items shared with you are exported too, except what their owner may not pass on (a TET trail, a file they imported): those are left out and named. A GPX file you exported, dropped back, gives each item again with its tracks and their names, and says already in your library.

Practice grounds

Practice grounds (Discover on the rail) finds places to practise off-road riding around the map: motocross, enduro, trial, supermoto, speedway, karting and other motor-sport grounds, from OpenStreetMap. Pick the kinds with the chips (none picked means every kind) and a radius (25 to 250 km), then Find. The list starts with the nearest; each ground says its kind, how far it is and who may ride there. Grounds OpenStreetMap marks private, or that lie inside a military zone, are never shown. Most grounds say nothing about access, so they are shown with Access not stated in OpenStreetMap: check before you go.

Click a ground, or press Enter on its name, to open its card:

its kinds, and the legality line: Open to the public, Members only, or Access not stated in OpenStreetMap: check before you go;
when it lies in a protected area (a national park, a nature reserve, a protected landscape…), a line that says so: local rules may forbid riding;
its facts from OpenStreetMap (size, surface, fee, opening hours, operator, phone), its website, and the date of the data with a link to the ground on OpenStreetMap;
the upcoming public events that meet there (within 500 m); click one to open it;
Route to it replaces your plan with a new one, from the point the search ran around to the ground (Undo brings your plan back); Add as a stop adds the ground at the end of your plan; Save to library keeps a copy, and the card then says it is in your library;
Hold an event here makes the ground the meeting place of one of your events.

The card opens under the ground's name, so Tab goes on from the name into the card's links and buttons, and Escape closes it. A ground clicked on the map, on the tool's pins or on the Practice grounds layer, opens the same card.

Hold an event here

Hold an event here offers the events you own or organise — not the finished or cancelled ones — and, above them, New trip meeting here, which makes a trip named after the ground in one click. Either way the ground becomes that event's Start stop, which is where an event's meeting place comes from: so the event then appears in this card's own list of upcoming events, and on the ground's card for other riders, once it is published, its visibility is listed, and it has a date still to come. A card lists upcoming events only, so an event with no start and no end never reaches one however rightly it is published — a trip made here has no date yet, and the confirmation says so and offers to open it and give it one.

An event that already has a Start stop is asked about first: a stop cannot be edited, only removed and added again, so replacing it is a real change to someone's schedule. Saving the ground to your library happens on the way — a stop always points at a library record — and a ground you had already saved is used as it is, under the name you gave it. Moving that bookmark in the Library moves the event with it.

While the dialog is open, Tab stays inside it and Escape closes it; the same two ways in are in the event console's Schedule tab, where the stop picker has Practice grounds beside your Library (see Events).

Links: the published catalogue and the reference data

Links on the rail lists, in this order: the published catalogue, then Curvy roads, Dirt passages, MTB trails, Beaches, Practice grounds and the trail library. ↑ ↓ move along it and Enter opens a row. A row your plan does not include is not listed.

The reference data rows open their tool in the planner, in its group of the rail. Every tool's cards (a curvy road, a beach, a camp spot, a ground…) work the same way: click anywhere on a card, or press Enter or Space on its name, to pick it on the map, and again to let it go; the picked card is marked ✓, and its buttons act without picking it. Every tool's cards have Save to library; a dirt passage's card has it too, and says In your library once the passage is saved, from there or from the catalogue.
The published catalogue opens beside the list, in the Library itself: what signed-in riders may see (dirt passages, rider signals and the published dirt-passages datasets today; curvy roads and places as their sources are added) and your own items. It has the same controls as the library's list: words, This map area or Everywhere, a chip per kind with its count (Dirt passages, Curvy roads, Places, Rider signals, Datasets, Mine), List or Table, 20 records a page with Previous and Next.
On the map a record is the box it lies in, dashed, in the colour of its kind (a place or a signal is a dot). The record you open is drawn as itself: the passage's or the road's line, the place's point. A click on a box opens its record; your own items on the map come first.
A record opens in the column beside the map (a click, Enter, or ›): its figures, and Save to library, which keeps a copy in your library that remembers where it came from. A dirt passage becomes an imported line (its ways joined, kept as parts where they do not meet), a curvy road a curve, a place a bookmark. Once saved the panel says In your library with Open, and the record is never saved twice. Show on the map fits the map to it; Open in Dirt passages or Open in Curvy roads opens its tool. Your own items say they are already yours and open in the Library. A rider signal is shown and not copied: it changes as riders report.
Several records (Ctrl+click, or Space in the list or the table): the column says how many, and Save N to library saves each one that can be and is not saved yet.
A published dataset is a whole region offered as one file, and the Datasets chip is how you find them: words do not narrow them. A dataset's box is its whole region, so This map area lists the ones that cover the view and Everywhere lists all of them. Opening one gives The published dataset: how many passages and how much dirt it holds, the OpenStreetMap date it was built from, the size of the file and its layers, then the licence and the credits — the dirt passages are published under the Open Database License (ODbL) 1.0, crediting OpenStreetMap contributors, Copernicus DEM GLO-30, Kartverket and Lantmäteriet, and using the data means keeping that attribution.
- Download gives you the GeoPackage, which opens in QGIS as it is. The browser downloads it itself — Norway is about 368 MB and the file that holds every published region about 1 GB — and a download that stops resumes rather than starting again. The file's sha256 is printed beside it, so you can check what arrived.
- Open the collection opens the dataset's OGC API Features collection in a new tab, which describes it and links to its features. Copy the address gives the collection's own address at api.fastgis.eu: that one is for QGIS and other GIS clients, and it needs your own API key, which the browser does not have.
- Save to library keeps the dataset in your library as a bookmark at the middle of its region, carrying the licence, the credits and the three addresses, so you can find it again without searching the catalogue.
- A region that is no longer published keeps its record and says so: the record is there, the file is not.

The address bar holds the query, so a filtered library is a link you can paste: /library?q=… for a search, ?bbox=… for a map area, ?cat=… for a category, and /library?scope=epona&q=… for a sentence asked of the Epona Library (below). While one item is in the panel the address is the item's own, /i/…, with the query after it: an item link (an old one too, or a "back to the item" link from the roadbook editor or a story) opens the Library with that item in the panel and the map fitted to it.

Ask the Epona Library

Under the Results search sits its scope: My library (your own items, with the chips, the area and the filters above) or the Epona Library: everything the Epona Library holds that you may see, from your own items to dirt passages, curvy roads, places and rider signals. In the Epona Library the box takes a sentence, in any of the app's languages: "strade bianche vicino a Petina", "curvy roads near Voss", "my longest ride last month", "how many km did I ride in 2025".

Enter or Ask sends it. Nothing is sent while you type: each question is read by our language model, and takes about two seconds (longer when the model has been idle). Places shows above the answers here too: picking one takes the map there and empties the box, so the next question's near me is that place. Enter on a coordinate goes there instead of asking.
Understood as. A line of chips says how the sentence was read: the place, the dates, the kinds, Mine, the words. A dashed chip (a length, highest first, Top 1) is applied by the Epona Library itself. A place the sentence names moves the map there. Near me is the map's centre: there is no GPS on a desktop.
Three groups. Mine, Shared with me and Epona Library, as on the phone. Shared with me stays empty for now: what other riders share with you cannot be searched yet. A question such as "how many km…" or "the highest point…" gets its answer on a card above the list. More loads the next 20 without asking the model again.
Linked both ways. The answers are drawn on the map as boxes in the colour of their kind. Point at a row and its box lights up; point at a box and its row lights up. A click selects a record and brings it into view; Enter (or ›) opens it beside the map with Save to library, as a record of the published catalogue does. One of your own items opens in the item panel.
From the keyboard. ↓ in the box goes to the first answer, ↑ ↓ move along them, ↑ on the first row goes back to the box, Enter opens, Space selects or takes out.
When it cannot answer, a line under the box says why: no connection, the Epona Library unavailable, or too many questions in a minute; Try again asks the same sentence again.

Asking by voice comes later.

The profile: a vehicle, then a style

At the top of the Route planner you choose how this ride is routed in two steps. First the vehicle — Sport, Touring, Adventure, Enduro, Car, 4x4, then Bicycle and On foot — with a line saying which bikes or cars it means. Then the style for that vehicle: Curvy and Fast for Sport; Scenic, Relaxed and Fast for Touring; Easy and Normal for Adventure; Light, Normal, Hard and Wet day for Enduro; Relaxed, Fast and Scenic for Car (an ordinary car, no dirt-first); Easy and Normal for 4x4. Each style has a line saying what it rides. A vehicle opens on its usual style (Sport · Curvy, Touring · Relaxed, Adventure · Normal, Enduro · Normal, Car · Relaxed, 4x4 · Normal). Bicycle and On foot have no styles yet. With the keyboard, ← → choose as they move along a row, and the route is asked once you stop on a choice (or press Enter): stepping from Car to Adventure asks for one route, not one per step.

The profiles come from the server, with their names in your language, and the desktop keeps the last copy, so the picker works offline too. Their values are marked provisional until they have been confirmed on a ride; a retune reaches you without an app update. A profile always keeps private and closed gates closed and avoids closures riders confirmed.

The route planner has three tabs. Stops: the vehicle and the style (this picker), the place search, the stops with their arrival times, Round trip, the alternatives and what the route went around. Options: the scenic bias, your pace, Dirt-first, this ride's Gates and closures ladder and Max detour (shown when dirt-first is on or the ladder is at its third stop). Advanced: every knob the routing server takes for the vehicle's engine, with the same words as the rider app, in four folds — Roads (open), Surfaces and grades, Costs and penalties and Advanced — each saying what it holds while folded; then Save as my profile and Reset to defaults. An amber dot on Advanced says the knobs differ from the profile (the style reads Custom). Under every tab stay the route's figures (length, time, unpaved share, ⌖) and its actions (Save, Send to phone, Roadbook, ⋯), so a change on Options shows its effect at once.

Gates and closures is one choice with three stops, each avoiding what the one before it does, and more; ← → move along it, and each move plans the route again:

Closed on the map: avoids the gates OpenStreetMap marks locked, private or closed for the season. It can't know what riders found closed, or the gates the map leaves unsettled: those are crossed and listed as in doubt.
Closed on the map or by riders (recommended, the default): also avoids the closures riders confirmed, and your own reports. It can't know a gate shut since anyone last mapped or rode it.
Also gates in doubt, when a fair way round exists: also tries a way round the gates the map leaves unsettled (no access tag, a seasonal rule it cannot check). The way round is taken only within your Max detour and when it keeps nearly all the dirt (95 % of the unpaved km); otherwise the gate is crossed and listed as in doubt, and the briefing says why. A ferry's port gate is never tried round: the ferry is the way. Loops and optimised tours ask for the way round too; a loop also keeps it only when it still meets its length and stays a loop.

No stop goes through a gate the map marks closed or private, except a ferry port's own gate: the ferry's landing is closed to everyone but its traffic, so the route keeps its crossing and lists the gate. The planner says it as the port's gate, never as one to turn back at: "Port gate at 1.1 km — locked: ferry traffic passes" (Bergen's Fjord Line quay), and the briefing counts it as a ferry port gate, not as closed. An account that had Avoid closed gates switched off moves to the stop that matches its rider setting, and the planner says so once. The stop is saved with your settings and with a project, and the route briefing says which stop the route was planned at.

The four groups:

Roads: highways, tolls, ferries, tunnels, living streets, Avoid untagged tracks (Norway, Denmark), top speed (a car's reads No cap until you set one), shortest distance.
Surfaces and grades: dirt-first with its max detour, trails and minor roads, tracks, hills, the hardest ground allowed.
Costs and penalties, in seconds: ferry boarding, toll booth stop and penalty, border crossing stop and penalty, gate stop and penalty. A stop also counts in the arrival time; a penalty only steers the route. With dirt-first on, gates weigh 60 s + 30 s until you change them.
Advanced, folded: the engine's own weights (road name changes, service roads, a fixed speed, and for a car time or distance). They move routes in ways that are hard to predict; leave them unless you know what each one does.

A car has the same groups without trails, hills, tunnels and the hardest ground; for bicycle and on foot there is an Avoid group with ferries. A knob past the first nine is sent only once you set it, so until then the server's own value applies. Every control works from the keyboard: Tab moves between them, the arrow keys step a slider, Space ticks a switch and opens Advanced. A few engine knobs (the private-gate penalty, ignoring live closures, searching every road, the adventure-riding axis) are kept for the routing engine group, admins and the accounts an admin added: they can route through private gates or closed roads, and for everyone else the desktop never sends them. Move any of them and the style shows Custom; the vehicle stays, so the route is still timed for it. Choose the style again to go back to it, or press Reset to defaults for the planner's own defaults. Choosing another vehicle or style while on Custom replaces your settings, and a line under the picker says so ("Your Custom setting was replaced by Enduro · Normal") with Undo, which puts every control back as it was; it goes when you move a control again or close it with ✕. One thing the sliders cannot do: Trails and minor roads is a preference among the roads the router already takes, and on a long trip it moves nothing by itself (Bergen → Eboli is the same road at 0.5 and at 1.0). The knob that adds dirt is Dirt-first; the line under the slider says so, and while dirt-first is on the slider is pinned and its hint reads as on the phone. Save as my profile… keeps the setting under a name of your own. It then sits in its vehicle's style row, and in Account › Riding profiles (your account name in the top bar opens Account), where you can also make, edit, copy and delete your profiles and give each one a line of description (shown under the picker, like the built-in styles').

The vehicle times the route. Every route the planner asks for names its vehicle, and the server times unpaved ground at that vehicle's pace; the line under the route time says which ("Timed for Enduro").

One leg, another profile. The chip between two stops sets the profile of that leg: this ride's profile, any profile by vehicle, or one of yours.

The default lives in Preferences. The profile you choose in the planner is this ride's, and it is still there after a reload. Preferences › Planner › Default profile is where a new plan starts: Clear plan and New project go back to it. Use this ride's profile copies the planner's choice there. With no default, a new plan keeps the profile you rode last.

A plan, project or library route saved with one of the old riding modes (Twisty Tourer, Fast Transfer, Scenic Cruiser, Gravel Curious) opens on the profile that replaced it: Sport · Curvy, Touring · Fast, Touring · Scenic and Adventure · Easy.

Other ways: alternatives and the scenic bias

Alternatives. Plan a plain A → B, two stops with nothing between them, and the planner also asks for the routing engine's other ways there, up to three, as the phone does. They are drawn as grey lines beside the route, each with a chip right next to it where it parts from the route: its name and unpaved share, then its length, time and how much longer or quicker it is ("Alt 1 · 30% unpaved", "48 km · 1 h 39 min · +51 min"). The chips keep clear of the route and of each other and follow the map as you pan and zoom; pointing at a chip lights its line, and pointing at a line lights its chip. The same figures sit in the Alternatives cards under the route summary: each card names its way, its length large, then its time and how it compares, and a badge where one way stands out — Fastest, Most dirt; the route you have is marked ✓. Click a line, a chip or a card, or move along the cards with ← →, and that way becomes the route; the old route turns into an alternative you can go back to. The briefing, the profile and the surface follow the road you chose. An alternative's gates are not checked (the briefing says so): the check that routes around closed gates runs on the main route only. The way you chose stays with the plan: after a reload, or in a project, the planner asks again and takes the same road if it is still offered. Any change of yours (a stop, the profile, an option) starts again on the main route. Once the forecast found rain on the way, Find a drier route ranks these same ways by the weather along each (see Arrival, pace and weather below).

The round trip. Under the route, the Round trip switch has three choices. Off ends the plan at its last stop. Same way adds the start as the last stop and rides the way out's own roads back, from where the way out ended, so the two halves meet at the turnaround. Different way asks the engine for other roads back and rides the one that shares the least of the way out. It asks with your own profile and options (the style, dirt-first and its detour cap, the scenic bias, the gate settings), so the way back is planned like the way out. The switch owns the return it adds: choosing another replaces it, Off removes it, and Clear leaves nothing of it on the map. When dirt-first is on and the engine finds no other road within the detour cap (every longer alternative is dropped there), it says so instead of adding the same road again; lift the cap on the Options tab, or take the same way back. ← → move along the choices, Enter or Space chooses.

Choosing the way back. On Different way every road the engine offered back is a row under the switch, with its km, riding time and the share it has with the way out; the one you ride is ticked. The others are grey lines on the map, each with a chip that says the same. A click on a row, a chip or a line makes that road the way back; with the keyboard, ← → move along the rows and Enter picks. ⇄ Swap way out and way back rides the chosen road on the way out and the way out's road back; the rows then offer ways out. A half is never a road turned around (one-ways, turn restrictions and ferries do not reverse): after a pick or a swap each half is routed again along its road, so its gates, notes and times are fresh. The choice is kept with the plan (a reload, your account, a project) and one undo takes it back. If you change the way out afterwards, the rows give way to Find the ways back again.

A round trip reads as two halves. Any plan that ends within 1 km of its start is a round trip, whether the switch closed it or your own last stop did (then the switch rests until you remove that stop). The way out runs from the start to the turnaround, the way back from there to the start again. Under the whole loop's figures, a Way out and a Way back row each give their km, riding time and arrival clock (at the turnaround, and back at the start), on the same clock and pace as the stops. The turnaround is the stop farthest from the start; any other stop between can take its place with Turn back here (⤺) on its row. In the stop list the turnaround and the closing stop say what they are, a Way back line follows the turnaround, and a Different way reads "← Way back, by another road". The route stays one route: saved, sent to the phone, exported or made into a roadbook as a whole.

Each half reads apart everywhere. On the map the way out is blue and the way back purple, each with its own direction arrows, a little to the right of its road, so a same-way-back shows both lines side by side; the turnaround's pin is ringed in purple. The ground colours are a layer of their own, Surface, drawn over both halves and shown or hidden from its row in Layers (the same switch as the eye on the briefing's Surface badge); its legend says what the four colours are — asphalt, gravel, dirt, not known — the same colours as the elevation profile's surface bar; paved is green, so no ground colour is ever blue or purple. In Layers the route is two rows, → Way out and ← Way back, under Surface: each has its eye, its style (colour, width, pattern, kept on your account, as under Preferences › Lines and markers) and ◉ to select it. A selected half stays lit and the other dims, whether you chose it there, on the map (a click on its line) or from its row under the route; choose it again for the whole loop. The profile tints the two halves, titles them with their km and marks the turnaround with a dashed line, its name and its arrival. In the briefing a gate, a steep stretch, a rider report or a note says its half, with the km counted from that half's start ("Toll booth · way back km 12.2"); each badge's figure ends with the split ("1 out, 1 back") and its list is grouped under Way out and Way back; a gate at the turnaround says "at the turnaround", and a moved turnaround reads "The way out ends 11.4 km from Middalen". From the keyboard, Tab reaches the two rows, ↑ ↓ move between them, Enter fits the map to that half and lights it, Esc shows the whole loop again.

The scenic bias, under the profile, leans a motorcycle or car route toward the best-rated roads near it: Off, Light, Moderate or Strong, then Bends or Climb for which roads count as best. It is the phone's Scenic bias (the same values), it is not part of the profile (changing it leaves the style as it is), and it stays with your routing choices and in a project. It only changes the route where a real alternative exists; on many trips the road stays the same.

Loops: two or three to choose from

Discover → Loop plans a round ride from a start (a point you pick, stop A, or the map's centre): a length, a direction, and the plan's own profile — the loop rides the vehicle and style the route planner rides, shown in one line (Enduro · Normal) with Change, which opens the planner's vehicle → style chips in place (a profile chosen there is the plan's) — with the planner's dirt-first and Advanced settings. Generate loop asks the server for three loops at once: one in the direction you chose, and one on each of its neighbouring headings (±45°). The loop in your direction goes on the plan straight away, as a line in the layer list, and the server's verdict says whether it met your ask.

When more than one loop comes back, the section shows a card for each: its name and heading ("Loop 2 · NE"), then its length, time, unpaved share, how much of it rides the same road twice, and its climb, its verdict in one line, and its badges in words: Best match (the closest clean loop to your length), Most unpaved, Least ridden twice and Most climbing. A badge is only given when the loops really differ on that number. On the map, the loops that are not on the plan are grey lines with a chip each, like the alternatives'. Pointing at a card, a chip or a line lights that loop and dims the others. Click one, or move along the cards with ← → and press Enter, and it replaces the loop on the plan; Undo puts the last one back. The arrows only show a loop, they do not choose it, so the route is not recomputed on every key.

Fewer loops than three come back when a neighbouring heading ends on the same roads as an earlier loop, closes no loop, or is not ready within the server's 10 s. The section says so plainly: "Only two loops here: the NE loop repeated loop 1." Around Bergen, for example, the 200 km loops of neighbouring headings are often the same loop. Taking the loop off the plan takes its cards and its map lines with it.

Under the cards, the verdict speaks for the loop on the plan: the length you asked for, the length it has, its loop quality and how much of it you ride twice (the stretches that go out and back on the same road), the same figure as its card. A loop that rides a third of itself twice is a different ride from one that never does, whatever its length.

The scenic loop (Discover → Scenic loop) works the other way round: you tick kinds of places (villages, historic sites, viewpoints, passes, beaches, forgotten places), it finds them within reach of your budget in km or hours, and you pick the ones to visit; Compute closes a round trip through them in the best order. Under the places, a Stops row adds Fuel and Food (restaurants and cafés). Stops are listed apart, under their own heading, and never take a place's slot: for each direction around the start it offers the one about halfway out, where a break falls on a loop, rather than the forty nearest restaurants in the town you start from. A stop you add still counts toward the trip's 15.

Curvy roads: which end, which first

Discover → Curvy roads finds the bendiest roads around the map's centre: a preset (Twisty, Scenic, Mixed), what the search ranks by, and under Filters the radius, the road classes (primary, secondary, tertiary and unclassified roads, all four by default, so a national road over a pass such as the RN9 at the Tizi n'Tichka is in), the surfaces, the length and the population cap. Rank by decides which roads come back: By bends, By length (the longest of the bendy roads the filters keep), By climb, By intensity, By tightness. The section keeps all of these in this browser and in a project, so it opens as you left it.

Once the list is in, Sort list by orders what came back without asking again: Rank (the search's own order), Length (longest first), Climb (the most metres climbed from the road's start to its end) and Distance (nearest to where the map's centre was when you searched or chose Distance). Climb and Distance add their figure to each card, "↗ 1,535 m" or "4.2 km away".

Which end is the start. A road runs from its first point to its last: its profile reads from left to right that way, Add as it is rides it that way, Add reversed the other way. While a card is picked or pointed at, or the pointer is on its road, the map marks the start with a green dot and an arrow the way the road runs, and the end with a red ring. A picked card names both ends by the nearest place ("▶ Evanger → ◉ Vaksdal"), or by their coordinates where there is none. Pointing at Add as it is or Add reversed (or tabbing to it) turns the marks as the road would be ridden and draws a dashed line from where your plan ends to the end that would join it; the button says "from Evanger to Vaksdal" or the other way round.

The profile and the map. The card's ⛰ opens the road's elevation profile and picks the road. Pointing along the profile puts a dot on the road at that place; pointing at the road on the map moves the profile's marker there. A click on the profile brings the map to that place. From the keyboard the profile is a slider: ← → walk along the road (Shift: ten times as far), Page Up / Down a tenth, Home and End the two ends, Enter brings the map there. The heights come from the national models where a country has one, then from our own Copernicus GLO-30 copy (Europe, North Africa, Arabia and the Sahel), then from global SRTM. Where none has a height the card says No elevation data; the road, its ends and its marks still work.

The route at a glance

The route briefing sits under the route planner: one badge for each thing the route holds, in this order — Gates and access (closed · in doubt · passable, where in doubt is a gate the map leaves unsettled, which the route crosses; Not checked when a leg could not be checked, never "none"; under it, the Gates and closures stop the route was planned at and what that stop can't know; at the third stop, the gates in doubt it went round and the km that added, or each gate it kept and why: no way round, longer than your Max detour, it would lose the dirt, the way round has as many gates in doubt or meets a closed one, a ferry's port gate, and on a loop its length or its shape), Ferries (when the route takes one; below), Surface (the unpaved share; it opens to the kinds of road the route rides, most km first, each with its km and share: track, secondary road, main road, service road and so on, fourteen kinds in all, adding up to the whole route), Steep stretches (the km over 10 %, how much of it is unpaved, the steepest grade and where), Single track (when there is any) and Rider reports (the closures the router met, and the hazards, gates and rated stretches other riders reported along the line, with your own). A badge that warns is drawn as loudly as the unpaved share. Its eye lights its stretches and places up on the map, several at once; the surface's eye is the route's own surface colouring (paved green, gravel amber, dirt orange). A badge opens to its list, and each item shows its place on the map and on the profile. A gate in the list also says what OpenStreetMap records about it, each line in words with the tag itself beside it, so you can check it or copy it: "Motor vehicles: private motor_vehicle=private", "Locked locked=yes", a seasonal rule with its months. B goes to the briefing.

Ferries. A route with a ferry has a Ferries badge: how many crossings and how long the route waits at the quays in all, with the timetable's credit under it. It opens to one row per crossing, in the order the route takes them:

A timetable (Norway's ferries and Fjord Line, from Entur; from France's open data, Brittany Ferries' Portsmouth – Caen, Corsica Linea's Marseille – Bastia, Île-Rousse and Propriano ships and Newhaven – Dieppe; from Finland's open data, Tallink Silja's and Viking Line's Baltic ships — Helsinki – Tallinn, Turku and Åland – Stockholm; Germany's island, river and lake ferries from DELFI, among them Norddeich – Norderney; Ireland's domestic ferries from the National Transport Authority, among them Killimer – Tarbert): the sailing you can catch, the wait, the landing and the next sailings — "Bergen Jektevik terminal – Risavika utenriksterminal · next 14:00 · wait 4 h 56 min · lands 19:30 · then Tue 14:00, Wed 14:00, Thu 14:00 · Fjord Line". A sailing on another day carries its weekday. A sailing counts as caught only when you reach the quay early enough to board: 5 minutes for a local ferry, 15 for a national one or a fast boat, 60 for an international ship, or the operator's own check-in time where it publishes one (45 minutes for Brittany Ferries and Newhaven – Dieppe, 30 for Tallink Silja and Viking Line, an hour and a half for Tallink from Åland). The route's time and the stops' arrivals include the waits.
An interval mapped in OpenStreetMap: "every 30 min · about 15 min wait".
No timetable: "no timetable: crossing time from the map" (Color Line, Stena, Grimaldi and the other lines that publish no open timetable; Brittany Ferries' other lines, whose published file lists sailings the company does not run; Marseille – Ajaccio, shared with La Méridionale, whose ships are in no open feed; Corsica Ferries, whose published file has no sailing after 11 October 2026; Helsinki – Stockholm, Helsinki – Mariehamn and Stockholm – Tallinn, where the map's ferry route uses a terminal those ships do not; Viking Line's Birka Gotland, which takes no vehicles, is never offered). The route keeps the crossing time the map gives and a few minutes to board.

Each row shows its crossing on the map, and ↑ ↓ walk the rows. The sailings are read for the route's departure: the forecast's Leave at, or now when it is empty. Set another Leave at and the badge says which departure its ferries were timed for, with Time them for this departure to ask the route again. It does not re-route by itself, because the forecast and Find a drier route use the same departure.

A long wait is weighed against the way round. When a timed ferry would make you wait an hour or more, the route is also asked without that crossing, and the way round is taken if it arrives at least 30 minutes sooner, adds no more than 50 km and every ferry on it has a timetable or an interval. Kinsarvik → Kvanndal at 09:00 crosses the Hardanger bridge instead of waiting 1 h 05 at Kinsarvik and 56 min at Utne: 19 km more, 2 h 18 min sooner. A ferry with no timetable never wins this way, since nobody knows its wait. A ferry next to one of your stops is kept: you chose it. Loops and optimised tours keep their ferries.

The Ferries badge says when this happened. A route that went round gets one line naming the crossing it left out by its quays: "Not waiting 1 h 5 min for Kinsarvik ferjekai – Utne ferjekai: the way round arrives 2 h 18 min sooner, 19 km longer" ("14 km shorter" when it is). When the way round took the route's only ferry, the badge reads "no crossing" and shows that line alone. A route kept while a way round on a ferry with no timetable would arrive sooner gets a quieter line naming that ferry, since you may know its sailings: Kristiansand → Hirtshals at 09:00 reads "A way round by Hirtshals - Larvik might arrive 1 h 21 min sooner; that ferry has no timetable". Nothing is said for any other outcome, and there is no switch to make the route wait for the ferry: to keep a crossing, put a stop next to its quay.

Ranked by your dirt profile. With dirt-first on, a motorcycle or car route of stops is shown at once, then asked again in the background with your active dirt profile (the one chosen under Dirt passages, with its worth extra km trade-off), as the rider app does. The Dirt profile badge says Checking the route against your dirt profile… it may still change meanwhile. When the profile prefers another of the routes the engine found, it replaces the one shown, with one line: "Ranked by your dirt profile Long & easy: 2.5 km more profile dirt than the first route"; otherwise "the route stays as shown". An alternative you chose meanwhile stays yours. The badge then gives the route's km of profile dirt. On a plain A → B it also offers the forced-dirt plan when one rides more of that dirt: "Force the dirt: +7.0 km of Long & easy dirt on 1 passage(s), 1.25× this route", and Use this plan (Tab to it, Enter) puts that chain on the plan as the server planned it, without asking again, and brings the Dirt passages widget forward with its passages. The check has a time limit, Dirt profile check time (3, 5 or 10 minutes, under the Options tab under Dirt-first): past it the route stays without the check and the badge says so and where to change it. It is one setting you and the rider app share, kept with your account rather than with this browser or that phone: choose 5 minutes here and the app plans with 5 minutes, choose 10 on the phone and this planner opens with 10. Over 1,000 km in a straight line the route is not steered toward your dirt (Bergen → Eboli is 2,297 km); the badge says that too, and the engine's routes are still ranked. A route with a track in it, and a round trip's way back, follow their own roads and are not asked again.

What kind of gate. On the route each gate wears the glyph of its kind, the same eight as the rider app: a snowflake for a winter or storm closure, a cone for roadworks, a boat for a ferry's booth, port gate or ramp boom, a flag over a boom for a border crossing, a padlocked gate for a private or farm gate, a booth for a toll, a bollard, and the plain five-bar gate when there is nothing more to say; two stacked cards mean several kinds at once (a ferry's ticket booth that is also a toll). The Gates row says the kind in words ("Ferry or port · Toll at km 488.3") with the gate's status.

A gate's card is its row. Click a gate's glyph on the route, or Tab to it and press Enter, and the briefing comes forward (shown if it was hidden), the Gates badge opens on that gate, the row is selected and scrolled into view, and the map centres on the gate, lit on the route. The selected row shows the whole card: the status and its reason, the km, the mapper's note as written ("Intermittently closed during blizzards"), why it is the kind it is (the tag it was read from, as code, or "a ferry leg 0.5 km away"), its position and OSM node, and the tags in words. Copy puts the card on the clipboard as text and Share hands it to the system's share menu. One card at a time; a click on another row moves it, Escape clears it, and a new route clears it too. The red closed-gate lines under the route summary do the same: each one shows its gate. Nothing pops up over the map.

Every stop has a card too. The Stops badge lists the start as well as every via and the destination: "A · Bergen · leave about 10:00", then each arrival. Click a stop's letter on the map (a drag still moves the stop) or Tab to it and press Enter, and its row is the card: the km along the route, the arrival (the departure for the start), the weather there at that time and its position, with Copy and Share.

When the route cannot reach a point. A pin in a field, at the end of a private track or on a stub of road that joins nothing cannot be reached by the vehicle's roads. The server then routes to the nearest road that does connect, up to 15 km from the pin (the start too), and the planner says so under the route's figures, by the stop's own name: "The route ends 10.3 km from Middalen: no road this vehicle may use goes closer" (or starts, or passes, for the start and a via). The same line sits on that stop's row in the Stops badge and in its card. It shows when the route keeps more than 500 m from the pin, the rider app's figure; less is just the pin's way onto the road. A pin in the water snaps to the nearest road, never onto a ferry lane; ferries along the way are still taken. To end the route somewhere else, move the pin onto the road you mean. When the server refuses the route instead, the planner says why where the figures would be: the nearest road is more than 15 km from a named point — and there the planner also offers Plan from the nearest road (20.3 km from Off Sotra), a button under the words: one press puts the place where the server's own route met your point in place of that start, stop or end, and plans again with the same vehicle and profile. The replaced point carries its name ("Nearest road to Off Sotra"), so the briefing and the stop list say where it came from, and Undo puts your own pin back. Tab reaches the button and Enter presses it, like every other control. A server too old to name that place leaves the words as they are, with no button. The other reasons: no road this vehicle may use joins the points even from the nearest roads that connect; or there is no road anywhere near one of the points (a pin out at sea); a point is outside the area the routing maps cover (no road at all within 300 km, such as Iceland); or the route is longer than the routing engine's limit for its vehicle, "The route is longer than the 1,500 km limit for a bicycle: add a stop partway or choose another vehicle". The limit counts the straight lines through all the points of one request (bicycle 1,500 km, motorcycle 4,000 km, car 5,000 km), so when a route is too long the planner asks for it again leg by leg, split at its stops: a stop partway gets a long bicycle route through, and only a single leg past the limit is refused. A leg so long the routing engine runs out of time on it (a 1,000 km bicycle leg over the Alps can) is split the same way, and when one leg alone still takes too long the planner asks for a stop partway. When the routing engine is down, or the server answers with a reason this desktop does not know yet, the planner says "The server could not plan this route" and names the reason's code in small type under it; the server's own error text is never shown.

The stop list gives each leg its figures under its profile: the distance, the climbing, the unpaved share and the time. Under each stop after the start it says when you get there and the weather there at that time (see Arrival, pace and weather below).

The elevation profile is drawn at its widget's own size: resize it, beside the map or docked under it, and it draws again. Point at it and the place is pinned on the map; point at the route line on the map and the profile's marker moves there. A card at the point gives the distance, the height, the slope, the surface, the posted limit and the time it takes to get there; it stays inside the profile's widget — beside the cursor, on its left near the right edge, under the point near the top — and the ⓘ in the profile's title bar switches it off and on. Under the curve run the surface in five classes, with each one's share, and the posted limits. P gives the profile the keyboard: ← → walk along the route (with Shift, ten times as far), Home and End go to its ends. The profile has three tabs: Elevation (all of the above), Road class (the kilometres on each kind of road, most first, as the briefing names them) and Surface (each surface's kilometres and share). The surface bar stays under every tab.

The forecast is the profile's last row: set Leave at (empty means now) and press Compute. The weather along the route at the time you reach each place lines up under the profile, with the worst of it, the km it covers, the ice stretches and whether leaving later clears them; the card at the point then gives the clock time and the weather there. A new route drops it, and so does another departure or another pace (it was asked for other times).

Save, send to phone

The route's actions sit in a bar pinned at the foot of the Route planner widget, in reach however long the plan: Save (to the library), Send to phone (Shift+P from anywhere in the planner, except while you type), Roadbook, and ⋯ with Download GPX (once saved), Edit route, Zoom to the route, From library… and Clear plan. Send to phone puts a notification on your own phones; a tap opens the plan in the app's planner, ready to ride (from where you are; when that is too far, as planned). A plan must be in your library to be sent: a saved one goes at once, and one not saved yet (or changed since you saved it) opens the save form first, its name filled in and its button reading Save and send. Cancel or Escape sends nothing. A note under the actions says how many of your phones it reached, or why none and what to do, as in the Library.

Arrival, pace and weather

One clock. Every time the planner shows is read from one clock: the stops' arrivals, the legs' times, the card at the point, the forecast's cells and the briefing. It starts at the forecast's Leave at (empty means now: the moment the route came back, or you pressed Compute) and follows the route's own timing, slow on a gravel climb and quick on a main road. The forecast is asked for at those very times, so a cell and the card never disagree.

Each stop's arrival and weather. Each stop after the start shows arrive about its time and the weather there then: rain (snow or sleet by its own sign, ⚡ for thunder), gusts with an arrow where the wind blows, the temperature, and the visibility when it is under 5 km, as on the phone. They come from the same weather frames as the phone's stops and the weather layers; when nothing is known for that place and hour, the stop shows no weather line rather than dashes. The same arrivals sit on the profile's forecast row, one mark per stop (click one, or Enter, to put the profile and the map there), and in the briefing's Stops badge, whose list fits the map to a stop.

Your pace, under the scenic bias: Relaxed (a fifth longer than planned), As planned, Brisk (15 % quicker) or Mine. It re-times what the planner shows (the stops, the legs, the card, the forecast) and leaves the route alone; the route summary keeps the planned time and adds ≈ 1 h 25 at your pace. It stays with your routing choices.

Mine is the pace the rider app learned from your rides, read from your account when you sign in and when the planner opens (see Your riding pace on the accounts page). It times the route as the phone's pre-ride figure does: stretches the engine planned at road speed (at or above your pace split, 35 km/h unless you changed it on the phone) at your road factor, slower stretches and lines followed as drawn at your track factor, each taken halfway towards the plan. The two figures agree for the same route. Mine is for the plan's vehicle (a motorcycle, a car for 4x4 and car profiles, a bicycle, on foot), and it is greyed out until your account holds at least 20 km of learned riding for it; its tooltip says why, or shows your two factors. As planned stays the default.

Find a drier route. When the forecast finds rain on the way, Find a drier route appears beside it. On a plain A → B it asks the forecast for each of the route's alternatives, at the same departure and pace, and marks the driest: the fewest kilometres of storms, then of rain; between equally dry ways, the quicker. It never picks a wetter road because it is quicker; when the driest takes longer it says so in amber ("⚠ 37 min longer than your route", at your pace). The Alternatives row then lists the driest first, the row and the chips on the map say each way's weather ("9 km wet", "clear", "✓ driest"), and Use makes it the route, its forecast with it. With more than two stops the engine offers no other ways, and the planner says so.

Projects

A project keeps the whole app as you arranged it, under a name, so you can open it again — the way a QGIS project does. There is one project for the whole app, not one per view. The menu beside the product name, at the top left, holds New project, Open a project…, Save (Ctrl S, or ⌘ S on a Mac) and Save as…, and lists the recent ones; the open project's name is on the button, with a dot when something changed since it was saved.

A project keeps:

the window — which columns, widgets and toolbars show, where they sit, their sizes and which are folded, in the planner and in the Library (each room has its own arrangement), the profile's card switch and the briefing's eyes;
the layers — which map layers are on (curvature, slope, live traffic, the TET network, live riders, rider reports, advisory zones, dirt density, dirt passages, gas stations, beaches) and their opacity, the files you imported and the library items you showed on the map, each with its style, and the drawing order;
the options — this ride's profile (the vehicle and the style, or Custom with its sliders and dirt-first), the gate and detour options, your units;
what is on the map — the plan, the drawing layers with their drawings, names and styles, and the measurements with theirs; where the map looks, which basemap it shows and how our own basemap is tuned;
the attribute tables — which are open, in which order, and each one's columns and sort.

A library item shown on the map is kept by reference: opening the project fetches it from your library again, so it is as the library has it now. If it was deleted, or is no longer shared with you, the project opens without it and says so. Everything else is kept in the project itself.

Projects are yours: they stay with your account, outside the library — they are not shared and do not appear in search. Each browser keeps its own copy first, so saving works offline, and your account keeps a copy too, so another browser opens the same projects; when the two differ, the later save wins. An account keeps up to 20 projects of up to 1 MB each; at 20, delete one before saving a new one. Opening a project or starting a new one asks first when what is on screen has changes that are not saved; the plan it replaces comes back with undo. A reload while a project is open brings back what was on screen, including its unsaved changes.

The weather timeline

The rider app's weather timeline is on the desktop map too: rain from the radar of the last hours, our own nowcast for the next two, then the forecast, and the forecast's wind gusts, temperature and visibility. Switch on Weather timeline in the layer list, or press W.

One variable at a time: 🌧 rain, 💨 wind gusts, 🌡 temperature or 🌫 visibility, chosen under the row in the layer list or on the Weather toolbar. The row's legend says what the colours mean in that variable's units; for rain also the marks of snow, sleet, freezing rain, thunder, hail and fog.
The Weather toolbar sits on the map's bottom edge while the layer is on, and snaps to any edge like the others. Its track is tinted by where each frame comes from — radar (blue), our nowcast (amber), the forecast (violet) — with a tick at the newest radar frame. Beside it are the frame's time and how far it is from now (−15 min, now, +2 h), ▶ to play the frames, ⚠ when a source is late, and ⟳ to read the frames again (they are read every five minutes anyway).
Your stops are on the track. With a route planned, a mark sits at the departure (A) and at each stop's arrival, on the same clock as the stop list (your Leave at and your pace). Click a mark to see the weather at that hour. Stops reached after the last forecast hour have no mark.
From the keyboard, W puts the focus on the track: ← → step the frames, Home and End go to the first and the last, Page Up and Page Down jump from one stop's arrival to the next, and Space plays and pauses.
A project keeps which variable is on; the frame is always today's.

The frames are the ones the rider app shows, from our own weather service (see the weather layers for the sources).

The window from the keyboard

Everything in the planner and in the Library works without a mouse:

Tab moves from one part of the window to the next — the top bar, the rail, each widget, each toolbar, the map — and Shift+Tab back. The order is the one on the screen, left to right, and follows your arrangement when you move a widget. Each part is one stop: Tab lands on a widget's title, a toolbar's first tool, or the control you used last there.
The arrow keys move between the controls inside a part. A control keeps the arrows it needs: a row of choices (the vehicle, the style, dirt-first, a radius) chooses with ← →, a slider tunes with ← →, a text field moves its cursor.
Enter or Space uses what has the focus. Escape closes what is open — a menu, a card, the report sheet, a picker, a map tool — the innermost first, and gives the focus back to what opened it; with nothing open it goes to the map.
In a dialog — a confirm such as Sign out phone, the sign in here? prompt when another browser holds your seat, the picker that attaches a route to an event — Tab and the arrow keys stay inside it: the dialog's own controls keep their arrows (a list, a date, a drop-down), nothing behind it moves, and Escape cancels it, never the confirm.
On the map, the arrows pan, + and − zoom, and a cross marks the centre: Enter or Space does there what a click would (add a stop, set a loop start, place a measure point, select what is there), and the context-menu key or Shift+F10 reports what you saw there. While you measure or draw a line, Space adds a point at the cross, the line follows the cross as you pan, and Enter finishes it.
Along the route, Tab stops at each stop and each gate in route order (the start, the gates before the first via, the via, and so on), with its tooltip; Enter opens its card in the route briefing. In the briefing's Gates and Stops badges, ↑ ↓ move between the rows and the row reached is the card (the map stays where it is), Enter shows it on the map and on the profile, Escape clears the selection.
Keys, when you are not typing in a field: / goes to the place search from any view, ? shows the list of keys, B goes to the route briefing, P to the profile (← → then walk along the route), Shift+P sends the plan to your phone (as its button does), Y to the layers on the map, W to the weather timeline (← → then step its frames), F to the attribute table (see The attribute table for its grid), and the map's tools have one letter each — I identify (what every layer has under the cross), M measure, D draw, R report, V the street-level photo nearest the cross. While the vector editor is on, its actions have keys of their own (see Map tools). Ctrl S (⌘ S on a Mac) saves the project from anywhere, even while typing.
The list of keys (?, or Help → Keyboard shortcuts: the Keys tab of the Help widget) is built from the keys the window really has, so a key added later shows up by itself. It is grouped like this section: the window, the map, the map tools, the widgets, the commands, then the keys of the widgets in the room you are in (the route planner, the briefing, drawing and the weather in the planner; the list in the Library). ↑ ↓ walk its rows.
Tooltips show the name of a tool, its key and one line about it, when you point at it or reach it with the keyboard — in the language you chose.
A list of choices (the basemap, a sort, the share audience, the language) opens with Enter, Space or Alt+↓; ↑ ↓, Home, End and the first letter of a row move the highlight, Enter takes it, Escape closes it and leaves the focus where it was. A date and time has two parts: ↑ ↓ step the day or the time, ← → go from one part to the other, Enter opens the month (Alt+↓ too). Where a date is changed in a row — a document's opens on in the event console — Enter saves it and Escape leaves it as it was; Alt+↓ opens the month there. A time an event does not have yet shows Set a time; once set, its ✕ takes it away again.

How the window tells you what happened

While something works. The button you pressed shows a spinner and keeps its place. After two seconds a line under it says what is running and for how long — or how far, when the job counts — with Cancel (Escape on the line does the same). Cancelled, nothing changes: the route on the map stays the one you had.
When it worked, a note says so where you acted — Saved, a route that replaced your plan, a new project — with Undo where it can be undone.
When it did not, the note says what failed and why in your language (Not saved: the server did not answer.), with Try again, which asks again exactly as before. What the server answered is folded under it, with Copy, for a report. Nothing is lost silently, and nothing opens a browser alert.
Out of sight. When the widget that did something is folded, hidden or in the other room, the line under the map says it, with Undo where it applies, and the widget's title bar shows a dot until you open it. Nothing floats over the map unless you floated a widget yourself.
On the pages outside the window too. The roadbook editor, the event console and its pages, Social, Stories, the sign-in and Ask for help use the same buttons, fields, lists and date fields, and say what happened the same way: a roadbook that is generated, matched to the roads, exported or printed shows the busy line with Cancel; an event move, an invitation or a friend request that did not go through says so with Try again; a question to Ask for help that could not be sent comes back into the box.

What it does

Area	What you get
Dashboard	The first screen: invitations waiting on your answer, what is running now, and what is coming up
Events	A time, a roster and the records you ride — trip, group ride, tour or rally, each with its own console at a URL you can paste. See Events
Plan	Build a route leg by leg in the Route planner widget, with the elevation profile beside the map (or docked under it). Gates, bollards and toll booths on a motorcycle or car route are drawn on it with the glyph of their kind (closed ones in red) and listed under the summary; a closed gate the router could not avoid gets a red warning, and each of its lines opens the gate's card in the briefing (see The route at a glance). The place search looks from the map: it ranks a name from the area you are looking at, the way the rider app does, so "Bergen" with the map over the Netherlands is Bergen in North Holland and over Norway the Norwegian city, and every result names its country (with its town or region) under its name on up to two lines, its kind below. Enter adds the result as a stop; Shift+Enter, or a result's ⌖, takes the map there instead, with a red pin until your next search, so a search around the map (curvy roads, wild camp) needs no panning. Coordinates work in the same box, latitude first (`60.30, 5.47`, `60.30 N 5.47 E`, `60°18'N 5°28'E`): the one result names the nearest place, Enter adds a stop there and ⌖ takes the map there; written like a coordinate but not one, the box says why; a name nothing matches says so too, with the coordinates hint. A stop added out of view brings the map to it (to every stop once there are two), and each stop row's ⌖, or Z on the row, zooms to its stop. The route planner's Options tab (beside the profile) carries the Gates and closures ladder (Closed on the map or by riders by default) and, with dirt-first on or at the ladder's third stop, Max detour (1.2× / 1.5× / no cap) — both saved with your settings and shared in meaning with the rider app; with dirt-first on, Dirt profile check time (3 / 5 / 10 min) sits beside it: how long the server may rank the route by your dirt profile — one setting shared with the rider app, kept with your account, so whichever of the two you change it on, both plan with it (see The route at a glance). When dirt-first was capped — on one part of the plan or several — the route planner offers the full route with its extra length and time, and one click lifts the cap everywhere. When the server times unpaved ground for a vehicle, a line under the route time names it ("Timed for Adventure"). A reload loses nothing: the plan comes back marked Restored draft (with when you left it) until you change it, Keep it or clear it; this ride's profile, the routing options and dirt-first are saved with your account, so another browser opens with them too; the map opens where you left it, on the same basemap, with the window arranged as you left it. The plan itself stays in this browser and is per account: someone else signing in here does not see it. To keep the whole arrangement under a name and open it again, in this browser or another, save it as a project. Send to phone opens the plan on your phone, ready to ride (see Save, send to phone)
Dirt passages	The rider app's dirt layer on the planning map, under Discover → Dirt passages: the same filters, the same rider profiles (Explorer, Long & easy, …, and your own copies — saved with your settings, so the app and every browser share them) and the paved-gap views. Count a dead end as joined across a gap of up to Off · 5 · 25 · 50 · 100 · 150 · 250 m (5 m by default, kept in the profile): a dead end whose gaps, none longer than that, reach a road or an open passage draws as a through passage, and from zoom 12 its gaps show as orange dashes, where the map has no way. Off keeps every dead end a dead end. Click a passage (or one of its gaps) and its details open at the top of its widget — the facts, whether a route may use it, the gaps at its dead ends, the live wet estimate, check local rules, and Add to plan (a joined group adds all of its passages). The gaps block lists each dead end's gaps with their length, what they land on and what lies along them (height step, steepest grade, water, wetland, the nearest building and settlement), with a line naming the elevation they come from: the national 10 m model where the passage was graded on one (Norway, Sweden), else the coarse 30 m one, a shorter junction from elsewhere on the passage when there is one (dotted on the map while the details are open), and always a warning. After crossing a gap you can lift its warning for yourself (I crossed it, it is safe, then confirm); it then draws grey, on the phone as well, and Put the warning back undoes it. A passage your gap joins is still a dead end to the route planner, and its details say so (Joined at your gap limit, but routes still treat it as a dead end), a worth-exploring one included — unless your own lifts join every one of its dead ends (since the API of 15 October 2026): then it is routable for you, and nobody else, Add to plan is on, and a gap you lifted also joins the dead end it lands on. The plan crosses such a gap only where it is shorter than the road, as its own leg, Gap 140 m, ride on sight: a straight line with no road under it and no turn instructions, counted in the plan's length. Put a lift back and the passage is a dead end again at once. Gap groups: from 25 m up, the passages your gap limit joins to each other are one group. Click one and the whole group is haloed on the map (with a paved-gap view on as well, the view's group keeps the halo when the passage has one), and its details gain the group block: the passages in riding order (each opens its own details, the halo kept; one with no name is Passage 2, by its place in that order, here and in the gap lines), one length with its dirt, tarmac and gap metres, the grade, climb and gates across them, and every gap inside the group with its facts, its warning and your lift, the ones the riding path crosses first. Profile of the group draws the profile below along every member end to end, across the gaps between them. Add all to plan stays off, with the reason: routes still treat these as dead ends — unless your own lifts make every passage of the group routable for you; then it adds them all. Vertical profile draws the passage's height and grade when you ask for it (a few seconds; a spinner meanwhile): the slope colours under the curve, the surface bar in the Surface legend's four colours (the card decides the ground: its pieces are gravel or dirt, never paved; a gap is unknown). Between two pieces it follows the paved road the card's tarmac figure counts (dotted grey); where a passage branches it jumps to the other branch, a thin dotted mark with no distance and no climb. It marks the passage's two ends (A, B) and its gates, and, when your gap limit joins it, each gap as a shaded straight stretch with its length. Point at it, or walk it with ← → (Home, End), and a card says the distance, the height, the grade and the surface there while a pin shows the place on the map. Above it the figures over the passage's own stretches (gaps left out) sit beside the card's: the total climb and descent agree when they are within the coarser elevation model's step; the card reads 30 m GLO-30, the profile a national model where one answers (Norway's 10 m), so they can differ, and the line says so. The passages are ridden in the order you added them, from your first stop to your last, and numbered in the plan; Best order rearranges them for the least road riding. Each leg of the plan opens in line, highlighted and fitted on the map. On an A → B route, Find dirt passages along this route lists the ones worth the detour. All of it works from the keyboard: arrows pick a profile, Enter opens a leg, Escape folds it. A gap with no way on the map can be tagged, confirmed and handed to OpenStreetMap: see Gaps worth mapping. Plan a dirt track is the other way to use the passages you picked: see A dirt track out of the passages you picked
Profiles	Choose the vehicle, then the style — the same start and finish, ridden differently; tune the sliders behind it on the route planner's Advanced tab, save your own in Account › Riding profiles, give one leg another profile. See The profile
Finding things	Fuel, food, campsites, viewpoints, mountain passes, dark-sky sites, forgotten and remote places, beaches, MTB trails, curvy roads, wild-camp spots and scenic villages — the same searches the rider app has — and practice grounds to ride off-road. Search around the map, or along the route you are planning: results come back in the order you will pass them, an added stop lands in the right place in the route rather than after the destination, and the list tells you the longest stretch with none of them on it. Where it matters you can rank by ride time instead of straight-line distance, because a beach across a fjord is an hour away. Wild camp has the rider app's Advanced settings under Find: how far to walk for a better spot, what matters (view, water, flat ground), and under Filters how many spots, how far apart, the steepest slope, the farthest water, and how far to stay from buildings (150 m) and from main roads (Distance from roads, motorways down to tertiary roads, 100 m). 0 m turns either distance off. Reset to defaults puts them all back. They are saved on your account, so another browser you sign in to opens with the same settings (the latest change wins), and they are kept in a project too. The rider app keeps its own wild camp settings on the phone
Library	Everything you have recorded, imported, derived or authored — routes, rides, trails, points and roadbooks — on one map with a list linked to it both ways: browse the map's area or search everywhere by name, description and tag, with the places (cities, roads, addresses, coordinates) named like what you type above the list, a pick taking the map there, filter by category (with counts) and tag, select in the list or on the map (also with a box), hide and show items with their eyes, open one beside the list (its details, profile, stars, description, tags, sharing and links, edited in place), and act on one item or many (show on the planner's map, send to your phone, load into the planner, export, share, attach to an event, run full stats, delete). Every line carries the off-road share the server measured for it — "% unpaved" with its gravel and dirt kilometres — on the item panel and as a badge on its row. The same result shows as a table you can sort, filter and edit, with the measured figures as columns. The query lives in the page URL, so a filtered view is a link you can paste. See The Library. The same library opens as a picker inside the planner ("From library…", insert a saved line into the route) and the roadbook editor
Live traffic	Road closures, roadworks, queues and accidents from national traffic feeds, coloured by severity: red stops you, amber costs you time. The count says when the picture is partial rather than pretending it is complete, and the publisher's own wording is shown untranslated because some licences require it
Sketch and vector tools	Draw and edit points, lines and areas with their fields, every action on the Editing toolbar with a key; group them in drawing layers you name and style; save a feature to the library or back to where it came from, or all of them as a GeoJSON file. See Map tools and Layers on the map
Roadbook	Generate tulip-diagram pacenotes from a track
Stories	Author and publish trip stories and StoryMaps
Social	Friends, shared items and the leaderboard
Live riders	Watch friends who are sharing their position. Positions are pushed, so a marker moves within a second rather than at the next poll — and the poll stays as the fallback, so a hiccup slows the map down instead of emptying it. Click a rider for their card: speed and, when they share them, their bike's numbers, and the photos, videos and voice notes they share as they take them (see Watching a ride happen). The desktop is read-only here: it shows you where people are and never broadcasts your own position
Language	The desktop speaks the rider app's ten languages — English, Italian, Spanish, German, French, Norwegian, Dutch, Portuguese, Polish and Swedish — and uses the same words as the app for the same thing (Highways, Trails and minor roads, Hills, Round trip, Loop, Optimise stops, Wild camp, Live traffic, Add to route…). Pick one in the switch at the top right, also on the sign-in page; Automatic follows the browser. The choice is kept in this browser. Numbers, dates and times follow the chosen language. Text the server writes — roadbook lint messages, the generated roadbook notes, the printed book, the wild-camp legality line, some error messages — is still English
Sharing	Share any library record with your friends, one of your sharing groups, or as a public link. A share grants access, never a copy: the recipient reads your record, your edits show up for them, and Stop sharing takes access back — including from a link already handed out. Shares live in the same ledger the rider app reads, so what you share on the desktop appears in the app's share inbox. A public link is shown once, when it is created; the server keeps only a hash of it, and it expires after 30 days unless you re-share to extend it
Garage	Your vehicles, shared with the rider app: pick one from the catalogue or type it in, see its specifications and service schedule in your own language, and keep your own owner's manual with it — and have it read for its specs and service intervals. See Your vehicle's manual
Support	An in-app chat backed by the support bot, under Help → Ask for help

Anything you save is the same record the rider app sees — the library, the garage and your routes are one dataset, not a desktop copy.

A dirt track out of the passages you picked

The chain plan rides the passages you added, each one whole, in your order or in the one with the least road between them — and it takes ten. Plan a dirt track answers a different question: out of everything you picked, which single ride has the most dirt in it without riding any stretch twice? It takes thirty passages, it chooses the order and the direction itself, it may ride only part of a passage, and it may leave one out. Pick the passages as you always do — click one on the map, Add to plan in its details, Add all for a joined group — and the dirt widget lists them as you added them. Past the chain plan's ten it says so and offers the track; the button sits beside Best order.

Inside a track every gap up to your gap limit may be crossed, whether or not anybody has checked it: that is what makes long chains of short passages rideable at all. Nothing is lifted and nothing is stored. Real gates, ways OpenStreetMap closes to motor vehicles and private land still block it, exactly as elsewhere.

What you get:

The figures: the dirt, the length, how many of your picks are on the track, the gap metres, how many of them nobody has checked, the paved links, and the kilometres ridden twice if you asked for an out-and-back. When the search ran out of its two seconds it says the best track found in the time allowed.
One row per leg, in riding order. A gap nobody has checked is said apart and in the warning colour — Unchecked gap 25 m · ride on sight — and a gap that follows a mapped way names it, with may be closed to motor vehicles where the way is a footpath with no access tag. A gap you lifted, or one shared with you, reads as it does in the chain plan, with who shared it. Paved link is a stretch of road joining two pieces, To the track the road from your start to the track, part of it a passage ridden in part and way back the return of an out-and-back.
The risk, once per track. With unchecked gaps the track says how many and how long they are, and waits for Accept and continue. It is asked again for a different track, it is never sent anywhere, and Route me there waits for it.
Route me there plans the road from your plan's start to the nearer end of the track, then the whole track to the far end. There is no return leg. Swap ends starts from the other end instead.
Left out (n), each pick with the reason: a spur that would mean riding the same ground twice (with Add as out-and-back, which rides it there and back and counts those metres), part of a passage left out for the same reason, a piece that no gap up to your limit and no road link up to your link limit reaches, or a passage the server refuses — closed to your vehicle, a closed gate, a toll road ridden in and back out, a dead end with no gap data yet, or inside an advisory zone. The passages left out whole are dimmed on the map where they are.
How long a road may join two pieces is yours to set: Dirt track: link pieces by road up to under the gap limit, 1 · 2 · 5 · 10 · 25 km or No limit, 5 km by default, kept in your dirt profile like the gap limit. At 1 km a piece the 1.2 km of road would have reached is listed as not joined instead.
When you move a limit, the track says so. The gap limit and the paved-link limit sit right above the track, and the track on screen was solved with the ones you had then. Change either and a line appears above its figures naming what changed — Your gap limit is now 250 m, Your paved-link limit is now 10 km, both at once as Your limits have changed, and off for the two you can turn off — with Plan again beside it. It asks for the same track with your new limits: the same picks, the same out-and-backs, the same end, and the road from your start if you had asked for it. Until the answer lands the figures are still the ones that were solved, so nothing on the panel tells you a limit it did not use. The answer is a new track, so unchecked gaps are put to you again.

Back to the chain plan returns to the ordinary plan with your picks kept (it takes ten of them); Remove all passages clears both. Everything is keyboard-operable: Tab reaches each button, ← → pick on the link ladder, Enter opens a pick's card in line and Escape folds it, and the risk takes the focus when it appears. The rider app has the same track, offline as well, and the phone speaks a warning before each unchecked gap while you ride it.

Gaps worth mapping: tag one, confirm it, hand it to OpenStreetMap

A gap is a short stretch with no mapped way where a dead-end dirt passage almost reaches a road or another passage. Your gap limit decides which ones you see; until somebody maps the missing track, no route can use it. From the desktop you can write down what is there, keep the evidence with it, and get the text and the file an OpenStreetMap note needs.

It happens in the gaps block of a passage's details, under the gap itself, and the same steps are in Join candidates in the dirt layer's settings, where every gap you have tagged is listed with its state.

Tag this gap opens a short form. Two answers are needed: the kind of way (track, path when motor vehicles may not use it, or minor road) and the surface, from the same picture tiles the rider app uses. The rest is optional — track grade, who can ride it, width to the half metre, and a note of up to 280 characters. Access and motor vehicles are only for a restriction you saw on a sign; nothing here ever says a way is open. Where the gap has a shorter junction from elsewhere on the passage, you can tag that instead. The gap you tag stays yours and private.
The tag names where it lands — the way at the far end, with its OpenStreetMap id — and says how many other riders have tagged the same gap. That count is a hint that somebody else saw the same thing; it confirms nothing.
Add a ride as evidence picks one of your recorded or imported rides from the Library. It counts when the ride passes within 25 metres of both ends of the gap, and the server measures that itself: a ride that does not reach says how far it was from each end, so you can pick another. The ride then joins the gap's Library collection, which is made for you when you tag it (Join candidate, with the passage and the gap's length), and holds the evidence: the ride, your photos, the file you export.
I rode it, it exists is offered once a ride has crossed it. It is the sentence that matters — you were there, the track is there, and it can be ridden — and the same press lifts the gap's warning for you, so the gap turns grey and the passage becomes routable for you alone, exactly as lifting the warning by hand does. Confirming needs a ride of yours across it: before that it is refused, and it says why.
Copy the note and Download GeoJSON give you what to send. The note is one paragraph in English — OpenStreetMap's language — naming where the track joins, its length, the day it was ridden, the tags suggested with source=survey, and your own words. The GeoJSON is a single line with those tags on it, which opens in QGIS or any editor. It is never a ready-made edit: a note asks a mapper to look, and one ride is not a survey of a way. Both are offered once you have confirmed the gap.
Drop this tag removes it. Its Library collection stays.

Everything here is keyboard-operable: the chip rows are one stop each with ← →, Enter sends the form and Escape closes it.

What the phone adds is being there: it marks a gap explored by itself after a ride across it, takes the photo, and can tag a gap offline. The two see the same gaps and the same states.

A gap you have confirmed on site is a discovery, and it is yours: you decide who else can ride it. Under the gap, Share this gap asks who — one or more of your friends by name, all my friends, any of your groups, or all riders. The audience you pick is shown back to you as Shared with: …, Change reopens it with your current choice ticked, and Stop sharing ends it. Only a gap you confirmed on site can be shared: marking a gap safe by hand keeps it to yourself, and asking anyway is refused with that reason. What travels is the gap and nothing else — your track, your photos, your note and your tags stay private.

All riders works differently from the rest, on purpose. One rider's word is not enough to send everybody down a track nobody else has seen, so at first it is only a cue: your card says 1 rider confirmed this gap, and the gap routes for your friends and your groups but for nobody else. The moment a second, independent rider confirms the same gap on site, it routes for everyone, and the card says so. That second rider is never named, and neither are you to a stranger — a public gap reads Confirmed by 2 riders. If you later stop sharing it, a gap that reached two riders stays public while one of them still vouches for it.

A gap somebody has shared with you reads like one of your own: grey on the map, grey in the card, and the passage it opens can go into a plan. The difference is that it says where it came from — Shared by Anna — and that instead of put the warning back, which is not yours to do, it offers Hide. Hiding one brings its warning back for you only; the rider who shared it is not told, and Use it again undoes it. In the dirt layer's settings, Use gaps shared with me turns the whole lot off at once; it is on to begin with, and it is your account's answer, so the rider app obeys it too.

In a plan, a leg across a shared gap names the rider in its row — Gap 106 m, ride on sight · 1 min · shared by Anna — so you always know whose word you are riding on. When a share ends, or you hide the gap, or you turn the switch off, the passage goes back to being a dead end at your next plan.

Picking a vehicle from the list

Under Account › Garage, adding or editing a vehicle offers the catalogue the vehicle's Kind actually has: a motorcycle is picked from the motorcycle catalogue, a car from the 4x4 list, and a bicycle or a walking entry from neither — there is nothing to pick from for those, so you type the make and the model yourself. Brand, then model, then year; each step is one keyboard row, and the filter box above it only narrows what is shown.

Picking a car fills its make, model, year and consumption, and sets its Type for travel times to 4x4, which you can change to Car on the row below. The fuel tank stays yours to fill in: no vehicle register records one. The card says what the register can actually support about the drive — on a model whose name also covers two-wheel-drive versions, a RAV4 or a Duster, it says 4x4 versions exist rather than claiming yours is one. A consumption figure from a register is the one the model was type-approved at, labelled with its cycle (WLTP, NEDC) and called a lab figure: expect a loaded car off road to drink more, and the source column says register rather than manual, because no manual was opened. Change the vehicle's kind and a pick from the other list is dropped, since the model no longer describes it.

Fuel you carry

A car's editor has Fuel carried: how many cans and how big each one is, two cans of twenty litres. The litres and the kilometres they are worth are worked out under the boxes — you never type a total, so the two can never disagree.

It is a second range, beside the tank's and never added to it: fuel in a can is no use until you stop and pour it, so the range the car can actually reach while moving stays the tank's, and that is still what fuel-stop planning uses. The card reads both. The cans are your kit, not the manual's numbers, so picking a model never fills them in and never locks them; set the count to 0 when they come off.

Your service schedule, in your own language

Details on a vehicle's card lists its service schedule: what the service is, and how often it falls due. Both halves are in your language — Olio motore · ogni 15.000 km o 12 mesi — and they are the same words Read it uses in the table below, so one card does not name the same service twice in two languages.

What makes that possible is a key stored beside the wording. When you pick a bike from the catalogue, the card keeps the catalogue's key for each service (oil change, air filter, valve clearance) alongside the sentence the catalogue publishes; the key is what gets translated.

An item you typed in yourself has no key, and your own words are shown, in whatever language you wrote them. That is deliberate: nobody should rewrite what you called a job on your own bike.
A vehicle saved before the key existed shows the wording it was saved with until it is picked again or the key is recovered for it.

The rows are a keyboard group of their own: Tab reaches the schedule, the arrows step through it, Home and End jump to its ends, and each row is read out as one sentence — the service, then its interval.

Your vehicle's manual

Under Account › Garage, each vehicle's card has a Owner's manual row. It keeps your own copy of the manual with the vehicle, so it is there on the desktop and wherever else your garage is, rather than in a drawer.

Upload the manual opens the file picker; the row says before you pick that it takes a PDF of up to 60 MB. A file that is not a PDF, is empty or is over the limit is refused on the spot, without sending it, and the reason is written in your language. While the upload runs the row shows how much has been sent, and the card's other buttons wait.
Once it is in, the row shows the manual's title, pages and size. A PDF the server could not count the pages of is kept all the same, and its row simply leaves the pages out.
Open shows the PDF in a new browser tab. Replace uploads another file in its place (the old file is removed once the new one is kept, so a failed upload leaves you the manual you had). Remove asks first, then deletes the manual and its file from your Library.
Everything is reachable from the keyboard: Tab to the row's buttons, Enter or Space to press one, and the browser's own file picker takes over for the pick.

The manual is private to you: it is a document in your Library that no other account can read, and it is erased with your account and included in your data download. The details of the doors behind the row are in Your own manual.

What your manual says

Under the row, Read it has the server read your own PDF and then shows what it found: your manual's specifications and its service intervals, each with the page it was printed on, and the catalogue's own figure beside it.

While it runs the row says where it is — waiting its turn, then reading. A read of a 186-page manual takes a handful of seconds; the panel asks again on its own until it lands, and says so plainly if it did not finish, so you can ask again.
The two columns are your manual and the catalogue, never mixed. Where they differ the row says differs and keeps your figure: it is the book for your bike. Where the catalogue has nothing to compare, the column is an em dash rather than a number nobody read.
A figure whose line could not be found again on any page is shown with no page. It is what the manual said, but it is not used for a service reminder — a page number nobody can check is worse than none.
A manual we cannot read is a result, not a silence: it says whether the PDF is a scan with no text, or a brand whose layout we cannot read yet. The brand is noted either way, and that list is what decides which brand is taught next.
When the make on your vehicle and the brand printed in the document disagree, the panel says so and tells you the figures below are the document's — a Honda manual on a KTM-labelled bike must not hand you Honda's numbers under KTM's name.
The card draws only the one-line summary until you ask to see the figures: a garage of twenty bikes does not fetch twenty parsed manuals to draw a list.
Keyboard first: Tab reaches Read it and then every figure row, the arrows (and Home and End) walk the rows, and each row is read out as the whole fact — the name, your figure, its page, the catalogue's figure and whether they agree.

A read describes one PDF: replace the manual and the panel drops what it held, because the book it described is gone. The doors behind the panel are in Reading your manual.

Watching a ride happen

The live layer is read-only by design, and that is enforced rather than promised. The gateway proxies the live plane as a one-way valve: frames come down to the browser, and of the frames a browser could send, only a keepalive is passed on. The two frames that would matter — "here is my position" and "stop sharing" — are writes, and they never leave the gateway.

This is why the desktop reaches the live plane through the gateway at all rather than holding a credential of its own. A token in a browser is a token that publishes as you; a socket the gateway owns is not.

If the socket cannot open, or closes, the map falls back to asking every 15 seconds. You lose the second-by-second smoothness and nothing else.

A rider's card: their numbers and their captures

Click a rider's dot on the map (or put the map's cross on it, press I and then Open) and the Live rider card opens in the right-hand column, beside the map, like a picked report.

The dash. Speed, heading and how long ago the last fix came, then — when the rider shares their bike's numbers this time — rpm, gear and lean, then coolant, fuel and the odometer. It shows only what the rider's phone sends: a rider with no dongle has no rpm line, and a rider who did not tick my bike's numbers has just the first line. A value older than 10 seconds turns grey; a dongle that went quiet greys the bike's numbers while the position keeps moving.
The captures. When the rider shares their captures, each photo, video, voice note or note they take appears on the card the moment it is announced — a thumbnail first, before the full file has left their phone. The newest four are shown; All lists every one with its time. Click one (or Tab to it and press Enter; ← → move along them) to see it full size in the card: the picture, the video with its controls, the voice note to play. Until the file is uploaded you see the thumbnail and why: Not uploaded yet, or The video waits for the rider's Wi-Fi. ← and → step to the newer and older ones, Escape goes back to the rider, Where it was taken moves the map there, and Copy and Share give who, what, when and where with a map link.
The title bar. Centre moves the map to the rider; Copy and Share give their name, place and time with a map link.

The files are read through the gateway, the same way as everything else: only someone the rider is sharing captures with can open them, and never through a link that works for anyone else. When a rider stops sharing, their card stays open and says so, and their captures stay readable for 24 hours; then they are gone from the live view, and only the rider's own Library share reaches them.

The card follows the socket like the map does: frames arrive as they happen, and when the socket is closed the card asks for the rider's captures every 15 seconds instead.

Signing in

Sign in through the gateway with the same account you use everywhere else. The gateway sets its own session cookie; DESKTOP_GW_COOKIE_SECURE should stay on anywhere with TLS.

A wrong username or password is said under the password field; when the gateway does not answer, the sign-in says so, with Try again.

An account holds one desktop session and one phone at a time. Signing in or out on the desktop never touches the phone; only Sign out phone (below) does.

The same browser signing in again goes straight in. The gateway recognises it by a long-lived "this browser" cookie (desktop_gw_device, httpOnly), which is not a credential and does nothing without the password.
A different browser is asked first: "Your account is signed in on Chrome · Windows (last active 3 min ago). Sign in here? That browser will be signed out." Cancel changes nothing anywhere. Sign in here takes the seat. The question stays valid for two minutes; after that the answer is "That took too long — sign in again". If yet another browser takes the seat while you decide, you are asked again, naming that one.
The browser that was signed out leaves the app as soon as you come back to it: switching to its window or tab makes it check its session with the server, past the gateway's one-minute cache, so it signs out within a few seconds without a reload (a tab you keep switching to checks at most once every 3 seconds). While it stays in front it leaves on its next request, or within seconds if the live map is open. It shows "Signed out — alice signed in on Firefox · macOS at 14:02" with a Sign in button. A password change, or a sign-out from another device, shows its own short reason the same way — "Signed out — alice signed this browser out from iPhone · iOS 26.4 at 14:02" when the phone did it, or "Signed out — an administrator signed this account out everywhere".

Devices. Account › Devices shows both seats: This browser and Phone, each with its name and when it was last active ("riding now" while the phone is sharing its position or in a group ride), or "No phone signed in". Sign out phone asks first — "Sign out iPhone · iOS 26.4? It will stop sharing location and receiving calls for this account." — then signs that phone out; its next request shows who signed it out and from where. Use it for a lost or lent phone. This browser signs itself out with the header's Sign out; the gateway only lets the desktop list the seats and sign out the phone seat, never its own.

Browsers are named from their User-Agent ("Firefox · macOS", "Edge · Windows"; "Web browser" when it cannot tell). A desktop seat can change browsers at most SEAT_TAKEOVER_DAILY_CAP times (default 5) in 24 hours; past that, sign-in answers "too many device switches".

What your account keeps, and deleting it

Besides your library, which lives with the rest of your account, the desktop keeps a few things of its own for your account, so another browser opens with them:

your settings: basemap and overlays, avoid gates and closures, maximum detour, signal sharing level, line styles, the dirt filter and the planner's routing choices;
the sketch you drew in the vector editor;
your projects, up to 20 of up to 1 MB each;
your riding modes, with any icon you uploaded;
star ratings from before ratings moved to your library;
roadbooks it generated from your tracks, kept 90 days;
your sign-in record, which holds your username and email and expires after 7 days.

Your data export includes them. The archive of your account's data (asked for on your account page) carries desktop.json (settings, projects, sketch, riding modes, ratings) and, kept apart, desktop_derived.json (your tier, feature settings and the generated roadbooks).

Deleting your account reaches them too. The moment you delete it, every desktop tab you have open is signed out and its sign-in record is gone. The rest stays, out of use, for the same 30 days as the rest of your content, so a cancel brings it back untouched; at the end of the window it is deleted with your account. The account itself is only removed once the desktop has confirmed: if the desktop cannot be reached that day, the deletion finishes on the next day's run.

Copies the desktop keeps in your browser (each project's own copy, and the plan you were working on) are on your device, out of reach of any server. Deleting your account from the desktop (below) clears them from the browser you delete it in; signing out does not, because a project too large for your account lives only there. In any other browser, clear this site's data to remove them.

Account › Your data and Delete my account

The last two sections of Account do what the web account page does, through the same functions:

Your data → Download a copy of my data asks for the archive. It is built in the background; the link is emailed to you and waits on your web account page for 6 hours, and the section says "A copy is ready until 15:42" with a link to that page as soon as it is. The download is there, signed in on the web: the desktop never handles the archive. One request an hour, shared with the web page: asked again too soon, the section says when you can ask next, as a time. When the build queue is down it says to try again in a few minutes, and that try does not count toward the hour.

Delete my account first says what goes at once (public links and shares, emergency contacts, friends and live sharing, every sign-in, and this browser's copies), what waits 30 days (everything else, the desktop's own store included) and how to cancel (the emailed link, or a web sign-in within the 30 days and Keep my account). Delete my account… opens a dialog:

your shared tracks, each with its length, none ticked: the default is that they go with everything else. Ticking one leaves it published, edited first (start, end and stops removed) and not claimed to be anonymous;
your username, typed exactly (capitals count) before the button wakes.

Deleting answers with the date everything else is erased. A ticked track that is too short to survive the edit (too little is left once its start, end and stops are removed) is not kept, and the answer says so. If you kept a track, the one-time code to withdraw it later is shown once, in groups of eight, with Copy the code: it is not kept in the browser, not in the address bar and not in any log, and the same code arrives by email. That answer is closed only by its button ("I have kept the code: sign out"), not by Escape. Meanwhile this browser's copies of the account (projects, the open project, the reload copies of the plan and the window) are cleared, and the button signs the tab out: the sign-in screen says "Signed out — this account was removed." The language, the layer switches and other preferences of the browser itself stay.

Everything works from the keyboard: Tab through the tracks and the field, Space ticks, Enter deletes once the name matches, Escape cancels the dialog.

First steps: the tour and Help​

How it looks​

How it fits together​

The planner's window​

Preferences and your account​

Layers on the map​

Map tools: identify, measure, draw​

The attribute table​

The Library​

Collections​

On the public map​

Import and export​

Practice grounds​

Hold an event here​

Links: the published catalogue and the reference data​

Ask the Epona Library​

The profile: a vehicle, then a style​

Other ways: alternatives and the scenic bias​

Loops: two or three to choose from​

Curvy roads: which end, which first​

The route at a glance​

Save, send to phone​

Arrival, pace and weather​

Projects​

The weather timeline​

The window from the keyboard​

How the window tells you what happened​

What it does​

A dirt track out of the passages you picked​

Gaps worth mapping: tag one, confirm it, hand it to OpenStreetMap​

Sharing a gap you confirmed​

Picking a vehicle from the list​

Fuel you carry​

Your service schedule, in your own language​

Your vehicle's manual​

What your manual says​

Watching a ride happen​

A rider's card: their numbers and their captures​

Signing in​

What your account keeps, and deleting it​

Account › Your data and Delete my account​