Goose Review: Open Source WHOOP 5.0 Companion for iOS

Goose is an independent, open-source project that gives WHOOP 5.0 users full control over their health data. Instead of relying on WHOOP's cloud, Goose runs everything locally on your iPhone, using a Rust core to parse Bluetooth packets into meaningful metrics. If you've ever wanted to own your fitness data or experiment with raw biometrics, this alpha preview is worth watching.

What Is Goose?

Goose is an iOS app (SwiftUI) backed by a Rust library that communicates with WHOOP 5.0 bands over Bluetooth. It decodes the device's data streams into daily health, recovery, sleep, strain, stress, cardio, energy, and coach views. The entire pipeline — from BLE scan to metric display — stays on your device, with no cloud dependency. Currently in alpha, it's a proof-of-concept aimed at developers who want to explore a fully local WHOOP companion.

The biggest problem with most wearable health trackers is data lock-in. Your heart rate, sleep stages, and recovery scores live on the manufacturer's servers. Developers and privacy-conscious users have few options to access raw data locally. Goose takes the opposite approach: it connects directly to the WHOOP 5.0 band, pulls the Bluetooth packets, and processes them entirely on-device using a Rust core. This local-first architecture gives users back control. It's especially appealing to iOS developers building custom health dashboards or Rust enthusiasts curious about bridging embedded systems to SwiftUI.

Architecture: BLE, Rust, SwiftUI

Goose's architecture is split into three layers:

• BLE Client (GooseBLEClient.swift): scans for WHOOP 5.0 devices, manages connection, and receives raw packet data.
• Rust Core (in Rust/core): a Rust library that parses the WHOOP 5.0 protocol, computes health metrics (sleep, recovery, strain, etc.), and exposes a C bridge.
• SwiftUI App: handles onboarding, tab navigation (Home, Health, Coach, More), and renders the metric views. The app uses a GooseRustBridge.swift wrapper to call into the Rust library via JSON-over-C.

The data flows from BLE -> Rust -> SwiftUI, all inside the iOS process. No network requests leave the device.

Getting Started

Goose requires a macOS development machine with Xcode 16+ and Rust. Here's how to build for the simulator:

# Install iOS Rust targets
rustup target add aarch64-apple-ios aarch64-apple-ios-sim x86_64-apple-ios

# Open the Xcode project
open GooseSwift.xcodeproj

# Build for simulator (from command line)
xcodebuild \
  -project GooseSwift.xcodeproj \
  -scheme GooseSwift \
  -configuration Debug \
  -destination 'platform=iOS Simulator,name=iPhone 17' \
  -derivedDataPath /tmp/goose-swift-deriveddata \
  build

For a physical device, you'll need an Apple Developer account and the device ID. The build script Scripts/build_ios_rust.sh automatically compiles the Rust core for the active platform. If you just want to peek at the code, the project is self-contained.

Once you connect a WHOOP 5.0 band and Goose starts receiving packets, the Health tab displays a recovery score, sleep duration, strain, and more. The Coach view uses those same local metrics to answer questions like "Why is my recovery low today?" without sending data to an external server.

A snippet from HealthView.swift shows how the app presents a metric card:

struct MetricCard: View {
    let title: String
    let value: String
    let subtitle: String?
    var body: some View {
        VStack(spacing: 4) {
            Text(title)
                .font(.caption)
                .foregroundColor(.secondary)
            Text(value)
                .font(.title2).bold()
            if let subtitle = subtitle {
                Text(subtitle)
                    .font(.caption2)
                    .foregroundColor(.secondary)
            }
        }
        .padding()
        .frame(maxWidth: .infinity)
        .background(RoundedRectangle(cornerRadius: 12).fill(Color.gray.opacity(0.1)))
    }
}

This pattern repeats across Sleep, Recovery, Stress, Strain, Cardio Load, and Energy Bank views. The data originates from the Rust core via the C bridge, but the UI is pure SwiftUI.

Pros, Cons, and Alternatives

If Goose doesn't fit your needs, consider these alternatives:

• WHOOP Official App – Feature-rich but cloud-dependent and closed-source.
• Bevel – Premium health app aggregating data from multiple sources including WHOOP, but not open-source and costs money.
• Autosleep – Popular sleep tracker for Apple Watch, but doesn't connect to WHOOP bands.

Should You Use Goose?

Goose is for developers who want to experiment with local health data processing and are comfortable with Xcode, Rust, and a highly unstable alpha. If you just want to see your WHOOP stats, stick with the official app. But if you're curious about what's possible when you own your biometric pipeline, Goose is a fascinating proof-of-concept. Keep an eye on its development – by mid-2026 it may mature into a real alternative.