Nine chapters. Each one opens with the mechanic it describes, animated — then lists what else lives there. Everything here is merged and reachable in the app; anything still unproven on real hardware says so.
Draw a route on the map, import one from anywhere, and keep a library that lives on your phone instead of in someone’s cloud.
Tap waypoints on the map, pick a BRouter profile — trekking, fast bike, shortest — and preview distance and ascent before you commit. A shape toggle closes the loop back to where you started instead of leaving a one-way line dangling.
Why it's rare: Neither Wahoo app has a route builder at all; it is the standing top-three user request, and got worse when Komoot paywalled sync.
Routes are files on the device, searchable and removable one at a time, with a cached map crop on every row. Sort by most recent or by nearest start, and star the ones you keep coming back to.
Why it's rare: The v3 app dumps every synced route at you with no filtering, and dropped v2’s starred-route filter outright — support’s answer to riders asking for it back was “search instead”.
The import picker lists the course library the head unit is actually carrying — across Komoot, Strava, RideWithGPS and local folders — newest first, with a search field once there are more than a dozen. Tap one and it pulls and imports.
Why it's rare: No app exposes the head unit’s own file listing; on a Komoot-synced unit that is hundreds of routes you otherwise cannot reach from a phone.
Pick a completed ride — on the phone or still on the head unit — and import it as a route to ride again. Fetched over Bluetooth if it is not on the phone yet.
Why it's rare: There is no vendor path from a finished ride back to a re-rideable route on the phone.
Tap a file in a file manager or share one in from Komoot, Strava, Gmail or Dropbox and land in the editor with it imported. The format is decided by sniffing the file’s bytes, never its name or MIME type — both of which lie constantly for these two formats.
Search a 200 m corridor along the whole route in one query, and get rows that answer “is it worth the detour, and will it be open?”
Pick a category and search a 200 m corridor along the entire route in one query instead of tapping the map every kilometre. Hits are listed in the order you will meet them, and you tick as many as you like — from the list or by tapping one on the map — and add them in one go.
Why it's rare: No companion app searches along a route at all; the official app has no route editor to put the result into.
Each hit crosses its OSM opening hours with the arrival time the app already projects for that distance, and shows a green Open 10:06 or a red Closed 10:06. Move your start time and the verdict moves. Opening hours are a nasty format, so BikeScout reads a documented subset and shows nothing at all for the rest — a confidently wrong “Open” is worse than silence.
Why it's rare: Nothing in the category crosses a POI’s opening hours with your projected arrival — there is no ETA to cross them with.
Rows read at 42.1 km · +120 m detour · on the left — the real round trip and which side of your direction of travel it sits on, rather than a perpendicular offset no rider ever covers.
Why it's rare: The map data carries all of this and every other tool throws it away, leaving you a pin and a straight-line distance.
A drinking fountain is almost never named but often carries a brand or operator, so the row reads “Stadtwerke Stuttgart” instead of “Water”. That name rides to the head unit too.
Why it's rare: Falling back to the category name is what everyone else does; the tags to do better are already in the same response.
Seasonal, Fee, Customers only, Private — and the facilities that justify the trip: Repairs, Pump, Free public pump. Water tagged as not drinkable never reaches the list at all, because a water list exists to answer “can I fill a bottle”.
Why it's rare: Nobody else surfaces the tags that decide whether a stop is worth riding to.
The editor keeps a quick row of five — water, food, coffee, viewpoint, generic — and puts the other fifty behind a searchable More categories page, grouped the way you would go looking: Water · Food & drink · Rest & facilities · Shops & services · Scenic & places · Warnings & help · Terrain & effort · Markers. Type “pharm” if you know the word, browse the headings if you don’t.
Café, bar, restaurant and groceries markers are a berry red-purple rather than the brand teal they used to share with everything else — teal sat one hue from water’s blue, and a rider could not tell a food stop from a fountain at marker size. It is the colour-blind-safe slot, and further from every other category colour than the pair that caused the complaint.
Wahoo’s sync strips the POI type, so a Komoot viewpoint arrives off the device untyped. BikeScout recovers the category from the POI’s own name, in English and German alike — Aussichtspunkt, Trinkwasserbrunnen, Fahrradladen — so it draws as a viewpoint instead of an anonymous pin. Only ever an upgrade: a POI the file did type is left alone.
A Komoot import reads as “3 POIs”, not “210 POIs”. Cues are a router’s instructions; they are never offered as a category you can drop.
Splice a place into the line you are already riding — as a via-point to the finish, or a there-and-back that rejoins where you left.
Pick a found place and either re-plan from the anchor onward (via-POI to finish) or take a there-and-back that rejoins where you left, leaving the rest of the route untouched. The route up to the anchor is never thrown away, POIs still on the new line carry over, the extra distance is measured against the remaining route, and none of it needs a GPS fix. Preview, apply, then send — apply and send are separate actions.
Why it's rare: Neither official app can edit a route at all, let alone bend one around a bakery you just found.
“Marktplatz Stuttgart” or just “bakery” returns real places ranked near you, from a key-free OSM geocoder proxied through the app’s own backend and cached for a week. Each result carries a one-line address.
Why it's rare: The official app lost address navigation in v3, and Apple Maps sharing errors out on ROAM v3 — four independent sources across 2025–2026.
A shared place is parsed, its shortener followed server-side, and it lands as a destination. Google’s pin coordinate wins over the camera centre, so you get the place and not the viewport. A link that can’t be read says so and leaves your text in the field — never a dead end.
Why it's rare: No companion app accepts a map link as a destination.
With nothing loaded, a rideable point-to-point route is planned from where you are and becomes the active route. With a route already loaded the button reads Add to my route and the place is pinned at the top of the reroute sheet instead. A loaded route is never silently replaced.
Why it's rare: There is no in-app routing to a searched destination anywhere in the category.
Phone to device over Bluetooth, stops intact, cue noise under your control, cancellable mid-transfer.
The route is announced on the config channel, streamed as a gzipped FIT course in MTU-sized chunks, and committed — then the unit loads it and navigates. Byte-validated against a live capture of the real protocol.
Why it's rare: Online, the official app pushes phone → cloud → head unit over Wi-Fi; nothing traverses Bluetooth, and no other phone app pushes routes to an ELEMNT at all.
Marked stops travel as FIT-standard course-point records and appear along the route on the device — the whole point of the exercise.
Why it's rare: Wahoo’s own provider sync strips them: across 755 synced routes on the test device, 0 carried a POI, and all 83,760 course points were turn cues.
An imported course is mostly cue noise. Per route or as a default, send every cue, thin to the ones that need a decision, or strip to a clean breadcrumb line — and slide the survivors up to 200 m along the route for the long-standing “cues fire too early” complaint. Non-destructive: the saved route keeps every cue, so it is re-tunable after the ride.
Why it's rare: Neither the official app nor the firmware offers either control.
The ✕ inside the button stops streaming and closes the device’s transfer session cleanly, so the next push isn’t rejected as busy and the partial file is never committed — the unit never lists it.
Why it's rare: There is no user-facing transfer to cancel in the official flow; a stuck cloud sync is a support ticket.
On connect, and whenever you change the selection on the device, BikeScout reads back the loaded route and reconciles. For its own pushes the token matches directly; for anything else — a Komoot course — it pulls the actual course file off the device by path and parses it.
Why it's rare: No app exposes the head unit’s loaded route; this recovers even a Komoot course’s file.
A handshake on connect makes the unit stream 237-byte frames instead of the default 20-byte ones, and pulls are gzip-compressed on top for roughly three times fewer bytes again. Route pushes additionally request a fast connection interval.
Every ride in one list wherever it lives, pulled off the head unit over Bluetooth, uploaded to Strava on its own.
Ride history shows every ride in one date-ordered list, whether it is already on the phone or still only on the head unit. A ride that has been pulled appears once, matched by the filename stamped at download time, so the list reads as “my rides” rather than as sync state.
Why it's rare: No other companion shows device-resident and phone-resident rides as one list.
Enumerate the completed rides on the device and pull them over Bluetooth — one, or all at once, with per-ride progress and retry. The list streams in as it enumerates, is cached, and reconciles on refresh.
Why it's rare: The current official app removed .fit export and USB file access; the surviving alternatives are desktop-only.
Opt in and pulled rides queue automatically, uploading one at a time, oldest first. Going offline, hitting Strava’s rate limits or an expired connection parks the queue; it resumes at the next app start, foreground return or pull. Each ride’s button reads “Queued for Strava” until it becomes “View on Strava”.
A ride with a long lunch uploads with both its real elapsed time and an average speed the stop didn’t drag down.
The app records the ride either way, so the ridden line is drawn from its own recording rather than from a course the head unit happens to be following.
Why it's rare: Without a loaded course there is nothing for the official app to draw.
The forecast where and when you will actually be there — and a sunscreen rule that models the sun rather than a timer.
A weather band fused with the elevation profile, an ETA timeline strip, and a start-time and average-speed control — not the weather at the trailhead now. Head and tailwind are resolved as the component along your heading rather than raw wind speed.
Why it's rare: The head unit shows no weather at all, and nothing projects a forecast along a route by arrival time.
Sweeps departure times across the next 12 hours of the fetched forecast, re-projected locally with zero extra fetches, and recommends the cheapest rain and headwind window. One tap applies the advised start and re-projects the band instantly, offline-safe.
Why it's rare: Nothing in the category answers “when should I leave”.
Rain onset, headwind, temperature highs and lows, gusts — evaluated in a look-ahead window ahead of your position, off a prefetched offline-safe cache, with per-kind cooldowns.
Why it's rare: Nothing pushes look-ahead weather to an ELEMNT; the firmware has no weather surface of its own.
Set your Fitzpatrick skin type and the head unit nudges you to reapply. The interval scales with the UV index and gates on solar elevation computed on-device, so it stays quiet when the sun is too low to burn, and it is timed by accumulated riding-in-sun — the clock freezes when you’re off the bike or in the dark. The card always says what it’s doing, or why it’s paused.
Why it's rare: No bike computer or companion app models UV exposure at all.
Weather is fetched on an explicit “Check weather during ride” tap — never on route load, screen open or a timer — and a route change clears a stale forecast.
Your own trigger→message rules, written to the screen in front of you, gated by conditions so they stay quiet when they should.
Interval and threshold triggers, conditions that gate them, per-rule cooldowns. Presets ship for hydration (every 30 minutes, suppressed on a steep descent), fuel, a heart-rate zone alert, the weather trio and sunscreen. Evaluation runs on its own 20-second cadence while a ride is active, so interval rules fire on time rather than only when telemetry happens to tick.
Why it's rare: The official app’s custom alerts are timer-style; there is no condition-aware trigger→message channel that writes your own text to the screen.
One trigger — every N minutes, or when a metric crosses a threshold — an optional condition that gates it, the message the device shows, and a cooldown, with a live preview of the exact notification. Rules persist in full, so a rule you tuned stays tuned across restarts and updates.
Why it's rare: No companion app lets a rider author a device-screen alert.
Messages, email and missed calls, classified and framed for the device’s own notification channel — hardware-validated, including multi-fragment messages. Android only: iOS has no equivalent access, which is a platform wall rather than a gap in the app.
A live link with no vendor cloud that survives tunnels, restarts and expiry — and lets friends message you back.
Flip the switch, sign in once by magic link, and friends open a link — no account, no app — to watch the ride move on a map. The link expires by itself after six hours.
Why it's rare: Wahoo Live Track depends on their cloud and is a chronic reliability complaint.
The planned route is cut at the rider: the half behind fades to a dotted trail, the half ahead stays bright amber and carries arrowheads so which way round the loop goes is never a guess, and the rider’s own GPS trace is blue. Progress only ever moves forwards, so an out-and-back or a wrong turn can’t rewind it.
Why it's rare: Every other tracker draws one line and a dot.
Opening a route on the Routes page stages it on the phone; it reaches followers only once the unit holds it. Browsing routes mid-ride therefore can’t redraw a follower’s map with a course you aren’t on.
Why it's rare: Nothing else distinguishes a staged route from the one the device is carrying.
The head unit’s own run-state travels with every point, so the badge reads PAUSED or AUTO-PAUSED instead of pulsing LIVE over a dot that stopped moving. Elapsed time on both sides is moving time, so a long lunch doesn’t drag the projected arrival later for the rest of the ride.
Why it's rare: Vendor live tracking has no run-state channel to the viewer.
The app checks in every five minutes on its own clock, and the first position that gets through after a run of failures checks in straight away — so a two-hour valley costs you the valley, not another five minutes on top. A session that expired without you stopping it is put back on its feet keeping the same public link, and follower pages that were open retry with a backoff and pick the ride straight back up. A ride you actually ended stays ended.
Why it's rare: Vendor live tracking drops the session and hands you a new URL.
Toggle Group ride when going live, or start one mid-ride; buddies join from the link or a QR code. Everyone sees everyone on the Ride screen and on one merged map page. Ten riders, twelve-hour TTL.
Why it's rare: There is no multi-rider view in the category that doesn’t route through a vendor account.
A contact you’ve marked can-message gets a compose box on their tracking page; a send under five minutes old reaches the head unit through the same hardware-validated notification path, or a phone notification when the unit isn’t connected. Anything staler lands in an in-app list you read on your own time, never interrupting mid-descent. Bounded structurally rather than by content filtering — 160 characters, three messages per contact per hour, and a kill switch that empties every viewer’s compose box mid-ride without ending the share.
Why it's rare: Wahoo’s own Live Track is watch-only; there is no viewer→rider channel at all.
After 30 seconds of failed pushes the device gets a card naming the cause — no connection, sign-in expired, or server error — once per outage, plus “connection restored” when points land again.
Why it's rare: The official app’s own live-track warning is a fixed, payload-free firmware string that cannot say why.
Ask for the nearest water without stopping, and let the app keep the head unit connected, alive and yours to hand back.
Say “send me to the nearest water source” — also: send the route to the head unit, start or stop live share, find my device. Commands are understood in English and German across 18 kinds of place; spoken replies are English only for now. Resolved by a keyword grammar first — instant and offline — then, only if that misses, an on-device LLM on hardware that has one. There is no cloud tier: nothing spoken ever leaves the phone.
Why it's rare: Neither the official app nor the firmware offers any voice control.
A cheap, unambiguous reroute just happens and is pushed to the device; an ambiguous match or a detour past your threshold is read back for a spoken or tapped yes, and ten seconds of silence cancels it and says so, route unchanged.
They are exposed as typed OS-assistant intents, so a command can run without opening the app; on iOS Siri asks for confirmation in its own dialog, and on Android — which has no equivalent round-trip — a command that needs confirming opens the app and asks there. Not yet verified on hardware: the Dart side is covered by tests, but Siri phrase matching, the confirmation round-trip and Android’s invocation path have not been confirmed on a real device.
A Quick Settings tile and a Bluetooth earbud long-press each open the same listening session the mic button does, and a deep link — which also works on iOS — runs one of five named commands immediately, for a Gemini Routine or any automation app that can open a link. Turning on the earbud trigger means making BikeScout the phone’s digital assistant, which is exclusive system-wide: it replaces Gemini everywhere, not just on the earbud button. Not yet verified on hardware: code-complete and tested in Dart, but the tile’s appearance, a real earbud long-press arriving, and the locked-screen paths are all unconfirmed.
BikeScout remembers the unit you last rode with and connects on launch, without ever raising a permission dialog to do it, only ever reaching for the most recent head unit, and giving up after twenty seconds rather than leaving the radio hunting for a device that’s switched off. Hit Disconnect and it stays disconnected.
A Bluetooth link that stays up while the device stops sending data raises no disconnect, so nothing used to notice — the map froze and the ride stopped recording while the app still said “Connected”. A watchdog now watches the telemetry clock itself: after 30 seconds of silence it works out which fault it’s looking at and applies only the remedy that fits, and if telemetry is still gone at 75 seconds the link is dropped and rebuilt, with your recording and live session kept intact.
Why it's rare: A silent-but-connected link is invisible to every implementation that only listens for disconnects.
The device answers one requester at a time, so a leftover connection attempt polling it alongside the live one is enough to stop telemetry outright while the link still looks healthy. Bringing a unit up now claims it: the previous driver is retired before the new one touches the radio.
One “Disconnect everything” releases every device, stops auto-reconnect and stops the background service, so the unit is free for the official app — a Bluetooth peripheral takes one phone at a time. It’s on the Devices screen and on the ride notification, so you can release it from the lock screen.
A library plus an interval builder — per-step duration by time, distance or left open, target by power, heart rate or cadence as an absolute range or a zone — encoded to a FIT workout and pushed to the head unit. Not yet verified on hardware: the builder and encoder are code-complete, but a pushed workout’s on-device behaviour hasn’t been confirmed on a real unit.
Standalone points of interest — home, a café, a water source — picked from a type grid and a map or GPS picker, and synced to the head unit as inline course-config rows. Not yet verified on hardware: the sync path is code-complete but unconfirmed on a real device.
Opt-in, off by default: records the session, every head-unit connect, all BLE frames in and out, driver and protocol events, and uncaught errors to a rolling 4 MB file, bounded at two files so it never grows without limit. Readable in the app before it goes anywhere, and mailable to support with the session header in the body. Nothing is redacted — the toggle’s copy says so plainly, because a partially-scrubbed log would leak through the hex while looking safe.
A full Garmin driver — protocol spine, a GFDI file-transfer engine, and the same head-unit driver contract the ELEMNT uses — is wired into the app: the Devices scan recognizes a Garmin by its GFDI service and marks the card Experimental, and Send, Sync from device and Find my device all run over it. Connect, device info, route push and find-device are confirmed working on a real Edge 540 — route push genuinely works on hardware, today. Sync from device (which also queues newly pulled rides for Strava), workout push and notifications are byte-tested against a decompile of Garmin Connect, not yet verified on hardware. Live telemetry streams heart rate, power, cadence and ride start/stop off the Edge’s own event-sharing service, but carries no position — a Garmin’s own GPS fix isn’t exposed there, so live sharing on a Garmin would need the phone’s GPS instead. The family stays experimental while ride pull, workout push and notifications get their turn on real hardware.
No live telemetry dashboard on the phone — the head unit is the instrument, and duplicating speed or heart rate on a phone screen is what a phone is worst at. No segments: investigated and removed, because a phone-to-device segment push isn’t a reimplementable operation — segments carry no announce opcode, and the generic table-sync framing they would need lives inside the vendor’s own native library, not on a wire that can be captured and replayed.
BikeScout