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.

8 min read • View on GitHub • More from NoopApp

A WHOOP strap rests on a desk beside a laptop and phone. Thin ink lines split from the strap into two routes, one for live telemetry and one for backfill, and only the path into the laptop's local database carries a lock. The scene explains that NOOP is built around data custody, not just syncing.
NOOP treats the wearable as a source of records, not a black box. Live data and historical offload follow different paths, but both end in local storage before anything gets deleted from the strap.

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.

Dmitry Grinberg, Author / Maintainer · Show HN: NoopApp
Key Takeaways

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's most important architectural idea is that live telemetry and historical offload are different problems. The app does not treat them as one sync event, and it does not allow deletion until local storage has caught up.

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.

A close-up workbench shows raw binary blocks entering a mechanical router and splitting into labeled event streams. One branch goes toward live telemetry, another toward a latch that only releases after a local database drawer closes. The illustration explains how protocol decoding and safe trimming are linked.
The packet layer is where NOOP becomes more than a parser. It routes frames, separates live events from historical offload, and ties deletion to a confirmed local write.

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.

A WSJ-style hedcut portrait of Dmitry Grinberg, rendered from his verified GitHub avatar. The portrait gives a human anchor to a project that otherwise reads like infrastructure.

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.

Dmitry Grinberg, Author / Maintainer · Show HN: NoopApp

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.

ProjectHardware modelCloud dependencyData ownershipPlatform supportBest for
NOOPUses closed WHOOP strapsNo cloud required for core useLocal storage and local scoringMulti-platform focusPeople who want WHOOP hardware without the vendor stack
WHOOP official appUses WHOOP strapsCloud requiredVendor-controlledOfficial mobile appsUsers who want the default experience
GadgetbridgeMany supported wearablesNo vendor cloudLocal-firstAndroidUsers who want a broad open companion app
PineTime / InfiniTimeOpen hardware and firmwareNo vendor cloudUser-controlledDepends on companion appUsers who want a fully open stack
Bangle.jsOpen smartwatch hardwareNo vendor cloudUser-controlledJavaScript ecosystemHackers 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.