NOOP: The WHOOP Clone That Treats Your Strap Like a Local Database
A reverse-engineered, local-first companion that pulls raw data over Bluetooth, scores recovery on-device, and only trims the strap when the bytes are safely stored.

I reverse-engineered the Whoop strap's Bluetooth protocol and built an app that can talk to it, download data, and compute all the metrics that the official app computes, but entirely offline, on your own device.
- NOOP's core idea is custody, not cloning: it turns a closed wearable into a local data appliance that keeps raw health records on-device.
- The project is split into two acquisition paths, live telemetry and historical backfill, so the app can preserve data before it ever asks the strap to delete anything.
- Its most interesting engineering move is the safe-trim rule, which makes local durability a prerequisite for deletion acknowledgments.
- NOOP matters because it proves a premium proprietary wearable can be re-architected around local scoring, local storage, and reverse-engineered protocol control.
NOOP is easiest to understand if you forget the app UI for a minute. The real product is a custody chain: data leaves the strap, lands on your device, gets analyzed locally, and only then is the strap told it can clear space. That is a very different promise from a normal fitness companion.
The strap is not the product
The official NOOP repository is a local-first companion for WHOOP straps. It pairs over Bluetooth, pulls down raw physiological data, and computes the same kind of outputs users expect from the vendor app, without pushing the stream into a cloud account.
That framing matters. Most wearables are designed around a server, a subscription, and a sync loop that you do not control. NOOP flips that model and makes the strap feel more like a sensor attached to your own datastore.
The two-lane pipeline hidden inside the app
NOOP divides the world into two flows. Live frames go through the collector, which buffers and flushes them on policy. Historical data goes through the backfiller, which pulls from strap memory and only returns a trim acknowledgment after the app has written the data to local storage.
That safe-trim rule is the design win. It makes the app behave like a careful records system, not a downloader. The strap is not allowed to become the only copy of your health history.
Reverse engineering as infrastructure
The lower layers are built around a familiar chain: BLE ingest, protocol decoding, frame routing, then persistence. In the repo's own terms, pieces like BLEManager, WhoopProtocol, and FrameRouter turn proprietary bytes into structured events that the app can actually reason about.
BLEManager -> FrameRouter -> parseFrame
if frame.type == REALTIME_DATA {
collector.enqueue(frame)
} else if frame.type == EVENT {
if dispatchLiveGestureIfFresh(frame) {
handleGesture(frame)
}
}
backfiller.write(frame)
if store.isLocallyDurable(frame) {
strap.ackTrim(frame.range)
}
The protocol work is not only about heart rate. The reverse-engineered event stream also covers gestures and wrist state, and the freshness gate keeps delayed events from being treated like fresh input. That is a small detail with big consequences for UX and trust.
Why the app feels stable even when the radio does not
Defensive engineering is a quiet theme here. The repo includes a marginal radio detector, service UUID rotation for different WHOOP generations, and a policy layer that treats Bluetooth as unreliable rather than ideal.
That matters because fitness data is only useful if the pipeline survives bad radio conditions without confusing the user. NOOP does not assume a perfect connection. It plans for failure, degrades carefully, and keeps the data path legible.
Recovery, sleep, strain, all computed on the device
The most radical part of NOOP is not that it downloads data. It is that it computes recovery, sleep, and strain locally. The StrandAnalytics layer pushes interpretation onto the edge, which means the cloud is optional for more than just storage.
let recovery = RecoveryScorer(samples: store.recentSamples)
let sleep = SleepStager(samples: store.nightSamples)
let strain = StrainCalculator(samples: store.daySamples)
appState.recovery = recovery.score()
appState.sleep = sleep.stage()
appState.strain = strain.value
That is the real proof point. Complex health interpretation does not inherently require a remote service. It requires enough discipline to model the data locally and enough patience to make the edge stack reliable.
A project with a very specific audience
NOOP is not for everybody, and that is part of the appeal. It speaks to privacy-minded users, reverse-engineering fans, and people who bought hardware and resent being told the software is a rental.
The human anchor here is Dmitry Grinberg. The project's public face is unusually spare, but the technical posture is clear: stay close to the metal, keep the data local, and let the code do the talking.
I like the Whoop strap. It is small, has no screen, and collects good data. I do not like the Whoop business model. I do not like that I have to pay a subscription to use the hardware I bought. I do not like that my data is sent to the cloud. I do not like that I cannot use the device without an internet connection.
How NOOP compares to other escape hatches
The cleanest comparison is not against other apps alone. It is against entire ownership models. WHOOP's official app keeps you inside a subscription cloud. Gadgetbridge opens many devices, but not this one. PineTime and Bangle.js give you open hardware, but they ask you to change the hardware itself. NOOP is different because it unlocks an existing closed strap.
| Project | Hardware model | Cloud dependency | Data ownership | Platform support | Best for |
|---|---|---|---|---|---|
| NOOP | Uses closed WHOOP straps | No cloud required for core use | Local storage and local scoring | Multi-platform focus | People who want WHOOP hardware without the vendor stack |
| WHOOP official app | Uses WHOOP straps | Cloud required | Vendor-controlled | Official mobile apps | Users who want the default experience |
| Gadgetbridge | Many supported wearables | No vendor cloud | Local-first | Android | Users who want a broad open companion app |
| PineTime / InfiniTime | Open hardware and firmware | No vendor cloud | User-controlled | Depends on companion app | Users who want a fully open stack |
| Bangle.js | Open smartwatch hardware | No vendor cloud | User-controlled | JavaScript ecosystem | Hackers who want open watch software |
That is why NOOP is so specific and so interesting. It is not trying to win the whole wearable market. It is carving out one clean escape hatch for people who already own premium hardware and want the software freedoms that usually come with open devices.





