The engine under the desk.
Trot is a small, headless Rust daemon that reads your under-desk treadmill over Bluetooth and serves it as plain HTTP + WebSocket. Run trot daemon, point anything at it. It's the open-source core the Nowhere app is built on.
Rust · GPLv3 · runs offline · zero telemetry
One binary between your treadmill and everything else.
No GUI, no account, no cloud. Trot connects to the belt, keeps the record, and exposes it on localhost. What you build on top is up to you.
Local HTTP + WebSocket
A tiny axum server on loopback: poll /api/state or subscribe to /ws for a live stream of steps, speed and distance.
Records sessions
Every walk is written to a local SQLite database with per-minute rollups and retention. Your history, on your disk.
Headless daemon
trot daemon runs quietly in the background — drop it behind systemd, launchd, or a login item and forget it.
Nothing leaves
No accounts, no analytics, no phone-home. Trot binds to 127.0.0.1 and speaks only when spoken to.
Small & portable
One dependency-light Rust binary. Builds and runs on Linux, macOS and Windows from the same source.
Which treadmills work.
Trot reads treadmills over Bluetooth Low Energy — under-desk walking pads and full-size treadmills alike. Six protocol families: five native adapters plus the standard FTMS profile for everything else.
One honest line before the list: two of these are tested on real hardware — LifeSpan here, and the Urevo URTM030 by the contributor who added it. The remaining adapters are independent implementations written from published protocol documentation and open-source reverse engineering, validated against captured frames where captures exist — never against a physical device. If you own one, a report tells us whether it works — still the most useful contribution anyone can make, and how the Urevo got here.
LifeSpan™
The proprietary console protocol, developed and tested against a real LifeSpan walking pad. The one family verified on real hardware.
Urevo™ E1L · URTM030
These pads broadcast FTMS and a proprietary protocol, and only the proprietary one reports steps — so Trot speaks that one. The E1L is checked against published captures; the URTM030 was verified live on real hardware by a contributor, including its different checksum convention, and takes its calories from FTMS where the pad exposes it. Other Urevo pads (Spacewalk) take the FTMS path.
WalkingPad™ · WiLink
The legacy KingSmith™ protocol of the A1, A1 Pro, C2, R1 Pro and P1, rebuilt from the canonical open-source reverse engineering and checked against published frame captures. Newer FTMS pads (e.g. the Z1) take the FTMS path.
Sperax™ RM01 / RM-02
Speed and steps, honestly: this protocol carries no distance, and Trot won't invent one. The FTMS-broadcasting RM-01 takes the FTMS path.
PitPat™ / Deerrun™ / SupeRun™
The shared OEM protocol behind a long tail of budget pads advertising as PitPat-T…, whatever the box says. Steps, distance, time and calories natively, checked against a published frame capture.
Everything that broadcasts FTMS
The standard Bluetooth Fitness Machine Service: Horizon™ AT-series, Technogym MyRun™, BowFlex™ T9, 3G Cardio™, Matrix™, and verified walking pads from Merach™, Sunny Health & Fitness™, CitySports™, WellFit™, Mobvoi™, Sportstech™, YPOO™, TheRun™, Urevo (Spacewalk) and newer KingSmith — where a KingSmith pad broadcasts its step-count extension, steps accrue too.
FTMS is per-model: if your treadmill has an “FTMS” or “broadcast to Zwift / Kinomap” mode, trot scan will find it. Some brands stay closed — iFit (NordicTrack / ProForm), Peloton and Echelon don't broadcast their data, so no third-party tool can read them.
™ Trademarks of their respective owners. See Trademarks.
Install, pair, walk.
Grab a prebuilt binary for macOS, Linux or Windows — or build from source. All you need is a Bluetooth adapter.
Every archive ships a .sha256 next to it. macOS binaries are signed with a Developer ID certificate and notarized by Apple, so they run without a Gatekeeper warning however you download them.
Prefer a polished UI over a terminal? Nowhere is the desktop, mobile and web app that runs on this exact engine.
A local API you can build against.
The daemon picks a free port and writes it to a handshake file; trot status/today/log and Nowhere read it automatically. These are the same endpoints the app uses — nothing is private.
| Endpoint | Returns |
|---|---|
| GET /api/state | Connection status + the live sample (steps, speed, distance, duration) + today's totals — plus driver (which adapter claimed the treadmill) and steps_supported (null until step data is seen, then true). |
| GET /api/today | Today's totals with an hourly breakdown. |
| GET /api/sessions | Session history; /api/sessions/:id for one. |
| GET /api/analytics | Aggregated trends over time. |
| GET /api/steps/by-device | Daily steps split by the device that recorded them. |
| GET /api/export | A full, lossless dump of your data (sessions + samples). |
| POST /api/connect | Reconnect the treadmill; /api/disconnect drops the link but stays paired. |
| POST /api/pair | Pair a device from /api/scan; /api/unpair forgets it. |
| WS /ws | Live push: every new sample and session event as it happens. |
Reads are open on loopback; anything that changes state needs the per-launch token from the handshake file, sent as x-sc110-token. Point curl, a script, a Grafana panel, or your own front-end at it. The /api + /ws boundary is deliberately the seam between Trot and Nowhere, so anything Nowhere does, you can too.
Trot is the engine. Nowhere is the app.
Same author, clean split: an open engine anyone can run and fork, and a polished product that pays for the work. Neither hides the other.
Trot
The GPLv3 Rust daemon. Talks to the treadmill, keeps the database, serves the API. Headless, hackable, yours.
- Command line + background daemon
- Local HTTP + WebSocket API
- Fork it, script it, self-host it
Nowhere Coming very soon
The calm, privacy-first app built on Trot — live sessions, history, analytics and optional encrypted sync, on every platform. Launching soon.
- macOS, Windows, Linux, iOS, Android, Web
- One codebase, no data collection
- Buying Plus keeps the engine funded
The short answers.
Which treadmills work?+
Do I need an account or the internet?+
127.0.0.1, keeps no account, and never phones home — no telemetry, no sign-in, nothing leaves the machine.Where is my data stored?+
GET /api/export.Which platforms does it run on?+
Is there a graphical app?+
/api + /ws — and it's coming soon. Trot never depends on it, and you're free to build your own client.How is it licensed?+
People who contributed to Trot
Everyone here has opened a pull request on GitHub — code that shipped, not suggestions.
Own a treadmill Trot cannot read? A capture from a real machine is the most useful thing you can send — see CONTRIBUTING.
Who made this possible.
No manufacturer publishes a specification for any of these treadmills. Everything Trot knows about them, other people worked out first — by capturing traffic, decompiling apps and reading bytes until the fields made sense, then publishing what they found. Trot reimplements these protocols in Rust rather than porting them. Where it does reproduce something literally — a cipher table, a command frame, a device-name list — it says so, item by item, in docs/provenance.md. The facts are theirs; the implementation is ours.
What was learned from whom, with every licence in full, is recorded in THIRD-PARTY-NOTICES.md — and it ships inside every release archive. Want to be on this list? The issues are open, and a report from a treadmill Trot has never met on real hardware is the most useful thing anyone could add.
Free as in freedom. GPLv3.
Trot is released under the GNU General Public License v3. Run it, read it, change it, share it. If you ship a modified version, keep it open — that's the whole deal.