GlucoWatch & GlucoPhone

Your glucose on your wrist and your Android phone: current readings, trends, history, insulin and carbs, and optional forecasts. GlucoWatch is a Wear OS app with a watch face and three tiles. GlucoPhone is a phone dashboard you can use on its own or connect to your watch.

Use Dexcom Share or your own Nightscout, or try everything with built-in demo data before connecting an account. The watch can fetch directly, so the phone app is optional. There is no GlucoWatch server and no Google Play Services dependency.

Install and try it · Connect your data · Pair your watch · Developer guide

On your watch

• Glucose at a glance: a large reading, trend arrow and reading age, with a chart from rim to rim.
• A watch face and three tiles: glucose only, glucose with time and heart rate, and a light theme. Tap the glucose value to open the app for more detail.
• Complications for other faces: glucose, chart, forecast, insulin/carbs on board, and the last bolus/carbs, where your data source supplies them.
• Treatment context: Nightscout or the phone's connected pump source can add boluses, carbs, basal events, and insulin/carbs on board.
• Optional forecasts: a glucose trend, your Nightscout loop's forecast, or a model running on the phone.
• Freshness you can see: old readings are marked OLD DATA. An optional notification tells you when readings are more than ten minutes old; Android can delay background refreshes and alerts.

See the watch app and individual tiles

Glucose	Glucose, time and heart	Glucose (light)

Watch face screenshot

On your phone

Glucose and history	Meals, insulin and heart rate

• A glucose dashboard: current value and trend, reading age, time in range, the 30-minute change, and an optional forecast, in mmol/L or mg/dL.
• Draggable history: switch between 3, 6, 12 and 24 hours and drag back through up to two weeks of locally retained readings. Longer history builds up as the app collects data.
• Meals and insulin: photograph food, record carbs, and log bolus or basal doses on the chart. These personal logs and photos stay on the phone.
• Pump and loop data: combine your CGM with your own Nightscout or CareLink insulin data.
• Heart rate: an optional Health Connect track on Android 14 or later, when your phone has samples and you grant access.
• Local prediction: choose a built-in forecast or import a compatible ONNX model from a file or Hugging Face. Inference runs on the phone. See the prediction guide.
• Easier watch setup: relay readings and forecasts over Bluetooth, or copy your Dexcom or Nightscout login to the watch so you can avoid its keyboard.

All screenshots above use synthetic demo data, captured on Galaxy Watch6 Classic 43 mm and Galaxy S22-sized emulators. Demo heart rates and forecasts are illustrative.

GlucoWatch and GlucoPhone are not medical devices. Do not use them for treatment decisions. Keep using your CGM's official app and alarms.

Install and test from your phone

You need Android 10 or later for GlucoPhone. To use GlucoWatch, add a watch running Wear OS 4 or later. You can try the phone app without owning a watch.

The latest GitHub release has three separate APKs (Android installer files):

App	File in the release	Install on
GlucoPhone	glucowatch-phone-<version>.apk	Your Android phone
GlucoWatch	glucowatch-<version>.apk	Your Wear OS watch
GlucoWatch face	glucowatch-watchface-<version>.apk	Your Wear OS watch, alongside GlucoWatch

Obtainium installs GlucoPhone on the phone. It cannot put GlucoWatch on the watch. Wear OS does not let an app on the watch install other apps, so Obtainium on the watch cannot do it either. The watch files come from the same GitHub release. The phone sends them over with Wear Installer, in step 2.

Leave a debug install before the release

A copy put on the watch or the phone from a computer, for testing, is not the release. Android treats it as a different app with the same name and will not replace it. The install stops, often with App not installed.

Take the test copy off first, then install the release. Taking it off deletes the login, the pairing between the phone and the watch, and any forecasts stored on that device. You set those up again after the release is installed. A later update does not need this. Once the release is what is installed, Obtainium and Wear Installer update it in place.

On the phone

1. Open Settings → Apps → GlucoPhone.
2. If it is there and you installed it from a computer, tap Uninstall.
3. If GlucoPhone is not listed, there is nothing to remove. Continue with Obtainium.

On the watch

1. Open Settings → Apps and uninstall GlucoWatch.
2. Uninstall GlucoWatch face the same way. It is a second app. Leaving either one in place blocks the release, and the face and the readings will not match.
3. Debug mode is Wireless debugging and ADB debugging under Developer options. Step 2 turns them on so the phone can send the apps, and turns them off when that is done. Do not leave them on. They use the battery, and the apps keep running after they are off.

Then install the phone with Obtainium and the watch with Wear Installer, below. Pair again when both are installed: Connect your phone and watch.

1. Install GlucoPhone through Obtainium

Obtainium installs Android apps from their release pages and checks for updates. On your phone:

1. Install Obtainium from its official releases. Most current phones use its app-arm64-v8a-release.apk; use app-release.apk if you need the universal APK. Android may ask you to allow your browser to Install unknown apps.

2. Open Obtainium → Add App and paste this repository URL:

   https://github.com/GlucoseDAO/glucowatch
   

3. Open the additional options and set Filter APKs by Regular Expression to:

   ^glucowatch-phone-.*\.apk$
   

4. Add the app, then tap Install. If Android asks, allow Obtainium to Install unknown apps and finish the installation. If you see an APK chooser, select glucowatch-phone-<version>.apk.

5. Open GlucoPhone. The release starts with Demo data, so you can explore Today, scroll the dashboard, drag the chart and try the logging controls without an account or network. Use Connect when you are ready for your own data.

The APK filter selects the phone app from a release that also contains two watch packages. See Obtainium's APK filter documentation. Keep this entry in Obtainium to receive future phone updates.

2. Install the watch app and face from your phone

This is the watch install. Obtainium stays on the phone and does not send anything to the watch. Wear Installer 2 does. It needs debug mode on the watch for a few minutes, then you turn it off.

1. In your phone's browser, open the latest release, expand Assets, and download glucowatch-<version>.apk and glucowatch-watchface-<version>.apk to Downloads. Choose the same version as GlucoPhone.
2. Install Wear Installer 2 on your phone. Connect the phone and watch to the same Wi-Fi network.
3. On a Galaxy Watch, open Settings → About watch → Software information and tap Software version repeatedly until Developer options are enabled. On other watches, tap Build number under Settings → System → About → Versions.
4. In the watch's Developer options, turn on ADB debugging and Wireless debugging. Open Wireless debugging and note the watch's IP address.
5. In Wear Installer 2, enter the IP address → Done, then menu → Pair with watch → Enable. On the watch, tap Pair new device. Enter its six-digit code, a space, and its pairing port in Wear Installer 2 → Done.
6. Return to the watch's main Wireless debugging screen. Enter its connection port in Wear Installer 2's port field. This is different from the pairing port in the previous step.
7. In Wear Installer 2, choose Custom APK, select glucowatch-<version>.apk from Downloads, and tap Install. Repeat for glucowatch-watchface-<version>.apk.
8. Open GlucoWatch on the watch. Turn off Wireless debugging and ADB debugging. Debug mode is only for this install. The apps stay after you turn it off.

If pairing or installation fails, follow the installer's Wear OS 4+ help. This Wi-Fi pairing is for installation; the Bluetooth pairing inside GlucoPhone is a separate step below.

3. Add the face and tiles

Long-press the current watch face → Add watch face → GlucoWatch face. If a complication is empty, long-press → Customize → tap the slot → choose a GlucoWatch provider such as Glucose or Glucose chart. The face needs the GlucoWatch app on the same watch.

Swipe through the watch's tiles → Add tiles and choose Glucose, Glucose, time and heart, or Glucose (light). For heart rate, grant access when the face asks, and tap Allow heart rate in GlucoWatch → Settings for the tiles.

Updating later

Obtainium checks for GlucoPhone updates. Open its entry and install the update. Do not uninstall GlucoPhone first. Uninstall only when a debug copy is in the way, as in Leave a debug install.

For the watch, download the newer app and face files from that same release and repeat Custom APK → Install in Wear Installer 2. Turn debug mode on for the install and off when both files have installed. Do not uninstall the watch apps first, unless the copy on the watch is still the debug one from a computer.

Update all three together, the phone app and both watch files, from one release. The watch's Wi-Fi address and connection port can change each time you turn debugging on.

If you prefer a computer, use the adb installation instructions. The phone app has not been submitted to F-Droid. Links to the watch and face submissions are in the release notes for developers below.

Connect your data

On GlucoPhone, open Connect. On GlucoWatch, open Settings. Choose a source, set your display units and tap Save & test.

Source	What you need	What it provides
Demo data	Nothing	Sample glucose, treatments and a forecast; works offline
Dexcom Share	Dexcom username, password and account region	Glucose and trend; enable Share in the official Dexcom app with at least one follower
Nightscout	Your site's URL and, for a private site, a read token	Glucose, uploaded treatments, insulin/carbs on board and loop forecasts when available
Dexcom G6 notifications (phone only)	Official G6 app on the same phone, Quick Glance on, notification access	New glucose readings collected locally; no Share login or glucose backfill
CareLink (MiniMed)	A care partner account and the account's country	Pump data where uploaded; can also supply glucose, depending on the device

Dexcom Share: choose Outside US (EU), US, or Japan for your account. A wrong region can look like a failed login. Share does not supply insulin or carbs.

Nightscout: enter your site's address. Use API v1 unless you specifically need v3; API v3 requires a token. For a private site, create a token with the readable role under Admin tools → Subjects. The app reads your site; it does not write treatments back. Loop data is displayed only while fresh. See Nightscout support.

G6 notifications: on the phone's Connect tab, choose Dexcom and enable Use G6 notifications instead of Dexcom Share. Turn on Quick Glance in G6, tap Allow notification access, grant access in Android settings, return and tap Save & test. New readings can take five minutes to arrive. History starts when collection begins; notification timestamps may differ from sensor timestamps. For the watch, use Phone app as its source.

Additional insulin sources: use your own Nightscout or CareLink alongside your CGM to show therapy data. Only combine sources belonging to the same person. CareLink setup explains browser sign-in and the pump data available.

You can also import an existing configuration with Connect → Upload .env / YAML or Import from URL. See configuration import and the YAML example. A filled configuration contains credentials; keep it private.

Connect your phone and watch

First pair your watch with your phone through its usual Wear OS or Galaxy Wearable setup. Then pair the two GlucoWatch apps:

1. On the phone, open GlucoPhone → Watch → Pair a watch.

2. On the watch, open GlucoWatch → Settings → Pair with phone. Allow Nearby devices on both devices and keep the pairing screens open.

3. Compare the six-digit codes and tap Codes match on both devices.

4. Choose how the watch gets its readings:

   Mode	Watch setting	When to use it
   The phone fetches and relays	Source Phone app → Save & test	Use the phone's CGM/pump data or G6 notifications; the watch needs Bluetooth range, but no internet or login
   The watch fetches directly	Source Dexcom Share or Nightscout → Copy login from phone → Save & test	Enter the login on the phone once, then let the watch use its own network connection

With Phone app as the watch source, choose Phone app model under Forecast to show the forecast computed by GlucoPhone. The model stays on the phone.

The Bluetooth relay is still being tested: pairing, syncing and copying a login between a real phone and watch have not yet been verified. The standalone watch and phone apps can be tried independently. See phone link status and limits. If you report a test result, include device models, OS versions and app versions, and remove credentials and personal health data from anything you post publicly.

Privacy and troubleshooting

Credentials and caches stay in each app's private storage. Source requests go to the services you select; there is no project server. The phone–watch exchange is encrypted after you confirm pairing. Meal photos, manually logged meals/insulin and phone heart-rate data stay on the phone. An imported model runs locally; selecting a Hugging Face model downloads its files without uploading your glucose. See the phone link guide.

• No reading: check the selected source, Dexcom Share/follower setup or Nightscout token, and the status returned by Save & test.
• Old readings: check your upstream CGM and internet connection. A successful connection does not make an old reading fresh. In phone relay mode, also check Bluetooth range.
• Dexcom works on Wi-Fi but fails on mobile: use watch Settings → Connection check. Carrier blocking explains the errors and available routes. Resolve over HTTPS is off by default; use it only for a diagnosed DNS failure.
• Phone sync stops: check Nearby devices permission and the phone's battery restrictions. Some manufacturers stop background services; see known limits.
• Empty face: install both the watch app and face, open the app once, then check complication providers.

For developers

For Android Studio, JDK 21, a virtual watch, debug defaults and desktop source checks, see Developing GlucoWatch. Released APKs need none of that setup. Project rules are in AGENTS.md. The license is Apache-2.0.

Modules

Module	Role
core/	JVM clients, source sync, models, predictors, demo data, encrypted phone link and desktop CLI
app/	Wear OS app, cached readings, settings, five complications and three tiles
watchface/	Watch Face Format XML; shows the app's complications
phone/	GlucoPhone dashboard, source setup, local model imports and Bluetooth relay
onnx-inference/	Shared adapter for the phone's local ONNX Runtime inference

Build and test

Requirements: Android SDK (ANDROID_HOME or sdk.dir in local.properties) and an installed JDK 21 compiler. Gradle 9.1.0's wrapper runs on Java 17–25.

./gradlew :core:test
./gradlew :app:assembleDebug :watchface:assembleDebug :phone:assembleDebug

Debug APKs are in each module's build/outputs/apk/debug/ directory. Debug builds can compile private .env defaults into the APK; keep those APKs private. Release builds leave credential fields empty. See the debug setup guide.

Before a release tag, test and build inside each module, as F-Droid does:

./gradlew :core:test
(cd app && ../gradlew assembleRelease)
(cd watchface && ../gradlew assembleRelease)
(cd phone && ../gradlew assembleRelease)

Keep all three app version codes/names together. Signing, reproducibility, store requirements and metadata are covered in store publishing. F-Droid submissions: watch app and watch face.

Install the watch from a computer

Enable watch ADB/Wireless debugging and use the pairing and connection ports described above. Install Android platform-tools, download the app and face APKs from the same release, and replace the placeholders:

adb pair <watch-ip>:<pair-port>     # enter the six-digit pairing code
adb connect <watch-ip>:<connect-port>
adb -s <watch-ip>:<connect-port> install -r glucowatch-<version>.apk
adb -s <watch-ip>:<connect-port> install -r glucowatch-watchface-<version>.apk

Turn debugging off afterwards. For debug builds, substitute the local APK paths from the developer guide.

Debug on a Galaxy Watch

This installs a debug build on a watch you wear. The app and the face are two packages. Install both, or the face has nothing to draw. A debug APK signed with the debug key cannot replace a release install in place, and adb install -d does not downgrade a release build.

On Windows, adb is often not on PATH. If an emulator is also attached, pass -s and the watch's address so the install does not land on the emulator.

$adb = "$env:LOCALAPPDATA\Android\Sdk\platform-tools\adb.exe"
& $adb pair 192.168.1.50:37123
& $adb connect 192.168.1.50:41529
& $adb devices
.\gradlew.bat :app:assembleDebug :watchface:assembleDebug
& $adb -s 192.168.1.50:41529 install -r app\build\outputs\apk\debug\app-debug.apk
& $adb -s 192.168.1.50:41529 install -r watchface\build\outputs\apk\debug\watchface-debug.apk
& $adb -s 192.168.1.50:41529 shell am broadcast -a com.google.android.wearable.app.DEBUG_SURFACE --es operation set-watchface --es watchFaceId io.github.antonkulaga.glucowatch.watchface

Replace the IP and ports with the ones from Wireless debugging. The pairing port and the connection port are different numbers. Each install prints Success. Open GlucoWatch once so the complications refresh.

INSTALL_FAILED_VERSION_DOWNGRADE means the watch already has a higher versionCode. Uninstall both packages, then install again. That clears the login and the phone pairing stored on the watch.

& $adb -s 192.168.1.50:41529 uninstall io.github.antonkulaga.glucowatch
& $adb -s 192.168.1.50:41529 uninstall io.github.antonkulaga.glucowatch.watchface

To put the GitHub release back on the watch, uninstall both debug packages first. The release cannot update a debug install. The steps without a computer are in Leave a debug install.

Leave the phone's GlucoPhone installed if it is already the release. The watch and that phone have to speak the same link, PhoneLink.VERSION. If they do not, the phone says to update both. Replacing GlucoPhone with an older APK is the same downgrade and wipes the phone app you already use. After a watch uninstall, pair again: GlucoPhone → Watch → Pair a watch, and on the watch Settings → Pair with phone. Tap Codes match when both show the same code, set the watch source to Phone app, and tap Save & test.

Screenshots and implementation guides

uv run scripts/screenshots.py demo              # default 432 px round watch
uv run scripts/screenshots.py demo --watch all  # all three Galaxy watch sizes
uv run scripts/phone_screenshots.py demo         # 1080 × 2340 phone emulator

Generated captures stay in gitignored data/output/screenshots/. The reviewed demo images used above are checked in under docs/images/screenshots/; their provenance and refresh commands are in the screenshot guide. Never publish real-data captures. Store assets come only from demo captures using uv run scripts/store_images.py; the icon comes from uv run scripts/make_icon.py.

Further details: Nightscout APIs and freshness, Bluetooth pairing and encryption, network diagnostics, local prediction, and configuration import.