20 — Publishing Sukrara: Homebrew, notarized Mac builds, Google Play, F-Droid and the Garmin store
Esta página aún no está disponible en tu idioma.
2026-10-18 · research report, nothing shipped · official docs, policy pages and recent announcements, all read on 2026-10-18 (each claim links to a numbered source; the Sources list gives the date seen)
Sukrara ships today as GitHub Release files: an APK signed with the debug keystore (app.mauri.sukrara.poc) and
a Mac dmg/zip signed with a free Apple Development identity, so macOS says “Apple could not verify … is free of
malware”. Before the real app (app.mauri.sukrara) is built, the user wants to know how to publish it properly on
every platform it runs on:
- Mac:
brew installfor developers and a plain download for everyone else; Developer ID + notarization, Mac App Store, in-app updates. - Android: Google Play (the user’s old developer account was closed for inactivity: warned 2024-01-09, closed 2024-03-14, fee not refunded, “create a new account”), Google’s 2026 developer verification for sideloaded apps, and the open alternatives (F-Droid, IzzyOnDroid, Obtainium, Accrescent).
- Garmin: the Connect IQ Store for the planned watch app.
- Cross-cutting: Libre/LibreView naming, privacy policy and data-safety answers, GPL obligations, costs, effort.
Method
Section titled “Method”Web research only (no app changes): Apple, Homebrew, Sparkle, Google Play Console Help, Android Developers, F-Droid,
IzzyOnDroid, Accrescent and Garmin pages, plus news for timelines that official pages only summarise. Third-party
sources are marked as such. The app’s own facts come from the repo: poc/spikes/showcase-android/app/build.gradle.kts
(targetSdk 37, minSdk 36, debug signing, Juggluco’s GPLv3 security core compiled from a separate checkout),
the manifest (permissions below), poc/spikes/menubar/bundle.sh / dmg.sh (Developer ID + notarytool already wired),
the last release (APK 18.9 MB, dmg 11.0 MB) and the Play Store (app.mauri.sukrara and .poc both return 404, i.e.
unused).
Result
Section titled “Result”| Platform | Recommended channel(s) | Blocker today | Cost |
|---|---|---|---|
| Mac, non-developers | Notarized dmg from sukrara.mauri.app / GitHub Releases + Sparkle 2 in-app updates | Paid Apple Developer Program (Developer ID) | 99 USD/year |
| Mac, developers | Own tap mauriciabad/homebrew-tap → brew install --cask mauriciabad/tap/sukrara; later the official cask |
Official cask needs Gatekeeper-passing (notarized) builds + notability | 0 |
| Mac App Store | Go (2026-11-11): a sandboxed build without the update check, TestFlight first (review risk) | The App Store Connect app record and the distribution certificates (the owner) | (same 99 USD) |
| Android, everyone | Google Play (the reinstated personal account; app created 2026-11-10), every feature but the updater (decided 2026-11-11, Flavors) None: live since 2026-11 (0.14.5, the account section) | paid (old account) | |
| Android, power users | GitHub Releases + Obtainium, IzzyOnDroid; the “full” flavor with the updater (#188) | Release key; package registered for developer verification before it is enforced globally (2027) | 0 |
| Android, F-Droid main repo | Later, optional | Build from source incl. Juggluco core + rust-nostr; likely NonFreeNet anti-feature | 0 |
| Garmin | Connect IQ Store, free app | Developer account; privacy policy; no medical claims | 0 |
Total: 99 USD per year (Apple) + 25 USD once (Google Play). Everything else is free.
Homebrew
Section titled “Homebrew”The official cask is closed to Sukrara as it is today. Homebrew 5.0.0 (2025-11-12) deprecated casks without code
signing and deprecated --no-quarantine / --quarantine, saying it “does not wish to easily provide circumvention
to macOS security features” [H1]. On 2026-09-01 Homebrew disabled every cask in homebrew/cask that fails
Gatekeeper checks [H2][H3]; casks “must not require System Integrity Protection or Gatekeeper to be disabled or
bypassed” [H4]. Only the official tap is affected; maintainers point non-qualifying apps to their own taps [H2].
The official cask also has a notability bar (shared GitHub-popularity metrics, with room for “strong independent
public interest”) [H4], which a young project may not meet yet.
Own tap: works now, and the official cask later. What it needs:
| Piece | What |
|---|---|
| Repo | github.com/mauriciabad/homebrew-tap with Casks/sukrara.rb |
| Cask | version, sha256 of the dmg, url to the GitHub Release asset, name, desc, homepage, app "Sukrara.app", depends_on macos: ">= :sequoia" (or whatever the widgets need), auto_updates true (added by the bump workflow with the first Sparkle release), zap trash: for ~/Library/Logs/Sukrara.log, the App Group container and preferences |
livecheck |
url :url + strategy :github_latest (versioned asset names required) [H5] |
| Auto-bump | a release workflow in this repo (or a scheduled one in the tap) computes the sha256 and commits the new version; a scoped token with contents: write is enough [H5] |
| Trust | since Homebrew 6.0.0 (2026-06-11) non-official taps need explicit trust; brew install --cask mauriciabad/tap/sukrara (fully qualified) trusts that cask automatically, brew tap + short name needs brew trust [H6][H7] |
Until the builds are notarized, a tap cask could strip quarantine in postflight (xattr -dr com.apple.quarantine),
as several taps do [H5], but that is exactly the bypass Homebrew removed upstream and it teaches users to trust an
unverified binary. Recommendation: publish the tap only together with the first notarized build, then submit to
homebrew/cask once notability is plausible; the tap cask moves over unchanged.
Update (v0.11.14, user’s call): the tap is live with the not-yet-notarized build:
mauriciabad/homebrew-tap, brew install --cask mauriciabad/tap/sukrara. No quarantine stripping: the cask’s caveats explain the one-time Open Anyway step, the
same as the dmg (tested 2026-10-18 on macOS 27: brew-installed app blocked with “Sukrara” Not Opened, runs after the
approval). brew audit --cask --strict and brew style pass. .github/workflows/homebrew-tap.yml bumps version +
sha256 in the tap on every published release (every release is a normal one since 2026-11-12; a GitHub
prerelease, a release candidate, is skipped, like the apps’ update checks skip it); it
pushes with a write deploy key of the tap, stored here as the secret HOMEBREW_TAP_DEPLOY_KEY. Since 0.12.0
(#112) the cask installs the notarized app.mauri.sukrara dmg from this repo, without the Open Anyway caveat, and
its uninstall / zap name app.mauri.sukrara. One-time setup (the repo owner):
ssh-keygen -t ed25519 -N '' -C 'release workflow → homebrew-tap' -f /tmp/tapkeygh repo deploy-key add /tmp/tapkey.pub -R mauriciabad/homebrew-tap --allow-write --title 'sukrara release workflow'gh secret set HOMEBREW_TAP_DEPLOY_KEY -R mauriciabad/sukrara < /tmp/tapkeyrm /tmp/tapkey /tmp/tapkey.pubDeveloper ID + notarization (the real fix for “could not verify”)
Section titled “Developer ID + notarization (the real fix for “could not verify”)”- Apple Developer Program: 99 USD per membership year (local price shown at enrolment), individuals can enrol (2FA Apple Account, own credit card; the seller name is the person’s legal name) [A1][A2]. Developer ID certificates and notarization cost nothing extra; a free Personal Team cannot notarize [A3].
- Our scripts already do the rest (
poc/spikes/menubar/bundle.sh,dmg.sh, NEXT.md §5): once, create a Developer ID Application certificate andxcrun notarytool store-credentials sukrara …; thenSIGN_ID="Developer ID Application: … (TEAMID)" NOTARY_PROFILE=sukrara ./bundle.sh && NOTARY_PROFILE=sukrara ./dmg.shsigns (hardened runtime), notarizes and staples the app, then the dmg, and writes the release zip. The App Group is team-prefixed, so no provisioning profile is needed. - CI (optional, later): the same commands in a GitHub Actions macOS job with the certificate as a base64
.p12secret and an App Store Connect API key for notarytool. Keeping it local is fine at one release a week. - Side effects: the paid team may have a different Team ID than the free personal team, so the App Group
(
<TEAMID>.app.mauri.sukrara…) and the code signature change: existing Mac users get one more Keychain prompt, and the widgets read a new container (the host rewrites it on the next reading). Combine it with theapp.mauri.sukrararename so it happens once.
Mac release: Developer ID and notarization
Section titled “Mac release: Developer ID and notarization”Built 2026-11-10 (#91, notarization first, Sparkle next):
tools/release/mac-release.sh switches Developer ID signing and notarization on by itself once the credentials below
exist on the release Mac; until then it builds as before (Apple Development, Open Anyway). The owner creates, once
(about an hour, as the account holder):
-
Team ID: developer.apple.com › Account › Membership details. If it isn’t
QWUV9H4A3G(the free personal team’s), say so before the first notarized release:TEAMinapps/macos/Bundle/bundle.sh, the team check intools/release/verify-app.shand the App Group<TEAM>.app.mauri.sukrara(SukraraIDs.appGroupand its test, the entitlements: #19) change together, and the widgets read a new container. -
Certificate: Developer ID Application. Not Developer ID Installer (Sukrara ships a dmg, not a pkg) and not Apple Distribution (that’s the App Store). Xcode › Settings › Accounts › the paid team › Manage Certificates… ›
- › Developer ID Application (the private key is made in the login keychain); or developer.apple.com ›
Certificates › + › Developer ID Application (G2 Sub-CA) with a CSR from Keychain Access › Certificate Assistant ›
Request a Certificate From a Certificate Authority. Check:
security find-identity -v -p codesigninglists"Developer ID Application: … (<TEAM ID>)". Back it up: Keychain Access › My Certificates › that identity › Export… as.p12with a strong password, into the password manager (like the Android key; never the repo).
- › Developer ID Application (the private key is made in the login keychain); or developer.apple.com ›
Certificates › + › Developer ID Application (G2 Sub-CA) with a CSR from Keychain Access › Certificate Assistant ›
Request a Certificate From a Certificate Authority. Check:
-
App ID and provisioning profile: none for notarization. The entitlements (a team-prefixed App Group, nothing restricted) need no profile. Explicit App IDs (
app.mauri.sukrara,app.mauri.sukrara.widget, macOS) and a Developer ID provisioning profile only if #19 decides an entitlement needs one (e.g. Time Sensitive notifications, which is worth checking while enrolling); that’s #19’s change, not the release script’s. -
Notary credentials, stored in the login keychain as the notarytool profile
sukrara, one of:- App Store Connect API key (recommended: not tied to the Apple Account’s password or 2FA, revocable on its own):
App Store Connect › Users and Access › Integrations › App Store Connect API › Team Keys › + (name
sukrara-notary, access Developer); downloadAuthKey_<KEY ID>.p8(offered only once) and note the Key ID and the Issuer ID. Thenxcrun notarytool store-credentials sukrara --key ~/Downloads/AuthKey_<KEY ID>.p8 --key-id <KEY ID> --issuer <ISSUER ID>, the.p8into the password manager, and the download deleted. - App-specific password: account.apple.com › Sign-In and Security › App-Specific Passwords › + (
sukrara-notary). Thenxcrun notarytool store-credentials sukrara --apple-id <Apple Account e-mail> --team-id <TEAM ID>(it asks for the password, so it stays out of the shell history).
Check:
xcrun notarytool history --keychain-profile sukraraanswers (an empty list the first time). - App Store Connect API key (recommended: not tied to the Apple Account’s password or 2FA, revocable on its own):
App Store Connect › Users and Access › Integrations › App Store Connect API › Team Keys › + (name
What the release then does by itself: mac-release.sh finds the Developer ID identity (SIGN_ID picks another by
name or SHA-1) and refuses unless the profile sukrara answers (NOTARY_PROFILE names another); a Developer ID build
is never released unnotarized. bundle.sh signs the widget, then the app, with the hardened runtime and a secure
timestamp, submits the app to notarytool (--wait) and staples it. verify-app.sh --notarized checks, on the app and
the widget, the Developer ID authority, the hardened runtime, the secure timestamp, the stapled ticket and Gatekeeper’s
verdict (spctl: Notarized Developer ID). dmg.sh signs, notarizes and staples the dmg, and mac-release.sh checks
its ticket and Gatekeeper’s verdict. A rejected submission stops the release (apps/macos/build/notary.log; details with
xcrun notarytool log <submission id> --keychain-profile sukrara). 0.12.0 was the first notarized release: README ›
Install, the site, docs/DEVELOPMENT.md, the dmg window and the cask no longer mention Open Anyway (the dmg window
shows its first-launch help only for a build that isn’t notarized), and the cask can aim at the official tap.
Sparkle: built on 2026-11-11 (the owner’s decision: signed feed, one-click Install and Relaunch for the GitHub / Homebrew version, none in the App Store version), see Sparkle: the update feed.
In-app updates: Sparkle 2
Section titled “In-app updates: Sparkle 2”Sparkle 2 (current 2.9 line [S1]): generate_keys puts an EdDSA private key in the login keychain and prints
SUPublicEDKey; SUFeedURL points at the appcast; generate_appcast <folder> signs the archives and writes the
appcast (+ deltas); updates must be served over HTTPS [S1]. Developer ID signing is recommended (“if possible”) and
needed for key rotation [S1]. Plan: appcast at https://sukrara.mauri.app/appcast.xml (GitHub Pages is HTTPS),
enclosures pointing at the GitHub Release dmg; the EdDSA private key stays on the user’s Mac (export a backup to the
password manager). The cask then sets auto_updates true so brew upgrade doesn’t fight Sparkle. Built: see
Sparkle: the update feed.
Sparkle: the update feed
Section titled “Sparkle: the update feed”Built 2026-11-11 (#91), Sparkle 2.10.1 (SwiftPM, exact pin).
What the app has. The GitHub version is the Sukrara executable, which links SukraraUpdater (Sparkle behind
SukraraApp’s UpdaterEngine); bundle.sh embeds Sparkle.framework in Contents/Frameworks, signs it inside-out
(Installer.xpc, Downloader.xpc keeping its entitlements, Autoupdate, Updater.app, the framework; Developer ID,
hardened runtime, secure timestamp) and merges Bundle/sparkle.plist into its Info.plist: SUFeedURL
https://sukrara.mauri.app/appcast.xml, SUPublicEDKey VM8dSc/QTIcaHv5EgT02zW0gWCNg8rr39HqcgIMJNaM=,
SUEnableAutomaticChecks (once a day, no first-launch question) and SUVerifyUpdateBeforeExtraction (the dmg is
checked before Sparkle opens it: its EdDSA signature, or only for a key change the dmg’s own Developer ID signature of
the same team; after extraction the new app must still match, below). The App Store version is the SukraraAppStore executable: no Sparkle
in the binary, the bundle or the Info.plist (bundle.sh --app-store and verify-app.sh --app-store refuse any).
Dev, fixture, snapshot and test runs never create the updater (LaunchPlan). What the person sees:
docs/FEATURES.md › Updates (Mac, GitHub version). Notarization with Sparkle’s XPC services inside: accepted on
2026-11-11 (submission 1d7bb1ff-e862-4853-84a7-57e80fcd5176, verify-app.sh --notarized all ok).
Where the feed lives: GitHub Pages, website/public/appcast.xml. A release asset can’t be the feed: a per-release URL would have to be
known before the release exists, and the stable releases/latest/download/… URL skipped every 0.x release while they
were prereleases (until 2026-11-12). Pages is HTTPS on the project’s own
domain, already serves the site and .well-known, deploys on every push to main (.github/workflows/website.yml;
the site build copies website/public/ unchanged), and the file is reviewed in
git like the rest. The enclosures stay on GitHub Releases (the same dmg as the download and the cask).
No channels. Until 0.14.5 every 0.x release was a GitHub prerelease in Sparkle’s prerelease channel, which 0.x
installs allowed. Since 2026-11-12 every release is a normal GitHub release (marked Latest), so appcast.py writes
items without a channel and the app takes the default channel only (UpdatesTests: no item has one). Installs from
before still allow the old channel too, so they take the new items as well.
A release (tools/release/mac-release.sh, everything it did before plus): once the dmg is notarized and stapled,
Sparkle’s sign_update (from the SwiftPM artifact, apps/macos/.build/artifacts/sparkle/Sparkle/bin) signs it with
the key in the login keychain (macOS may ask once to let sign_update use it: Always Allow), checks the signature,
checks the keychain’s public key is the app’s SUPublicEDKey, and tools/release/appcast.py adds the item to
website/public/appcast.xml: version and build, minimumSystemVersion 15.0, the channel, the GitHub release page as the full
notes, the version’s CHANGELOG.md section as the notes Sparkle shows, and the enclosure
https://github.com/mauriciabad/sukrara/releases/download/v<version>/Sukrara-<version>.dmg with its length and EdDSA
signature (re-running replaces that version’s item). Only the dmg is the update; the zip stays a plain download. An
unnotarized build never goes in. Then, in this order: publish the GitHub release with that exact dmg (any rebuild
changes the signature: run mac-release.sh again), then commit website/public/appcast.xml and merge it to main; Pages
deploys it within minutes and every GitHub install sees the update at its next daily check. Committing it first would
offer a download that isn’t there yet. tools/release/release.py keeps that order (its github, then sparkle step) and checks the
dmg on the release is the one the item signs. UpdatesTests checks every item (the GitHub URL, a 64-byte signature, the
channel, the build number, newest first).
The key. Made on 2026-11-11 with generate_keys on the release Mac: the private key is in the login keychain
(a password item, service https://sparkle-project.org, account ed25519), and a backup is at
~/.apple-dev/sparkle-eddsa-private.key (chmod 600). The owner copies that file into the password manager (Proton
Pass, with the rest of ~/.apple-dev). It’s printed nowhere and never committed. On a new release Mac:
apps/macos/.build/artifacts/sparkle/Sparkle/bin/generate_keys -f <backup file> imports it into that Mac’s login
keychain; generate_keys -p must print the public key above.
If the key is lost (no keychain item, no backup): no update can be EdDSA-signed for the installed copies, because
each checks the key in its own Info.plist. Sparkle’s way out is key rotation through Apple code signing (checked in
Sparkle 2.10.1’s AppInstaller.m / SUUpdateValidator.m): an update whose dmg and app are signed by the same
Developer ID team as the installed app may carry a new SUPublicEDKey, and is then accepted without the old key.
So: generate_keys makes a new key (back it up), its public key goes into Bundle/sparkle.plist, and the next release
is made as usual (dmg.sh signs the dmg with the app’s Developer ID, mac-release.sh signs it with the new key);
from then on the new key is the one. If the Developer ID certificate is lost too, every Mac has to download the next
dmg by hand (README › Install; the cask still works with brew upgrade --greedy). A leaked key: the same rotation, as
fast as possible.
Homebrew. .github/workflows/homebrew-tap.yml adds auto_updates true to the cask with the first release that
has the updater (and keeps it): brew upgrade then leaves Sukrara to Sparkle, brew upgrade --greedy still upgrades
it. Not before: 0.13.0 has no updater, and a cask with auto_updates isn’t upgraded by a plain brew upgrade, so
0.13.0 installs would stay there. The tap’s own README needs no change.
Checking it end to end without the owner’s Mac’s app. A normal launch of a build outside the repo is the owner’s
app (their follower key, relays, alerts), so the local check never runs one. It runs two Developer ID builds without a
provisioning profile (bundle.sh --no-profile: no invite links, no data-protection keychain) as dev runs in a scratch
folder that has a .git marker (isolated data: SUKRARA_DEV=1, SUKRARA_DEV_HOME), with a local patch that is never
committed: the dev run starts only the updater and checks at once with automatic download on, Sparkle uses its own
defaults domain (SUDefaultsDomain), reads a
http://127.0.0.1 feed, and updater(_:willInstallUpdateOnQuit:immediateInstallationBlock:) installs at once. N+1’s
dmg is signed with sign_update and listed by appcast.py. Afterwards the builds are deleted and unregistered
(lsregister -u, pluginkit -r for the widget). Result on 2026-11-11 (0.13.90 → 0.13.91, Developer ID, Sparkle
2.10.1): the running 0.13.90 found 0.13.91 in the prerelease channel, downloaded the 15 MB dmg, verified it, installed
it in place and relaunched in about 3 s; the copy in place was 0.13.91 (13091) with a valid Developer ID signature, and
the relaunched copy (started without SUKRARA_DEV) was refused by the launch gate, as a dev copy should be. Then a feed
item “0.13.92” carrying another file’s signature: The update is improperly signed and could not be validated,
nothing installed. The owner’s app and its defaults were untouched (no SU* key in app.mauri.sukrara).
In Sukrara. Added: the above. Discarded, with the reason: generate_appcast (it wants every archive in one local
folder and rewrites the whole feed; one item per release from appcast.py is simpler and keeps the history in git);
delta updates (a 10 MB dmg once a week doesn’t need them, and they’d need the previous archives); a signed feed
(SURequireSignedFeed: every hand edit of website/public/appcast.xml would then lock all installs out; the archives are
signed and verified before extraction, which is what protects the install); a notification for a found update
(notifications are for glucose; the panel row and Sparkle’s window are enough); automatic install on by default (a
follower’s alarm should not change under the person without them knowing; it’s one switch away); removing Sparkle’s
XPC services (unused by a non-sandboxed app, but they’re part of the signed framework and notarize fine).
Provisioning profiles: Time Sensitive alarms, the data-protection keychain, universal links (#19, #34)
Section titled “Provisioning profiles: Time Sensitive alarms, the data-protection keychain, universal links (#19, #34)”Three things only a provisioning profile grants; Bundle/bundle.sh adds them when it finds a profile, and the app
reads its own entitlements at launch and falls back without them:
Entitlement (Bundle/app-profile.entitlements.in) |
With it | Without (ad hoc, dev, no profile) |
|---|---|---|
com.apple.developer.usernotifications.time-sensitive |
alarms break through a Focus (TimeSensitive) |
normal notifications; the panel, setup and Settings › Alerts say a Focus can hold them back |
keychain-access-groups = QWUV9H4A3G.app.mauri.sukrara |
the follower key and Juggluco’s secret in the data-protection keychain, no prompts after re-signing (KeychainStore.secrets) |
the login keychain (an ACL on the signature: one prompt per signing change) |
com.apple.developer.associated-domains = applinks:sukrara.mauri.app |
the web invite clicked anywhere opens the Follow step (AppLink.universal) |
the web invite opens the page, which offers the sukrara: link |
Owner checklist (done on 2026-11-10 for Developer ID; repeat when a certificate or profile is renewed):
- App IDs (Certificates, Identifiers & Profiles › Identifiers):
app.mauri.sukrarawith Time Sensitive Notifications and Associated Domains;app.mauri.sukrara.widgetwith nothing extra. No App Groups capability (QWUV9H4A3G.app.mauri.sukrarais team-prefixed: macOS grants it from the signature) and no Keychain Sharing (every profile carrieskeychain-access-groups = QWUV9H4A3G.*, which covers the app’s own group). - Profiles: macOS › Developer ID, one per App ID, with the Developer ID Application certificate (
Sukrara Mac Developer ID,Sukrara Mac Widget Developer ID, valid until 2044-11-05). Only if Apple Development builds should keep the entitlements too: a macOS App Development profile per App ID with the Apple Development certificate and this Mac registered (its Provisioning UDID:system_profiler SPHardwareDataType). - Where:
~/.apple-dev/profiles/*.provisionprofile(SUKRARA_PROFILES_DIRfor another folder).bundle.shpicks, per App ID, the unexpired profile that lists the signing certificate (and this Mac, for a development one), and withoutSIGN_IDsigns with an identity such a profile lists: with the Developer ID profiles above, everybundle.sh(and sotools/install.sh macandmac-release.sh) signs with Developer ID and embeds them. A profile missing a capability stops the build with what to enable. The owner keeps a backup of~/.apple-dev(the Developer ID key, the notary.p8, the profiles) in their password manager (Proton Pass), like the Android release key. - Check:
cd apps/macos && Bundle/bundle.shends withsigned: "Developer ID Application: …", profile "Sukrara Mac Developer ID" until …;tools/release/verify-app.sh build/Sukrara.applists the three entitlements (codesign -d --entitlements :- build/Sukrara.appshows them all);Bundle/smoke.shlaunches it offline with its own data and the app logslaunched (…; time-sensitive yes, data-protection keychain yes, universal links yes)(/usr/bin/log show --last 5m --info --predicate 'subsystem == "app.mauri.sukrara"').spctl -a -vvsays Unnotarized Developer ID until the build is notarized (above); a build made on this Mac has no quarantine, so it launches. All of this ran on 2026-11-10 with the profiles above; a build without them logsnothree times. - Site:
website/public/.well-known/apple-app-site-associationgives/jointoQWUV9H4A3G.app.mauri.sukrara(the profile’sTeamIdentifier; a new team changes it there, inbundle.shTEAM,SukraraIDs.teamIDandverify-app.sh). GitHub Pages publishes it (the Pages artifact includes hidden files); Macs read it through Apple’s CDN,curl -s https://app-site-association.cdn-apple.com/a/v1/sukrara.mauri.appshows what they see (refreshed within about a day of a change). - QA on the owner’s Mac (docs/QA.md Q6, Q8), then close #19: a Focus doesn’t hold back an alarm; the follower key moved (one Keychain prompt for the old login-keychain item, Always Allow); the web invite opens the Follow step.
Once a profile build has run, the follower key is in the data-protection keychain, which a build without the profile
can’t read (it would show not following). So bundle.sh stops when there is a profile for the app that can’t sign
the build (expired, another certificate) instead of quietly building without it; --no-profile builds without on
purpose. A test build with the profile also claims the invite links: never launch it from Finder, and unregister it
after testing (lsregister -u <app>, pluginkit -r <appex>).
Mac App Store: review risk (2026-11-11, #186)
Section titled “Mac App Store: review risk (2026-11-11, #186)”Finding: go, TestFlight first, then the Mac App Store, with the listing and in-app texts below. It replaces the
2026-10-18 “not now”, which assumed the Mac app talks to LibreView: it doesn’t (LibreView, the Nightscout upload and
the local Nightscout-style server are Android only, only: android in contracts/settings/settings.json; the Mac
has no listening socket). What Sukrara for Mac does, against the guidelines [A4]:
| Guideline | What it asks | Sukrara for Mac |
|---|---|---|
| 1.4.1 medical | greater scrutiny; accuracy claims must be backed or the app is rejected (“measure … blood glucose … using only the sensors on the device” is not permitted); remind users to check with a doctor; a clearance link if any | Measures nothing: it shows readings the wearer’s phone already has (Sukrara for Android over Nostr or Bluetooth, or Juggluco’s web server on the home network) and alerts on them. No accuracy claim, no clearance, so none is linked. Missing: the in-app reminder (added with the store build: setup’s first step and Settings › General) |
| 2.1 completeness | the reviewer must be able to see the app work | Nothing to see without a wearer. Review notes explain it; a demo video (Mac) and, if the owner agrees, a demo invite to a test wearer (an emulator debug build with the synthetic sensor, kept running during review). No demo mode in the app (CLAUDE.md: the release app never shows made-up values) |
| 2.4.5 (i) sandbox | appropriately sandboxed | The store build is sandboxed (below); the widget already was |
| 2.4.5 (iii) login | no auto-launch without consent | Open at login is a setup step and a switch the person turns on (SMAppService); nothing registers itself |
| 2.4.5 (vii) updates | only through the Mac App Store | The store build has no update check (like Android’s Play flavor) |
| 2.4.5 (ii, iv, v, ix) | Xcode tools, one bundle, no downloaded code, no root, all localizations inside | productbuild package of the one bundle with the widget inside; nothing downloaded or elevated; en + es in the bundle |
| 4.1(c), 5.2.1 | no other developer’s brand in the name or icon | The name is Sukrara, the icon our own; no FreeStyle Libre, Dexcom, Juggluco or Nightscout in name, subtitle, keywords or icon |
| 5.1.1 privacy | a privacy policy link in App Store Connect and in the app; consent; a way to withdraw | https://sukrara.mauri.app/privacy (its Mac part updated for this build). Missing: the in-app link (added: Settings › General). No account, no analytics |
| 5.1.3 health | no health data for ads or mining; none in iCloud; disclose the health data collected | None collected by the developer; readings stay on the Mac (31 days) and travel only end-to-end encrypted between the wearer and followers. No HealthKit, no iCloud |
| 5.2.2 third-party services | permission under the service’s terms | No vendor API on the Mac. Public Nostr relays (open protocol), and Juggluco’s web server, a documented feature of an app on the person’s own phone, on their own network |
How comparable apps fare (seen 2026-11-11). On the Mac App Store: GlucoseBar (Dexcom Share and Nightscout in the menu bar; Health & Fitness; “Data Not Collected”; 16+; “informational purposes only … verify any readings with their primary CGM solution”) [A6], Sugar Sense: Menu Bar Glucose (Libre, Dexcom and Nightscout through its own account; Medical; “Not a medical device … Base treatment decisions on your CGM’s own app or a blood glucose meter”; brands only in the description, not the name or subtitle; no notifications) [A7], Glucose Graph (Nightscout) [A8]. On iOS: nightguard (a Nightscout client with alarms, Medical, “Don’t use this App for medical decisions”) [A9], the official Dexcom Follow and LibreLinkUp. Gone: Sugarmate took itself off the App Store in 2022 when Dexcom’s partner API stopped serving users outside the US [A10]; Shuggah (Dexcom data, reported as a paid copy of xDrip4iOS) disappeared in August 2025 without a public reason [A11][A12]; Spike (read sensors through Bluetooth transmitters) was never on the store: a TestFlight beta, then an enterprise certificate Apple revoked in 2019 in a general clamp-down on enterprise distribution [A13]. The DIY apps that read sensors or drive pumps (xDrip4iOS, Loop, LoopFollow) stay self-built. The pattern: followers that show the person’s own data with a clear disclaimer, alarms included, pass review; the trouble is reading sensors directly and using a vendor’s API outside its terms. Sukrara for Mac does neither. The remaining risks are a reviewer who can’t see data (2.1, answered by the notes and the video) and a reviewer who reads the alerts as a medical claim (1.4.1, answered by the disclaimer and the listing’s wording).
The listing must say: what Sukrara for Mac is (a menu bar and widget follower of someone who shares their glucose
with Sukrara on their Android phone, or of Juggluco on the same network); that it needs that person (no sensor is read
by the Mac); alerts with their limits (a sleeping, offline or muted Mac can’t ring: keep the phone’s own alarms on);
not a medical device: values can be wrong, late or missing, don’t base treatment decisions on Sukrara, check the
sensor’s own app or a meter and talk to your doctor; no account, no data collected by the developer, end-to-end
encrypted sharing; free software (GPL, the source link); “FreeStyle Libre is a trademark of Abbott; Sukrara isn’t
affiliated with Abbott or Juggluco” when the description names them. Category Medical (LSApplicationCategoryType
already says so). App Privacy: Data Not Collected (end-to-end encrypted messages through relays nobody on our side
runs or reads; the readings stay on the Mac). Age rating: whatever the questionnaire gives with Medical or treatment
information: frequent.
The listing must not say: that it measures or reads glucose from a sensor, or any accuracy figure; that it replaces the CGM’s app, a meter, the phone’s alarms or a doctor; dosing or treatment advice (“take insulin”, “eat now”); “FDA”, “CE”, “approved”, “certified”, “official”, “safe”; a brand (FreeStyle Libre, Libre, Dexcom, Abbott, Juggluco, Nightscout) in the name, subtitle, keywords or icon; “best” / “#1”; screenshots with real health data (they are synthetic, CLAUDE.md).
Review notes (App Store Connect › App Review Information): “Sukrara for Mac shows the glucose of a person who shares it from Sukrara for Android (or from Juggluco on the same network). It reads no sensor itself. Without that person the app opens normally and shows Not following; setup, every Settings page and Send a test alert work. A video of it following a test wearer: .” Plus the demo invite if the owner keeps a test wearer running. No sign-in to give: Sukrara has no accounts.
Mac App Store: the App Store version (2026-11-11, #186)
Section titled “Mac App Store: the App Store version (2026-11-11, #186)”Built next to the GitHub version, like Android’s flavors (FEATURES › Mac App Store version):
| GitHub version | App Store version | |
|---|---|---|
| Build | Bundle/bundle.sh → tools/release/mac-release.sh (dmg, notarized) |
Bundle/bundle.sh --app-store → tools/release/mac-appstore.sh (pkg) |
| Binaries | the same swift build -c release output |
the same |
SukraraDistribution (Info.plist) |
github |
appStore |
| Update check | once a day + Check for Updates… | none: not started (ServicesPlan.all(for: .appStore)), no menu item, no Check now |
| About | 0.13.0 · GitHub version | 0.13.0 · App Store version |
| Sandbox | no (hardened runtime) | Bundle/appstore.entitlements.in: network client, Bluetooth, files the person picks; plus the camera, the App Group and the profile’s entitlements both versions have |
| Signing | Developer ID + the Developer ID profiles, notarized | Apple Distribution + the Mac App Store profiles; the pkg with Mac Installer Distribution |
CFBundleVersion |
<versionCode> |
<versionCode>.<yyMMdd>.<HHmm> (a new one per upload) |
| Checks | verify-app.sh --notarized |
verify-app.sh --app-store, pkgutil --check-signature, altool --validate-app |
Same bundle id (app.mauri.sukrara, decided 2026-11-11): one App ID with its capabilities (Time Sensitive, Associated
Domains), so the universal-link file, the App Group (QWUV9H4A3G.app.mauri.sukrara), the keychain group and the
widget’s id stay one; a person has one Sukrara, and switching keeps the follow (the follower key is in the shared
keychain group). A second id would mean a second App ID, profile set, App Group and site entry, and two Sukraras that
can run side by side and both ring. The cost: the two versions can’t be installed at once (TestFlight or the store
replaces the GitHub version in Applications, and tools/install.sh mac puts it back), and the App Store version’s data
lives in its container, so after a switch the readings come back from the wearer’s history and the Mac’s own settings
start from the defaults (no migration: CLAUDE.md).
What the sandbox changed in the shared code: nothing broke. Every path comes from homeDirectoryForCurrentUser,
which is the container in the sandbox (~/Library/Containers/app.mauri.sukrara/Data), so readings, treatments, the log
and the alert sounds (Library/Sounds of the container, where notifications look for them) move there by themselves;
the App Group, the data-protection keychain, SMAppService, the global shortcut (RegisterEventHotKey), the camera,
Bluetooth, the save panel and Host.current() work as before (checked with a sandboxed probe and the smoke run: no
sandbox denial in the log). The Mac app opens no listening socket, so no network.server. Fixed on the way, in both
versions, for App Review: the in-app medical reminder (setup’s Welcome and About Sukrara, 1.4.1) and the
privacy policy link (About Sukrara, 5.1.1). Bundle/smoke.sh now runs a sandboxed bundle with its dev data in a fresh folder
in its container (the only place it may write); CI’s mac job builds and smoke-runs it unsigned.
Not yet checked: what only a running, online App Store build shows (relays, the phone nearby, Juggluco, alerts with
their sounds, the widget, open at login): QA Q6, Q8, Q22 on the first TestFlight build. The smoke runs here are
offline by design (LaunchMode).
Mac App Store: signing and App Store Connect (state 2026-11-11)
Section titled “Mac App Store: signing and App Store Connect (state 2026-11-11)”Done 2026-11-11 (an agent in the owner’s signed-in Chrome; the API key VCB5XBQ3QZ, access Developer, reads
certificates, App IDs, profiles and builds but is refused (403) creating a certificate or a profile, and can’t create
the app record):
- Agreements: the Free Apps agreement is active; Paid Apps (not needed) is unsigned. Business also asks for the EU trader status (Digital Services Act): an App Store version in the EU needs it before review; TestFlight doesn’t.
- Certificates: Apple Distribution (
6642XM688S) and Mac Installer Distribution (36357R8WPQ, in the keychain as “3rd Party Mac Developer Installer”), both until 2027-11-11, from the CSRs in~/.apple-dev. Key and certificate in~/.apple-dev(apple-distribution.key/.cer,mac-installer-distribution.key/.cer, chmod 600) and imported into the login keychain (security importof a throwaway.p12,-T codesign/productbuild). Developer ID Application and Apple Development untouched. - App IDs: unchanged. No App Groups capability needed: validation accepts the team-prefixed group
(
QWUV9H4A3G.app.mauri.sukrara), and the Developer ID profiles stay valid. The SwiftPM resource bundle id passed too. - Profiles (Mac App Store Connect, the Apple Distribution certificate):
Sukrara Mac App Store(9YA7458SB6) andSukrara Mac Widget App Store(323P8KTP7X), until 2027-11-11, in~/.apple-dev/profiles/asSukrara_Mac_App_Store.provisionprofileandSukrara_Mac_Widget_App_Store.provisionprofile. They grant what the Developer ID ones do (Time Sensitive, Associated Domains, the keychain group). - App record: Sukrara, macOS, English (U.S.),
app.mauri.sukrara, SKUsukrara-mac, full access; Apple ID6833533014. - Validation: the first package was refused (90255, files only root can read):
bundle.shcopied the profiles with their 600 mode. It installs them with 644 now, andverify-app.shchecks every file is readable by everyone. - TestFlight: build
0.13.0 (13000.261111.1531)uploaded and processed (VALID); internal group Owner (the owner’s Apple Account, automatic distribution of new builds).
Back up ~/.apple-dev (both new keys, certificates and profiles) to the password manager with the rest.
Submitted for App Review 2026-11-13 (Waiting for Review; the owner deciding, an agent in Chrome): version
0.14.5, build 14005.261112.1554 (its export question answered: standard algorithms, not France), all 175
countries including France (the owner’s call, while ANSSI’s certificate is pending: if App Review or the France
storefront objects, remove France in Pricing and Availability until the certificate is uploaded), free, public
distribution, automatic release after approval; App Privacy Data Not Collected (published); DSA non-trader
(Business › Compliance: a free hobby project, nothing published; can be changed per app); App Review contact entered
by the owner; the review notes’ video line deleted (no video). The submit itself was an agent misclick on the
draft-submissions panel before the owner’s explicit go (App Review › Remove from review withdraws it).
The list below is the plan as it was (items 1, 3, 4 done; item 2 still open):
The owner, still to do (nothing here is accepted or submitted by an agent):
-
Export compliance of a build uploaded before 0.14.6 (later builds answer it in their Info.plist; TestFlight › the build › Manage): Standard encryption algorithms instead of, or in addition to, Apple’s (NIP-44: secp256k1, ChaCha20, HMAC-SHA256; TLS), none proprietary; then Is your app going to be available for distribution in France?: No until ANSSI’s certificate is uploaded (yes blocks the build until then). Until it’s answered the build shows Missing Compliance and can’t be installed.
France (ANSSI): French law requires a declaration to ANSSI for supplying encryption software in France, and Apple asks for its certificate before the App Store can list Sukrara in France. Filed by the owner on 2026-11-12 on demarche.numerique.gouv.fr (file 35378242, “Déclaration relative à un moyen de cryptologie”, as an individual; the brochures and form answers are in git history, commit 26365c80). Next: the certificate (“attestation de déclaration”) arrives by email, the owner uploads it in App Store Connect › App Information › App Encryption Documentation; Apple then gives an
ITSEncryptionExportComplianceCode, which goes into the App Store build’s Info.plist together withITSAppUsesNonExemptEncryptionYES, and France is added in Pricing and Availability. A new kind of encryption in the apps needs a new declaration. -
Install from TestFlight (the TestFlight app on the Mac): first quit Sukrara (TestFlight replaces
/Applications/Sukrara.app, the GitHub version) and delete~/Library/Containers/app.mauri.sukrara, which only holds the agents’ offline smoke runs. QA Q6, Q8 and Q22 on it;tools/install.sh macgoes back to the GitHub version. -
Listing: entered 2026-11-11, except what only the owner can give (the listing has what’s filled and the clicks left).
-
Submit for review.
Next uploads: tools/release/release.py (its testflight step), or by hand tools/release/mac-appstore.sh
(build, pkg, altool --validate-app), then --upload (uploads that pkg, builds nothing); each upload
gets a new CFBundleVersion and goes to the Owner group by itself: since 0.14.6 the App Store build’s Info.plist
answers the export question (ITSAppUsesNonExemptEncryption NO, see One-command release).
Mac App Store: the listing (entered 2026-11-11)
Section titled “Mac App Store: the listing (entered 2026-11-11)”Entered by an agent in the owner’s signed-in Chrome (App Store Connect, app 6833533014). Nothing was submitted, and no agreement, tax, banking, trader-status or export question was touched. The wording follows the review risk rules and the Play listing: no brand in the name, subtitle or keywords, no accuracy claim, no dosing advice, the not-a-medical-device statement.
Filled and saved
| Where | en-US | es-ES |
|---|---|---|
| App Information › Name / Subtitle | Sukrara / Glucose in your menu bar |
Sukrara / Glucosa en la barra de menús |
| Promotional text (≤ 170) | The glucose of someone you look after, live in your Mac's menu bar, with alerts when it goes low or high. End-to-end encrypted, no account. |
La glucosa de alguien a quien cuidas, en directo en la barra de menús de tu Mac, con alertas cuando baja o sube. Cifrada de extremo a extremo, sin cuenta. |
| Keywords (≤ 100) | diabetes,CGM,blood sugar,widget,alarm,alert,follow,caregiver,family,parent,type 1,T1D,monitor,sugar |
diabetes,CGM,azúcar,widget,alarma,alerta,seguir,cuidador,familia,padres,tipo 1,DM1,monitor,glucemia |
| Description | 2618 characters, below | 2856 characters, the same in Spanish (the Mac app’s own words: barra de menús, móvil, Concentración, urgente) |
| Screenshots | 6 at 2880 × 1800 (~/Pictures/sukrara-appstore/en/) |
6 (…/es/) |
| Support / Marketing URL | https://sukrara.mauri.app/mac/ / https://sukrara.mauri.app/ | the same |
| App Privacy › Privacy Policy URL | https://sukrara.mauri.app/privacy | the same |
Also: version 0.14.0 (was the default 1.0; it must equal the build’s version, so change it if another build is
submitted), copyright 2026 Maurici Abad, category Medical + Health & Fitness, content rights No third-party
content (the readings are the person’s own data), price Free in all 175 regions, Sign-in required off, and the
review notes (below).
Age rating: 16+ (Korea 15+; 17+ on OS versions before 26). Answers: every in-app control, capability, mature theme, sexuality, violence and chance item None / No; Medical or Treatment Information: Frequent (the app is about managing diabetes), Health or Wellness Topics: Yes (the card’s Eat carbs / Take insulin pills and the report’s consensus goals are self-care guidance). Judgement calls: Messaging and Chat: No and User-Generated Content: No (a treatment note is a ≤ 100-byte log entry seen only by the wearer and the followers they approved, not a messaging or publishing feature; Play’s IARC answer “users exchange text” is broader and stays as it is). Infrequent medical content would lower the rating but isn’t true for this app. GlucoseBar is 16+ too.
Description (en-US) (the Spanish text is in App Store Connect):
Sukrara shows the glucose of someone you look after in your Mac's menu bar, and alerts you when it goes too low or too high, changes fast, or stops arriving.
Sukrara for Mac follows a person who wears a glucose sensor and shares their readings from the Sukrara app on their phone. The Mac reads no sensor itself: it shows what their phone sends, end-to-end encrypted, over the internet or over Bluetooth nearby. It can also show the glucose from Juggluco on your home network.
Glucose at a glance• The value in its range colour, with its trend arrow, in the menu bar; struck through when it gets old.• Click it for the glucose card and a chart you can scroll back 31 days.• Desktop widgets with the same card.• VoiceOver reads the value, trend and range in one sentence, and a keyboard shortcut reads the glucose aloud from any app.
Alerts• Very low, low, high, very high and extremely high alerts, rising or falling fast, and no readings, with your own thresholds and sounds or the wearer's.• Mute them for a while and unmute them from the menu bar, or send a test alert any time.• When you allow it, alerts come through a Focus as Time Sensitive notifications.• A Mac that is asleep, offline or muted can't ring: keep the alarms on the wearer's phone on.
Follow someone• Open their invite link, scan its QR code with the Mac's camera, or pair nearby over Bluetooth and compare a 6-digit code. The wearer approves every follower.• No account to create and no server to host.
Treatments and reports• The wearer's insulin, carbs and notes on the chart, and your own when they allow it.• A glucose report for 1, 7, 14 or 30 days (time in ranges, average, GMI, variability), and CSV export.
Private by design• Readings travel end-to-end encrypted from the wearer's phone to your Mac and stay on your Mac for 31 days. The developer receives none of it: no analytics, no ads, no tracking.• Free and open source (GPL-3.0): github.com/mauriciabad/sukrara• In English and Spanish.
What you need• A Mac with Apple silicon and macOS 15 or newer.• Someone who shares their glucose with Sukrara on their Android phone and sends you an invite, or Juggluco on your home network.
ImportantSukrara is not a medical device and does not diagnose, treat, cure, or prevent any medical condition. Values can be wrong, late or missing, and alerts may not ring. Don't base treatment decisions on Sukrara: check the sensor's own app or a blood glucose meter, and ask your doctor or diabetes care team for medical advice. Sukrara is an early preview.
Sukrara is not affiliated with Juggluco or with any sensor maker.Android is named once, under What you need, because the Mac app only works with that phone app. Guideline 2.3.10
forbids other platforms’ names in metadata unless the app really works with them. If App Review objects anyway, it’s
a metadata-only fix: replace that line with Someone who shares their glucose with the Sukrara phone app (sukrara.mauri.app) and sends you an invite, …. No new build is needed.
Review notes (App Review Information › Notes, 1971 characters). They say:
- Sukrara has no account, so there’s no sign-in to give.
- Without a wearer, the panel says Not monitoring: not following anyone yet.
- What the reviewer can try: setup, every Settings pane, Settings › Alerts › an alert › Details… › Send Test Alert, and About with the medical reminder and the privacy link.
- The not-a-medical-device wording.
- Where the data goes: end-to-end encrypted, through relays the developer doesn’t run, kept 31 days.
- Why each entitlement is there.
- The GPL source.
They hold one placeholder, [VIDEO LINK TO ADD]. It stands for a video of the Mac following a test wearer: a
release or TestFlight Mac following an emulator debug build with the synthetic sensor, pointed at the public relays
for that recording only. Never the owner’s data. Replace the placeholder with the link, or delete that line before
submitting.
Screenshots: made by assets/brand/sukrara/appstore/ (the README there has the commands) from sukrara-snap
renders with synthetic data only (Marta, the made-up day). The pictures are in ~/Pictures/sukrara-appstore/{en,es}/,
outside the repo:
01-hero: menu bar + panel02-alerts: a low with its mute + Settings › Alerts03-follow: nearby pairing code04-widgets: live and aged05-report: Add Treatment + Glucose Report06-dark: the scrolled chart
None shows an Eat carbs / Take insulin pill or an update row. Making them showed the Spanish report’s period
picker in English (7 days): the catalog key was %@ days where the code looks up %lld days. It’s fixed in the
same change. LocalizationTests normalises every specifier to %@, so it can’t catch that kind of mismatch.
The owner’s clicks, in order (App Store Connect › Sukrara):
- 0.14.0 › App Review Information › Contact Information: first and last name, phone, e-mail. Save. (An agent doesn’t enter personal contact details.)
- The video: record it as described under Review notes, upload it (YouTube Unlisted), and put the link in
place of
[VIDEO LINK TO ADD]in Notes. Save. - The build: once 0.14.0 is on TestFlight, answer its export question (the first item of the list above). Then Build › Add Build › 0.14.0. Save.
- App Privacy › Get Started: No, we do not collect data from this app, then Save and Publish (the reasoning).
- Pricing and Availability › Set Up Availability: the countries. All of them, or leave France out to skip the ANSSI declaration. Save.
- Business › EU trader status (Digital Services Act). It’s needed before the version can go out in the EU.
- 0.14.0 › App Store Version Release: pick manual or automatic release. Then Add for Review → Submit.
The website’s Mac page (website/src/content/docs/mac.mdx › Get it) links the App Store once the app is live
(STORES.appStore in website/src/site.ts).
Android
Section titled “Android”Google Play: the account and app as set up (2026-11-10)
Section titled “Google Play: the account and app as set up (2026-11-10)”The research below assumed a new account; Google reinstated the old one instead, which changes two things: no “12 testers × 14 days” closed test (the account predates 2023-11-13; the app dashboard offers internal, closed and open testing at once, with no Apply for production step) and no new fee.
- Account: personal, developer account ID
5201366068122058756, ownermauriciabad1@gmail.com; identity, contact e-mail and phone verified; public developer e-mailsupport-googleplay@a.mauri.app; no account-level policy issues. The three 2024 apps (GradeCalc, Begur Secret, Emoji dealer) stay Removed by Google; their package names are unrelated. - App: Sukrara,
app.mauri.sukrara, Play app ID4974476015579711409, default language en-US, Free (can’t become paid once published), category Medical, store contactsupport-googleplay@a.mauri.app+ https://sukrara.mauri.app. Since 2026 Create app takes the package name, so it is reserved for this account. - Automatic protection off (Protected with Play → Automatic protection → Installer check off): Play would otherwise inject an installer check that tells anyone with a non-Play copy (Aurora Store, backups, transfers) to get the app from Play, and ship code that isn’t in the source. Sukrara is distributed on GitHub / F-Droid / others too.
- Play App Signing uses our release key (Protected with Play → App signing → Change key → Export and upload a
key from Java keystore, PEPK with
--rsa-aes-encryption). Play had generated its own key at app creation; it was replaced before any upload. App signing key and upload key are both27:EC:21:…:8D:96(tools/release/android-cert.sha256), so every channel shares one signature andandroid-release.sh’s output is uploadable as is. Play’s Digital Asset Links snippet matcheswebsite/public/.well-known/assetlinks.json. - API access: Google Cloud project
sukrara-playwith the Google Play Android Developer API enabled; service accountsukrara-play-upload@sukrara-play.iam.gserviceaccount.com, JSON key at~/.android/sukrara-play.json(0600, outside the repo; recreate withgcloud iam service-accounts keys create). In Play Console, for Sukrara only: View app information, Release apps to testing tracks, Manage testing tracks and edit tester lists and (since 2026-11-13, forrelease.py’s production step) Release to production, exclude devices, and use Play App Signing, which Play ties to Manage policy declarations and Manage deep links (locked on); no store listing. Checked: it opens an edit and lists the tracks. - App content done: Ads (none), Advertising ID (not used), Government apps (no), Financial features (none), Content rating (IARC, All Other App Types: users exchange text — treatment notes reach the wearer’s followers —, blockable, invited friends only, no location; result all ages / PEGI 3 / ESRB E / USK 0).
- Entered 2026-11-11 (the owner deciding on screen): Sign in details No, no part of the app is restricted
(Reviewer access); Target audience 13–15, 16–17, 18 and over; Privacy
policy https://sukrara.mauri.app/privacy; Health apps Diseases and conditions management (Play: no regional
requirements apply); Full-screen intent and Exact alarms (both Alarm clock); internal testing release 0.13.0
(versionCode 13000, tester list Testers: the Console account; opt-in link
https://play.google.com/apps/internaltest/4700763397995090600; the owner uploaded the
.aabby hand; signing certificate27:EC:21:…:8D:96). The store listing en-US + es-ES is filled in and saved (2026-11-12, AI asset declaration Don’t label assets). - Sent for review 2026-11-13, straight to production (the owner’s decision: 0.x releases are public
work-in-progress, the polished UI is 1.0; the listing says “still in development”). Data safety submitted by the
owner as No data collected (the own-account exemption). Foreground service (
connectedDevice): Continuous data transfer to an external device, video https://www.youtube.com/watch?v=aXdZv9Sv4qo (the 2026-11-11 emulator video, accepted by the owner after all; Unlisted on @mauriciabad, comments off). Production release 0.14.5 (14005, the bundle already on internal), full rollout, all 177 countries + rest of world; managed publishing off, so it goes live as soon as Google approves. First production notes (en-US + es-ES, entered in the Console only): “First version on Google Play. Sukrara is still in development: the core features are there, and new versions come often with improvements and new features. Found a problem or have an idea? Tell me at github.com/mauriciabad/sukrara/issues”. The Health Connect declaration never appeared. Steps as they were: what the owner does in Play Console. - Approved: live in production (0.14.5, seen by the owner 2026-11-16; Play dates it Nov 13): https://play.google.com/store/apps/details?id=app.mauri.sukrara, linked from
the README and the website’s Android page. No questions from Play about
USE_EXACT_ALARM, root or LSPosed. Left: nothing: item 6’s check below passed (2026-11-16). The fixed listing icon (#210) is live since 2026-11-16.
Google Play: reviewer access (App access)
Section titled “Google Play: reviewer access (App access)”Decided 2026-11-11 by the owner, replacing the 2026-11-10 Restricted plan of
#141: “No, no part of the app is restricted”. Sukrara has no
account or sign-in and every screen opens without a sensor (CGM); without one it just has no data yet (home shows
“Not monitoring: no sensor yet”; setup, every Settings page and each alert’s Send a test alert work). So no
instructions are entered in App access. The release build still has no demo data (the synthetic sensor is in
src/debug/ only) and won’t get a demo mode: someone could take a made-up 110 for their own glucose during a real low.
The demo video is still needed, for the foreground service declaration (both of its tasks ask for a video link;
declarations): at most 2 min, uploaded to
YouTube as Unlisted (it must play signed out). The owner records it on their own phone:
#185 has the shot list and how to stage each event. The emulator
video of 2026-11-11 (~/Movies/sukrara-play/sukrara-review-demo.mp4, a debug build with the synthetic sensor) was
rejected by the owner and isn’t used.
How the emulator was staged (still how the store screenshots are made again):
- A fresh install of the play flavor’s debug build on an AVD of its own (
play_media: android-37.0 google_apis, 1080 × 1920, 420 dpi), wearer role, every permission through the app’s own checklist, default thresholds; in setup tap Later at the sensor step (the synthetic source isn’t one of the wearer’s sensors), then close home’s Finish setup banner. Settings › Alerts › Low › Like an alarm on for the lock-screen alert, and the lock screen on (adb shell locksettings set-disabled false). - The local relay for the invite (
python3 tools/relay/relay.py --port 7447and… -a app.mauri.sukrara.debug.RELAYS --es urls ws://10.0.2.2:7447, docs/DEVELOPMENT.md; never the public relays from a debug build). - The synthetic source:
adb shell am broadcast -n app.mauri.sukrara/.debug.DebugReceiver -a app.mauri.sukrara.debug.SYNTHETIC --ez on true --ei cycle 110. The curve crosses the low threshold (70) at cycle minute 113, one reading a minute (cycle 135is the lowest point, 45 mg/dL).
Store screenshots (the same emulator session, made 2026-11-11, entered in the listing draft):
~/Pictures/sukrara-play/en/ and …/es/, eight each, 1080 × 1920 PNG without alpha (Play’s phone size for
promotion), System UI demo mode for the status bar: 01-home, 02-low-alert (the lock screen with the low alert and
the glucose notification), 03-widgets (the widgets and the Live Update chip), 04-treatment (15 g of carbs typed,
never saved), 05-invite, 06-alerts, 07-home-dark, 08-alert-reliability; a labelled copy of each (a “Test build
· simulated sensor data” band) in ~/Pictures/sukrara-play/labelled/. The data is the synthetic curve (about 47 % in
range). Spanish through the emulator’s language (cmd locale set-device-locale es-ES).
Who keeps it current: the owner re-records the video (#185’s shot list) when home, the alert screen or the foreground service’s notification change visibly, and the screenshots before a release whose listing changes. Health data in the screenshots is synthetic only; never the owner’s screenshots (CLAUDE.md).
Google Play: a brand-new personal account (research, 2026-10-18)
Section titled “Google Play: a brand-new personal account (research, 2026-10-18)”The old account is gone. Inactive accounts (created more than a year ago and never submitted an app, or all apps
under 1,000 lifetime installs plus no verified contacts / no Console use) are closed and the fee is not refunded
[G1]. Closure for inactivity is not a termination: Google’s 2021 announcement said closed developers “can still open
a new account” but cannot reactivate or migrate the old one [G2]. No official page says whether the same Google
account/e-mail can be reused; one third-party guide suggests a fresh e-mail may be needed [G3]. The one-account-
per-person rule is about simultaneous accounts. Plan: try registering with the user’s current Google account;
if Play Console refuses or only shows the closed account, use a new Google account (e.g. play@mauri.app as a
Workspace/Gmail login). An appeal to reinstate is possible but unlikely to help for an account with no live apps [G3].
Package names: Play package names “are unique and permanent … can’t be deleted or re-used” [G4]. Anything the old
account ever uploaded stays blocked forever (the user should check their old package names, but none can be
app.mauri.*: the domain and the Sukrara name are from 2026). app.mauri.sukrara and app.mauri.sukrara.poc are
unused on Play today (both 404, checked 2026-10-18). Never upload .poc to Play (even a closed test would burn
the name); the first upload should be app.mauri.sukrara.
New-account requirements
| Personal (recommended) | Organization | |
|---|---|---|
| Fee | 25 USD once [V2] | 25 USD once |
| Identity | legal name + address from the Google Payments profile, verified before publishing; contact e-mail + phone verified by OTP; Play shows name, country and developer e-mail (full address only if monetized) [G5] | D-U-N-S number required, organization name/address/phone shown publicly [G5] |
| Testing before production | closed test with ≥ 12 testers opted in continuously for 14 days, then apply for production access (questions about the app and the test) [G6]; open testing unlocks only after that [G7] | Not required (third-party summaries [G7]; the official page only speaks about personal accounts created after 2023-11-13 [G6]) |
| Fits the user? | Yes | Only with a registered legal entity; not worth creating one for this |
The 12 × 14 rule applies (account created after 2023-11-13 [G6]); the old account’s age doesn’t carry over. Count about 3 weeks from the first closed-test release to production [G7]. Testers: the user, family/followers who already use Sukrara, the Garmin/diabetes friends — 12 Google accounts that stay opted in (use a Google Group as the tester list so nobody drops out by accident).
Policies that matter for this app
| Topic | Rule | What Sukrara must do |
|---|---|---|
| Target API | New apps/updates must target API 36+ since 2026-08-31 [G8] | Already targetSdk 37 |
| Health apps declaration | Every health/medical app fills the form; categories include Diseases and Conditions Management and Medical Device Apps, the latter including “any software interfacing with medical device hardware”; EEA apps regulated under MDR/IVDR must show device name, manufacturer, IFU, UDI-DI [G9] | Declare Diseases and Conditions Management. Whether it must also be Medical Device Apps is the key risk (below) |
| Health content | Non-regulated health apps must state in the description that the app is “not a medical device and does not diagnose, treat, cure, or prevent any medical condition”; external hardware must be disclosed; a privacy policy linked in Console and in the app, public, not a PDF [G10] | Disclaimer + “requires a FreeStyle Libre 3 sensor” in the listing; privacy page on the site; link in Settings → About |
USE_EXACT_ALARM |
Only for apps whose core function is an alarm/timer or calendar; everyone else should use SCHEDULE_EXACT_ALARM [G11] |
Glucose alarms are arguably alarm-clock-like and Juggluco ships alarms on Play, but expect a declaration and possible rejection. Safer: switch the Play build to SCHEDULE_EXACT_ALARM + canScheduleExactAlarms() prompt (the alert timing doesn’t need more). Decided 2026-11-11: keep USE_EXACT_ALARM and declare it (Flavors); approved by Play with 0.14.5 (2026-11-16) |
| Foreground service | Each FGS type declared in App content with description, user impact and a demo video [G12] | connectedDevice (BLE to sensor/followers): record the video (start, notification, stop) |
| Device and Network Abuse | No interfering with other apps / the system; no self-updating outside Play, no downloading executable code [G13] | Play flavor without the LSPosed/SystemUI hook, lock-screen widget hook, root status bar, DUMP; and without the in-app GitHub update check (SettingsScreens.kt calls api.github.com/…/releases/latest). Decided 2026-11-11: the root features stay in the Play build (opt-in, the person’s own root), only the update check goes (Flavors); approved by Play with 0.14.5 (2026-11-16) |
| Data safety | Required, with a privacy policy, even if nothing is collected; E2E-encrypted data unreadable by the developer is not “collected”; a user-initiated transfer to a third party is not “sharing” [G14] | Nostr readings: E2E encrypted → not collected (relays see public keys, timestamps, IP). LibreView: user-initiated upload of glucose + treatments + account credentials to Abbott → disclose as health data sent at the user’s request. BLE/NFC: on-device. No analytics, no ads |
| Signing | New apps are enrolled in Play App Signing; the developer may “Provide a copy of your app signing key” instead of a Google-generated one, before the first open/production release [G15] | Upload our own release key so GitHub/IzzyOnDroid/F-Droid (reproducible) builds share one signature with Play |
Is it a medical device? This is the real risk, not a form field.
- EU (the user is in the EEA): software that “drives or influences the use of a device” falls in the same class as that device (MDR Annex VIII rule 3.3, MDCG 2019-11) [R1]. Reading a Libre 3 directly, showing values and alarming is close to being the CGM’s primary display.
- US: FDA’s CGM secondary display (21 CFR 862.1350, product code PJT) is class II, 510(k)-exempt, for software that shows CGM data to a follower; special controls include data-tampering protection and a “no dosing decisions” warning [R2][R3]. Software that reads the sensor itself is not covered by that exemption (our inference, not a ruling).
- Precedent: Juggluco (
tk.glucodata, reads Libre 2/3, Dexcom, alarms, uploads to LibreView) is on Play today, 100K+ installs, updated 2026-09-20 [P1]; a forum post says it was pulled once after an Abbott complaint and later returned (second-hand) [P2]. xDrip+ is distributed outside Play (GitHub) [P3]. - Consequence: publish as “not a medical device”, no dosing language in the listing, keep the badge texts (Eat carbs, Take insulin) out of screenshots or soften them in the Play build, and accept that Play (or Abbott) can remove the app; the sideload channel is the fallback. A lawyer’s opinion is the only real answer for the final app; not needed for an alpha.
Android developer verification (sideloading)
Section titled “Android developer verification (sideloading)”| Date | What |
|---|---|
| 2026-03-30 | Verification open to all developers in Play Console and the new Android Developer Console (for apps distributed only outside Play) [V1][V3] |
| 2026-08 | Limited distribution accounts (free, no ID, up to 20 devices, for students/hobbyists), the developer APIs, and the advanced flow launch [V1][V2] |
| 2026-09-30 | Enforced on certified devices (Android 7+) in Brazil, Indonesia, Singapore, Thailand, initially only for installs from the participating stores [V1][V2][V4] |
| 2027 | Global rollout for all apps on certified devices [V1] |
How it affects GitHub-APK distribution once it reaches Spain (2027): the APK installs normally only if its package is registered by a verified developer with the APK’s signing-key fingerprint [V2][V5]. ADB installs are exempt [V2]. Otherwise users need the advanced flow: developer options, a one-day wait, then biometric/PIN, “Install Anyway”, enabled for 7 days or indefinitely; with it disabled, updates to unregistered apps fail [V2]. If a package name is already registered by someone else, the claim needs extra review [V2]. Losing the signing key means the package can’t be registered [V2]. Registration is done in Play Console too (“the single place … including for apps distributed outside of Play”), so a Play account covers it; F-Droid-signed builds are handled by adding the platform’s key fingerprint next to ours [V5].
For Sukrara: the full (root) flavor and the Play flavor should be one package, one key, registered in the Play Console account; the limited-distribution tier (20 devices) is too small for public sideloading and isn’t needed once the Play account exists. F-Droid calls the programme an existential threat and won’t register apps on its developers’ behalf [V4][F3]; that’s F-Droid’s problem, not ours, as long as we register our own key.
Checked 2026-11-13 (Play Console › Manage account › Android developer verification): app.mauri.sukrara is
Registered (since 2026-11-10) with four verified signing keys, our release key 27:EC:21:…:8D:96 among them,
so GitHub / Obtainium / IzzyOnDroid APKs signed with it pass verification wherever it’s enforced. The other three
(3E:C6:16:…:90:7D, 4B:C4:64:…:1C:0C, 0D:E9:98:…:77:E1) aren’t the debug key on the release Mac and aren’t shown
on the app’s App signing page; they were registered on the day the app was created, most likely Play’s own keys from
before our key replaced its generated one. They’re left as they are (removing a key Play uses could break Play
installs); an F-Droid-signed build would need F-Droid’s key added here too. Identity: the account’s legal name and
address; trader status Non-trader (as on the App Store).
Seen 2026-11-12: installing the GitHub APK on the owner’s phone showed Google Play Protect’s App scan recommended dialog (“Play Protect hasn’t seen this app before”), with Scan app, Don’t install app and Install without scanning. At that point Play App Signing used our key and release 0.13.0 was on internal testing.
Moving off the debug key
Section titled “Moving off the debug key”The debug keystore can’t be used anywhere public (IzzyOnDroid and Accrescent refuse debug-signed APKs [F4][F6]) and Play requires an upload key. The plan:
- Generate a release keystore (RSA 4096 or EC P-256) on the user’s Mac; back it up (password manager + an offline copy). It is the identity of the app forever (developer verification + every channel).
- Use it for the new package
app.mauri.sukrara. A new package installs side by side withapp.mauri.sukrara.poc, so there is no signature clash: nothing is overwritten, but nothing carries over either. - Migration for existing alpha users: in the last
.pocrelease, show “Sukrara moved: install the new app, then uninstall this one”. What must carry over: the Nostr device/read keys (already restorable from the password manager, investigation 06), settings (add a settings export/import), the LibreView login (re-enter), the sensor (re-pair over NFC, works since 0.10.5; force-stop the old app first, like Juggluco). History comes back from the followers’ backfill and LibreView. - (Alternative if the package were kept: APK Signature Scheme v3 key rotation can move an install from the debug key to a new key in place. Not worth it given the rename.)
The Android release key
Section titled “The Android release key”Steps 1–2 above are done; step 3’s migration is dropped (the app starts clean).
- Where:
~/.android/sukrara-release.jks(PKCS12, RSA 4096, valid 30 years, aliassukrara), outside the repo, made once bytools/release/make-keystore.sh(it refuses to overwrite an existing key). Its random password is in the macOS Keychain itemsukrara-android-release(accountsukrara). Public fingerprint:tools/release/android-cert.sha256(also inwebsite/public/.well-known/assetlinks.jsonforapp.mauri.sukrara, with the debug key’s for debug builds). - How a release build finds it: the keystore from
SUKRARA_KEYSTORE(default the path above), the password from the environment variableSUKRARA_KEYSTORE_PASSWORDonly (Gradle never reads the Keychain);tools/install.shand the release scripts fill it from the Keychain item (security find-generic-password -s sukrara-android-release -w).tools/release/verify-apk.shrefuses an APK signed by anything else. - Backup: the owner keeps a backup of the
.jksfile and its password in their password manager (Proton Pass); after any change to the key, copy both there again (the password:security find-generic-password -s sukrara-android-release -w), plus one offline copy. Losing either = no more updates for every installed copy: Android only installs an update signed by the same key, so users would have to uninstall (losing their data) and install a new app. - Restore on a new Mac: put the file back at
~/.android/sukrara-release.jks(chmod 600) and recreate the Keychain item:security add-generic-password -s sukrara-android-release -a sukrara -w(it prompts for the password, so it stays out of the shell history).
Before every Android release: the release smoke
Section titled “Before every Android release: the release smoke”Run tools/release/android-smoke.sh --final on the commit you’re about to release (emulator only; it never
touches a phone). It builds the APK with the release key (no key or no pinned Juggluco → the build stops; it never
falls back to the debug key), runs verify-apk.sh (signer = android-cert.sha256, package / version from VERSION,
not debuggable, Libre 3 core inside, R8 full mode with the mapping that belongs to this APK, no debug classes or
debug-tool strings, no exported component without a permission beyond the launcher and the alert sound provider,
POST_PROMOTED_NOTIFICATIONS declared), then installs it fresh and launches it (see docs/QA.md Q10
for every assertion). Keep the mapping (apps/android/app/build/outputs/mapping/fullRelease/mapping.txt) with the
release: crash stack traces from the owner’s phone are unreadable without it. Keep-rule fixes go to the owning
module’s consumer-rules.pro (the module that uses the reflective / JNI library), never to a blanket -keep.
Cutting a release
Section titled “Cutting a release”One command does it (#187): tools/release/release.py <version> on the release Mac, from a clean checkout at
origin/next, a worktree included (docs/DEVELOPMENT.md › Release has the steps;
One-command release below has the store parts). What it runs, and what a release by hand would be: with tools/check/strict committed,
tools/release/android-release.sh (signed APK →
apps/android/app/build/dist/Sukrara-<version>.apk, verified, and its R8 mapping gzipped next to it as
Sukrara-<version>-android-mapping.txt.gz, about 4 MB, with a copy in ~/.android/sukrara-mappings/) and
tools/release/mac-release.sh (bundle → verify-app.sh → dmg + zip in apps/macos/build/). Then tag v<version>
on main and gh release create v<version> --verify-tag --latest with the four files (Sukrara-<version>.apk, Sukrara-<version>-android-mapping.txt.gz, Sukrara-<version>.dmg,
Sukrara-mac-<version>.zip). The mapping is a release asset (#96) so it lives as long as the APK it decodes and anyone
reading a crash trace in an issue can use it (retrace from the Android SDK’s cmdline-tools: gunzip it, then retrace mapping.txt trace.txt); it isn’t secret (the source is public under the GPL). About lists no download (Sukrara on
other devices opens the website, #179). The Android GitHub version’s updater (#188) takes only the asset named exactly
Sukrara-<version>.apk of a release, and only with the SHA-256 GitHub lists for it (the asset’s digest, which GitHub
computes on upload): keep that name. Releases are immutable since 2026-11-15 (Settings › General › Releases, the
owner’s OK): once published, a release’s assets and tag can’t change, and GitHub keeps a signed record of them, which
gh release verify-asset v<version> <file> -R mauriciabad/sukrara checks a download against (the website’s Check
it’s the real Sukrara shows the command; gh release create with the files uploads them to a draft first, so the
one-command release is unaffected). A wrong asset needs a new version. Play builds need no
separate mapping: they are app bundles with the mapping inside (BUNDLE-METADATA), which Play reads to deobfuscate
crash reports (the API’s deobfuscationfiles upload is only for APKs). Every release is a normal one and becomes Latest (since
2026-11-12; v0.12.0 … v0.14.5 were switched from prereleases then); it bumps the Homebrew cask (homebrew-tap.yml on
published), a GitHub prerelease (a release candidate) never does (also when dispatched by hand). Mac notarization switches on by itself once the Developer ID identity and the notarytool profile exist on
the release Mac (Mac release: Developer ID and notarization); they do
since 0.12.0, and a Developer ID build is never released unnotarized.
One-command release (#187)
Section titled “One-command release (#187)”Built 2026-11-11. tools/release/release.py runs the gate and publishes GitHub, Sparkle, Homebrew, Google Play
(internal testing and production) and TestFlight; the keys stay on the release Mac, none is a GitHub secret. The store calls are in
tools/release/stores.py (Python stdlib; the JWTs are signed by openssl, the Play key going to it on stdin, the
.p8 staying in its file; nothing prints a key):
- Google Play: Android Publisher v3 with the service account
~/.android/sukrara-play.json(testing tracks only): edits.insert → bundles.upload (Play’s versionCode and sha256 must be the local bundle’s) → tracks.updateinternal(one release,status: completed, the version’s name, notes en-US + es-ES fromapps/android/fastlane/metadata/android/<lang>/changelogs/<versionCode>.txt) → edits.commit. A versionCode already on the track is left alone (re-running is safe); if Play refuses to send other pending Console changes for review, the commit is retried withchangesNotSentForReview=trueand the summary says the Console has changes waiting. Checked read-only on 2026-11-11 (stores.py play-tracks): the edit opens,internalhas 0.13.0 (13000, completed), production / beta / alpha are empty, the only bundle is 13000; the edit was deleted, nothing committed. The app isn’t a draft app any more (a draft app would only takestatus: draft). - TestFlight: the gate’s pkg (its version and build number checked) through
mac-appstore.sh --upload, then the App Store Connect API (keyVCB5XBQ3QZ, Developer) until the build isVALID. Checked read-only (stores.py asc-builds): app 6833533014, build 0.13.0 (13000.261111.1531)VALID,usesNonExemptEncryptionunset (Missing Compliance). - Export compliance is answered by the build (since 0.14.6):
bundle.sh --app-storewritesITSAppUsesNonExemptEncryptionNO into the App Store version’s Info.plist, so no build asks in TestFlight. That is the owner’s answer (standard algorithms, not distributed in France) as App Store Connect stores it: build 14003, answered by hand on 2026-11-12, readsusesNonExemptEncryption: false. Once ANSSI’s certificate is approved (France (ANSSI) above), it becomes YES plus Apple’sITSEncryptionExportComplianceCode. The API can’t answer a build after upload with the Developer key (PATCH /v1/builds/{id}returns 403), so a build uploaded before 0.14.6 is answered by hand. - Play production, every release (since 2026-11-13): the same versionCode also on
production(status: completed, full rollout; managed publishing off, so it goes live once Google approves it); the service account has Release to production. Each track that already has the versionCode is skipped, so re-running is safe. The owner decided 0.x goes to production (public work in progress); the 1.0.0-only--productionflag is gone. - App Store, every release (since 2026-11-13): the
appstorestep aftertestflight. It lists the app’s App Store versions and then: a version already submitted, in review or live is left alone (re-running is safe); while another version is in review or waiting to release it does nothing (Apple reviews one version at a time; the build stays on TestFlight and the summary says so, a later release submits the newest); otherwise the editable version (never submitted, rejected, removed from review) is reused or a new one created, asversionString= the release withreleaseType: AFTER_APPROVAL, the VALID build attached, What’s New set on every localization fromapps/macos/AppStore/whats-new/<en-US|es-ES>/<versionCode>.txt(only once a version is live: the first has none), and a review submission (an existing draft one reused) submitted. App Store Connect copies the listing and screenshots to each new version (to be confirmed on the first automatic submission). Needs the key with App Manager access (Sukrara release,~/.apple-dev/release-AuthKey_DVJY683AS9.p8, the file the scripts pick); the Developer keyVCB5XBQ3QZ(Sukrara notary) stays for notarization, as~/.apple-dev/notary-AuthKey_VCB5XBQ3QZ.p8(notarytool reads it from the keychain profile). Replaces the never-run--app-reviewflag.
In Sukrara. Added: the above. Discarded, with the reason: fastlane / gcloud / google-auth (none is on the
release Mac; three REST calls and a JWT don’t need them, and fewer tools means fewer keys in more places);
GitHub Actions for the uploads (the keys would have to become secrets); running ./gradlew check and swift test
again in the gate (the green Checks run on the same commit ran them); waiting for the version commit’s Checks run
before the gate (they run side by side; it’s awaited before anything is published); a second verify-apk.sh /
verify-app.sh --notarized (android-release.sh and mac-release.sh run them); Spanish Play notes made from the
CHANGELOG (it’s English and covers the Mac too).
Alternatives to Play
Section titled “Alternatives to Play”| Channel | Fit | Requirements / notes |
|---|---|---|
| GitHub Releases + Obtainium | Now | Obtainium tracks GitHub releases and (since 1.7.0, 2026-10-17) verifies the APK signing certificate before installing [F1]. Needs only versioned, release-signed APKs. Add an “Add to Obtainium” link on the site |
| IzzyOnDroid | No (checked 2026-11-13) | Its policy: “Vibe-coded apps will be rejected” and the code “should be free of” LLM output [F4]; most of Sukrara’s commits are co-authored by Claude, so a request would very likely be rejected. Otherwise it would fit: FOSS licence, aimed at end users, APK < 30 MB attached to a tagged release (Sukrara: 19 MB), tag = versionName/versionCode, Fastlane metadata (descriptions, icon, screenshots), release-signed, not debuggable [F4]. Reproducible builds optional but verified when possible [F4]. Must not download executables without consent |
| F-Droid main repo | Later | FLOSS only, built by F-Droid from source with a free toolchain; no Play Services/trackers [F2] (Sukrara has none: no gms/Firebase in the build). Hard parts: the Juggluco security core comes from a separate checkout (make it a pinned submodule), rust-nostr (nostr-sdk) and zxing-cpp native libs must build from source. Likely anti-feature NonFreeNet (LibreView upload) [F3]; root features have no anti-feature. Use reproducible builds so F-Droid ships our signature (no key split). Age (checked 2026-11-13): “actively developed for at least 3 months, unless … proven to have some users” [F2]: first commit 2026-10-15, so from 2027-01-15. F-Droid forbids auto-updates unless opt-in: the owner’s decision (2026-11-13) is no fdroid flavor; the GitHub build’s updater becomes opt-in instead (done: setup’s Keep Sukrara up to date step and a banner suggest it; docs/FEATURES.md › Updates (Android, GitHub version)), so one APK, signed with our key (reproducible builds), serves GitHub, Obtainium and F-Droid, and every APK updates every other install. No AI-code rule today. Plan and checklist: #191 |
| Own F-Droid repo | Optional | fdroidserver repo on GitHub Pages (sukrara.mauri.app/fdroid/repo); easy but adds little over Obtainium + IzzyOnDroid |
| Accrescent | No | Sign-up allowlisted only; the project says new submissions are unlikely to be accepted for now (funding) [F5][F6] |
Flavors
Section titled “Flavors”Built 2026-11-10 (#142): the app module has two product flavors in the store dimension, with the same package
app.mauri.sukrara, version and release key (AndroidApplicationConventionPlugin). What the play flavor contains is
the owner’s decision of 2026-11-11 (#142,
below). The website and About call them the GitHub version and the Google Play version.
| Flavor | Channel | Build | Contents |
|---|---|---|---|
full (default) |
GitHub releases, Obtainium (later IzzyOnDroid, F-Droid) | tools/release/android-release.sh (:app:assembleFullRelease, APK) |
everything, and the updater (#188: daily check, notification, checked install) |
play |
Google Play | tools/release/play-bundle.sh (:app:bundlePlayRelease, app bundle) |
everything except the updater |
The owner’s decision (2026-11-11) and why
- Exact alarms: the Play build keeps
USE_EXACT_ALARM(noSCHEDULE_EXACT_ALARMswap). The missed-reading (no data) alarm, the alert repeats and the escalation of an unanswered very low to the followers are user-facing alarms scheduled withsetExactAndAllowWhileIdle(AlarmPolicy); they must ring on time while the phone dozes and the app is in the background.SCHEDULE_EXACT_ALARMisn’t enough: on Android 14+ it is denied by default for new installs and the person (or a cleaner app) can revoke it, and then the checks fall back to inexact while-idle alarms that run minutes late without the person noticing. Play allowsUSE_EXACT_ALARMonly where precisely timed alarms are the app’s core, user-facing function, documented and promoted in the description [G11]: glucose alarms are Sukrara’s core function, the listing leads with them, and Play’s exact-alarm declaration says so (the draft). Precedent: Juggluco, on Play, declaresUSE_EXACT_ALARM. Settled: approved by Play with 0.14.5 (2026-11-16), no questions asked. - The root features ship in the Play build too: the glucose in the status bar (root slot daemon, the LSPosed
module in System UI:
MonitorModule’sSystemUiRoot, the module’s manifest entries,META-INF/xposed) and the lock-screen widget (#66, the same module). They work only after the person roots their phone, installs LSPosed and enables Sukrara’s module for System UI: the status-bar value is off by default and also needs root granted to Sukrara; the lock-screen widget’s setting is on by default (as in the PoC) but shows nothing, and sends nothing to System UI, until that module runs. They change only Sukrara’s own icons, text and widget in System UI. The listing names the user-facing feature briefly and honestly (glucose in the status bar on supported phones, with advanced setup), not the means; every Play declaration and reviewer question is answered truthfully (root and LSPosed are named whenever Play asks how a feature works). Device and Network Abuse (“interfere with … the user’s device … including … other apps” [G13]) doesn’t apply: it runs only with the person’s explicit setup and consent and touches nothing but Sukrara’s own status-bar items and its lock-screen widget. Settled: approved by Play with 0.14.5 (2026-11-16), no questions asked; they’re part of every build from now on, new root features included, described the same way. - No updater in the Play build: an app from Play may not update itself, or send people to updates, other than
through Play [G13]. The updater is its own
module,
:update, a dependency of thefullflavor only (#188): the Play build has no update check, notification, download, worker, receiver orREQUEST_INSTALL_PACKAGES(allow.jsonplay_permissionsremoves it), andStore.updates()returns null, so About has no update rows (ManifestTest;verify-apk.sh --play: noapp.mauri.sukrara.updateclass in the mapping, no updater in the manifest, noapi.github.comin the dex). - About says which version it is (0.12.0 · Google Play version / GitHub version) and links to the website’s
Versions (
website/src/content/docs/android.mdx: same app and key; who updates each; where to get each; anything a store version leaves out, today only the updater). No disabled rows and no “install elsewhere to unlock” prompts in the Play build (Device and Network Abuse: no means to reach a non-compliant APK). - The flavors differ only in the updater (
Store): root and exact alarms are the same in both.
Not in either release build, so there is nothing to leave out: DUMP (only the debug build’s DebugReceiver declares
it), QUERY_ALL_PACKAGES (the queries are listed one by one in allow.json). REQUEST_INSTALL_PACKAGES is in the
GitHub build only (the updater installs its checked update with PackageInstaller).
The bundle has no language splits (bundle.language.enableSplit = false): Sukrara has its own language setting, and a
split that Play didn’t install would leave that choice without strings. arm64 only, like the APK.
Checks. ManifestTest also reads the play flavor’s merged manifest: its permissions are allow.json’s with
play_permissions applied (empty now), USE_EXACT_ALARM and no SCHEDULE_EXACT_ALARM, the System UI module’s
provider, hello receiver and permission, and the same components as the GitHub build but the updater’s receiver. tools/release/play-bundle.sh
builds the bundle signed with the release key (password from the Keychain, --no-daemon) and checks it: signer =
android-cert.sha256, base module only, arm64 only, the Libre 3 core, the R8 mapping in BUNDLE-METADATA (Play
deobfuscates crash reports with it), META-INF/xposed inside. Then bundletool validate and verify-apk.sh --play on
bundletool’s universal APK when bundletool is there ($BUNDLETOOL = the bundletool-all jar from its GitHub releases,
or bundletool on PATH); without it, verify-apk.sh --play on the play APK that Gradle builds from the same R8
output. verify-apk.sh checks the System UI module in both builds (META-INF/xposed, its manifest entries, every
LSPosed hook class keeps intercept) and, with --play, no updater (no app.mauri.sukrara.update class in the
mapping, no updater receiver or REQUEST_INSTALL_PACKAGES in the manifest, no api.github.com in the dex); without
it, that the GitHub build has the updater’s receiver. It copies Sukrara-<version>-play.aab to apps/android/app/build/dist/ and archives
the mapping in ~/.android/sukrara-mappings/<version>-play-mapping.txt. CI’s android-play job runs it with
--unsigned (no key, no Juggluco checkout: every check except the signer and the Libre 3 core).
Uploading isn’t scripted yet: the first upload to internal testing is the owner’s (the order in Play
Console). A script for later releases can use the service
account (~/.android/sukrara-play.json, testing tracks only) with the Android Publisher API (edits.insert →
edits.bundles.upload → edits.tracks.update → edits.commit).
Same package and key means a user can switch versions without reinstalling and keeps their data; whichever store has
the newer version code offers it. Decision: same package (not app.mauri.sukrara.full: two registrations and a
confusing choice).
Google Play: Data safety, Health apps and permission declarations (drafts)
Section titled “Google Play: Data safety, Health apps and permission declarations (drafts)”Derived from the code on 2026-11-10 for the play build (the facts are the privacy page’s, website/src/content/docs/privacy.md); only the
owner submits them, in Play Console › App content. Play’s rules used here [G14]: data the app sends off the
device is collected (Sukrara has no server, so everything below goes to services the person signs in to); data that
is end-to-end encrypted, so no one in between can read it, doesn’t need to be disclosed; a transfer the person starts
to a service they chose isn’t sharing; data that never leaves the device isn’t collected.
State (2026-11-11): Data safety is a draft, not submitted, and open. Saved on page 2: collects or shares data Yes; encrypted in transit Yes; My app does not allow users to create an account; Can users login to your app with accounts created outside of the app? No (the owner’s answer); deletion request Yes, URL https://sukrara.mauri.app/privacy. The owner disputes the premise below and will revisit it in depth; judgement call (1) was not applied. The recommendation (2026-11-11) is No, with the table below as the fallback: Privacy answers for both stores. The two readings:
- Nothing is collected (the owner): Sukrara has no server and the developer receives nothing; the follower name is an alias; the LibreView e-mail is only a sign-in. The uploads go to services the person signs in to and turns on.
- The opt-in uploads are collected (the draft below): Play counts data sent off the device as collected even when it goes to a third-party service the person chose, so Health info, e-mail, name and IDs are listed as optional.
Data safety must be submitted before any review (Send changes for review).
Data safety › Data collection and security
| Question | Answer | Why |
|---|---|---|
| Does your app collect or share any of the required user data types? | Yes | The opt-in uploads (LibreView, Tidepool, Nightscout) send health data off the phone |
| Is all of the user data collected by your app encrypted in transit? | Yes | Every connection is https / wss, platform CAs only (network_security_config.xml: cleartext only to 127.0.0.1); Nightscout takes only https:// sites. The opt-in Nightscout API › Also on this Wi-Fi serves plain http to the person’s own devices on their network: the phone serving its owner, not collection (say so if Play asks) |
| Do you provide a way for users to request that their data is deleted? | Yes | Everything is on the phone (uninstall or Clear storage; deleting a treatment also deletes it upstream); uploaded data is deleted in the person’s own LibreView / Tidepool / Nightscout account; the developer holds nothing. The privacy policy explains it |
| Account creation | My app does not allow users to create an account | No account with the developer; the sharing identity is a key pair made on the phone; LibreView and Tidepool are sign-ins to existing accounts. So no account-deletion URL |
Data types (everything not listed: not collected, not shared)
| Category › type | Collected | Shared | Optional | Ephemeral | Purposes | What and where |
|---|---|---|---|---|---|---|
| Health and fitness › Health info | Yes | No | Yes | No | App functionality | Glucose readings, insulin, carbs, treatment notes, sensor starts / changes: LibreView, Tidepool, Nightscout, each only after the person turns it on and signs in |
| Personal info › Email address | Yes | No | Yes | No | App functionality, Account management | LibreView and Tidepool sign-in (also LibreView’s sign-in for a new Libre 3 sensor) |
| Personal info › Name | Yes | No | Yes | No | App functionality | The LibreView upload resends the account’s own first and last name (which came from LibreView) |
| Personal info › Other info | Yes | No | Yes | No | App functionality | The LibreView upload resends the account’s date of birth (which came from LibreView) |
| Personal info › User IDs | Yes | No | Yes | No | App functionality, Account management | The LibreView account and receiver ID, the Tidepool user ID, in those services’ requests |
| Device or other IDs | Yes | No | Yes | No | App functionality | A random ID per install (LibreView device ID, Tidepool / Nightscout device name) and the sensor’s serial number (LibreView, Nightscout) |
| App info and performance › Diagnostics | Yes | No | Yes | No | App functionality | The phone’s battery level and charging state in Nightscout’s device status (Nightscout upload only) |
Not collected, and why: sharing with followers (NIP-44 end-to-end encrypted to the followers’ keys, relays can’t read it; the profile name and picture travel the same way); Bluetooth sharing (the same encrypted events; Pair nearby shows the wearer’s name and an invite code to nearby phones for up to 10 minutes, phone to phone, never to the developer or a service); Health Connect (written on the device); the calendar event (written to a calendar on the device; an account calendar the person picks is synced by that account, not by Sukrara); broadcasts and the local xDrip+ / Nightscout servers (to apps and devices the person picks); the camera (QR codes decoded on the device); the export file and the password-manager backup (the person’s own transfers). No location, contacts, messages, photos, audio, files, app activity, web history, financial info, advertising ID, analytics or crash logs.
Judgement calls for the owner: (1) To not rely on the user-initiated exemption, mark Health info, Email address, Name, Other info, User IDs and Device or other IDs as Shared too (purpose App functionality): the listing only gets more cautious. (2) A follower’s opt-in Upload the person you follow sends the wearer’s readings to the Tidepool account the follower signs in to; it is the follower’s own transfer of what they received, covered by the Health info row.
Security practices: data encrypted in transit: yes. Independent security review: no. Play Families Policy: no (not a children’s app).
Health apps declaration (App content › Health apps; saved 2026-11-11, Play: no regional requirements apply): Diseases and conditions management (diabetes: glucose display, alerts, insulin and carbs log). Not Medical device apps: Sukrara isn’t cleared or certified as a medical device and the listing says so. The description carries the statement Play asks for (“Sukrara is not a medical device and does not diagnose, treat, cure, or prevent any medical condition”), the reminder to ask a healthcare professional, the hardware it needs (a FreeStyle Libre 3 / 3 Plus, NFC and Bluetooth, or an invite to follow someone) and the Abbott disclaimer (“FreeStyle Libre and LibreView are trademarks of Abbott. Sukrara is not affiliated with or endorsed by Abbott.”) [G10]: see the store listing. Privacy policy URL: https://sukrara.mauri.app/privacy (in the app: Settings › About › Privacy policy).
Health Connect (App content, after the upload): WRITE_BLOOD_GLUCOSE only. Purpose: “Writes the glucose
readings of the person’s own sensor to Health Connect, once a minute, so other health apps they choose can use them.
Off until the person turns it on in Share with apps. Sukrara reads nothing from Health Connect.” The rationale screen
is the app’s HealthPermissionsRationale alias of MainActivity.
Permission declarations that appear after the first upload (each in English). State on 2026-11-11: full-screen intent and exact alarms saved; the foreground service not saved (needs the video, #185); Health Connect hasn’t appeared (neither Need attention nor Actioned): watch for it.
| Declaration | Answer |
|---|---|
Foreground service, type connectedDevice |
Not saved. The form offers Continuous data transfer to an external device (video only) or Other (video + description); the drafted task Connected device (Bluetooth) doesn’t exist. Both need the video link (#185). For Other, the description: “Sukrara monitors the person’s glucose sensor (CGM), or the phone of the person they follow. The foreground service keeps the Bluetooth connection to the sensor (or the connection to the wearer’s phone) so each reading and every low or high glucose alarm arrives within a minute while the app is closed. It starts when a sensor is paired or someone is followed, shows the current glucose in its notification the whole time, and stops when the sensor is forgotten or following stops.” User impact if deferred or stopped: “Readings stop and low glucose alarms, including the very low alarm, don’t ring: the person can miss a dangerous low.” |
Full-screen intent (USE_FULL_SCREEN_INTENT) |
Saved 2026-11-11: core functionality Alarm clock, pre-grant at install Yes; the form has no text or video field. If Play asks: “Sukrara is a glucose alarm app. The very low glucose alarm, and any alert the person sets to ring like an alarm, is posted with a full-screen intent so that, like an alarm clock, it wakes the screen and shows on the lock screen at once with its alarm sound, because a very low glucose needs immediate action. The person answers it from the lock screen (mute, remind less) or opens the app.” (Today the full-screen intent opens the app’s main screen, which doesn’t show over the lock screen: the phone wakes and the alert shows on the lock screen, but there is no full-screen alarm page; the text says only what happens.) |
Exact alarms (USE_EXACT_ALARM) |
Saved 2026-11-11: core functionality Alarm clock; no text field. The exact-alarm text below is what to answer if Play asks |
Exact alarm declaration
Section titled “Exact alarm declaration”Where: Play Console › App content › the exact alarm permission declaration (it appears once a bundle with
USE_EXACT_ALARM is uploaded). Saved 2026-11-11 as core functionality Alarm clock; the form has no text field,
so this text (English) wasn’t entered and is only what to answer if Play asks:
Sukrara is a glucose alarm app for people with diabetes who wear a continuous glucose monitor. Its core, user-facing function is alarms: it rings when glucose goes too low or too high, changes fast, or stops arriving from the sensor (the missed-reading alarm), repeats the alarm while glucose stays out of range, and alerts the people the user chose when a very low alarm goes unanswered. These alarms are scheduled with setExactAndAllowWhileIdle because they must ring on time while the phone is idle and the app is in the background: a late low glucose alarm can be dangerous. SCHEDULE_EXACT_ALARM is not enough: on Android 14 and later it is denied by default for new installs and can be revoked by the user or another app, and the alarms would then fire late without the user noticing. The alarms are the first thing the store listing describes, and every alert can be tried in Settings › Alerts › an alert › Send a test alert.
Precedent if Play asks: Juggluco, a CGM app on Play, declares USE_EXACT_ALARM for the same alarms. Play approved it
with 0.14.5 without asking.
If Play ever asks about root, LSPosed or the status bar (it didn’t for 0.14.5; a reviewer question, or App access / Device and Network Abuse): answer truthfully, in English:
Glucose in the status bar is an optional, advanced feature, off by default. It works only on a phone the user has rooted themselves, with the LSPosed framework installed and Sukrara’s module enabled for System UI by the user, and after the user grants Sukrara root when they turn the feature on. It shows the user’s own glucose value as status-bar icons or text; it doesn’t change, read or interfere with any other app, and it sends nothing anywhere. Without root the rest of the app works the same, and Settings › Status bar explains what the feature needs.
Not a form, but a policy to keep in mind: REQUEST_IGNORE_BATTERY_OPTIMIZATIONS (the alert checklist’s No battery
restrictions, which opens Android’s own dialog). Play allows it where the core function breaks under Doze; an alerting
glucose monitor is that case.
Google Play: store listing (drafts, en + es)
Section titled “Google Play: store listing (drafts, en + es)”For Play Console › Grow users › Store presence › Main store listing (default language English (United States) –
en-US) and a translation Spanish (Spain) – es-ES (Manage translations › Add your own translations). Play’s
limits: app name 30 characters, short description 80, full description 4000; no emoji, no “best” / “#1”, no
testimonials or calls to action about ratings. The listing names the alarms in its opening paragraph and gives them
a section of their own because Play requires the core function behind USE_EXACT_ALARM to be documented and promoted
in the description [G11] (the declaration
above says they are the first thing it describes; since 2026-11-12 they are the opening paragraph’s second sentence).
It names the status bar feature briefly as a user-facing feature and never the means (no “root” / “LSPosed”); the
declarations above say how it works. No dosing language (no Take insulin): Sukrara isn’t a dosing aid.
State (2026-11-12): everything below is filled in for en-US and es-ES (name, short and full description, icon, feature graphic, the 8 phone screenshots per language in order) and saved. On 2026-11-12 the owner rewrote the short and full description in their own voice (with the DIY disclaimer); the texts below are that version with its spelling and grammar fixed, and its es-ES translation, both entered and saved the same day. The Review step’s AI asset declaration (Don’t label assets / Label assets as created or edited using AI) is answered Don’t label assets: no AI-generated content (the owner, 2026-11-12).
| Field | en-US | es-ES |
|---|---|---|
| App name (≤ 30) | Sukrara: glucose & alerts (25) |
Sukrara: glucosa y alertas (26) |
| Short description (≤ 80) | Your glucose in status bar and home screen widget. Discreet alarms, cool sounds (79) |
Tu glucosa en la barra de estado y en widgets. Alarmas discretas, sonidos chulos (80) |
| App icon | assets/brand/sukrara/android/play-store-512.png (512 × 512, the Android launcher icon’s art, cropped to what launchers show). Live since 2026-11-16 (replacing the earlier render with the glyph at 2/3 size, #210; AI declaration Don’t label assets) |
the same (es-ES has no icon of its own: it uses the default listing’s) |
| Feature graphic | ~/Pictures/sukrara-play/feature-graphic.png (1024 × 500, no alpha: the wordmark beside a synthetic glucose card), source assets/brand/sukrara/play/feature-graphic.html |
the same (its only word is the name) |
| Phone screenshots | ~/Pictures/sukrara-play/en/ (1080 × 1920, synthetic data; Reviewer access says how they were made) |
~/Pictures/sukrara-play/es/ |
| Category / tags | Medical (set); tags: Diabetes, Health (whatever Play offers closest) | the same |
| Contact | support-googleplay@a.mauri.app, https://sukrara.mauri.app (set) |
the same |
Full description, en-US (3993 characters):
Sukrara shows your continuous glucose monitor (CGM) readings live on your phone, at a glance: in the status bar, home screen widgets, lock screen and notifications, so you rarely need to open the app. It has all the alarms you'd expect, with minimal alarm fatigue thanks to smart features and discreet sound packs. Share your glucose with friends and family, or yourself, through the Android and macOS companion apps (more coming soon...). It's compatible with the DIY diabetes ecosystem (xDrip+, Nightscout...). And it has advanced glucose charts that are beautiful and easy to understand.
Important disclaimerI made Sukrara for myself and share it with everybody. I use it every day, at my own risk, and it works fine, but I can't guarantee it. Anyone else who uses it does so at their own risk too. The apps are still in development: all the core features are there, but many more improvements and cool features are coming.
Interconnectivity- Send to LibreView, Tidepool, Nightscout and Health Connect.- Can act as an xDrip+ or Nightscout API, and broadcast glucose to apps like AAPS.- Family and friends see your glucose live on their devices.- Companion apps via Bluetooth when nearby, or Nostr (internet) when far away.- Can read glucose data from Juggluco.- Everything stays on your phone by default.
Alarms and notifications- Highly customizable alarms.- Each alert type has its own sound and vibration.- Sounds are discreet, with a different intensity for each alert type.- Pick your favorite sound pack or make your own.- Minimal alert fatigue: alerts go quiet when you've already acted.- Optionally, alarms can ring loud, even in Do Not Disturb.- Configure how alarms repeat.- Unacknowledged very lows can alert the people who follow you.
Log effortlessly- Supports smart insulin pens: - NovoPen Echo® Plus. - Tells priming apart from injections.- Quick actions in notifications.- Quick log pop-up by tapping the widget, the notification or the Quick Settings tile.- Add logs from companion apps.
Glucose always at a glance- Status bar chip via Live Update.- Anywhere in the status bar with advanced setup.- Home screen widget. You never need to open the app.- Lock screen widget with advanced setup. No need to unlock or touch the phone.- Persistent notification with the widget.- Any other device, like a Garmin watch.- macOS companion app with glucose in the menu bar, alarms and widgets.
Data analysis and reports- Glucose report: time in ranges, avg. glucose, GMI (estimated HbA1c) and glucose variability (CV).- Your doctor or clinic still gets your data through LibreView or Tidepool.- Import/export your history and settings.- Gamification: cool visual effects from 90% time in range.
Widget & glucose chart- Glucose value and trend.- Time in range over the last 24 h.- Time since your last insulin or carbs, or time in range over 7 days.- 12 h glucose chart with range bands and colors.- Glucose distribution.- Markers for insulin and carb logs.- Handles edge cases: data gaps, a sensor about to expire, muted alarms...
More- Battery optimized.- Many settings, but organized and explained. Trust the defaults.- A nice sensor expiry flow with a Live Update and subtle reminders.- Multilingual, but English is the main language.- No ads, no analytics, no tracking, no account.- Free and open source (GPL-3.0). Code on GitHub: mauriciabad/sukrara.- Actively developed: contact me to add or change features.
Compatible CGM sensorsAbbott's FreeStyle Libre 2, 2+, 3, 3+; Dexcom G6/G7/ONE+; Accu-Chek SmartGuide; Sibionics GS1; CareSens Air; and LinX / AiDEX X. For some, you need to install Juggluco.
LegalSukrara is not a medical device and does not diagnose, treat, cure, or prevent any medical condition. Don't make treatment decisions based on it. Use at your own risk. All product and company names mentioned are trademarks of their respective owners. Sukrara is an independent project, not affiliated with them.Full description, es-ES (3997 characters):
Sukrara muestra en tu móvil, en directo y de un vistazo, la glucosa de tu monitor continuo (MCG): en la barra de estado, widgets, pantalla de bloqueo y notificaciones, así que casi nunca abres la app. Todas las alarmas que esperarías, con mínima fatiga gracias a funciones inteligentes y sonidos discretos. Comparte tu glucosa con familia y amigos, o contigo, con las apps para Android y macOS (y pronto más...). Compatible con el ecosistema DIY de diabetes (xDrip+, Nightscout...). Y con gráficas avanzadas, bonitas y fáciles de entender.
Aviso importanteHice Sukrara para mí y la comparto con todos. La uso a diario bajo mi responsabilidad y funciona bien, pero no puedo garantizarlo. Quien la use, también lo hace bajo la suya. Las apps siguen en desarrollo: lo esencial ya está, pero llegarán muchas más mejoras y novedades.
Interconectividad- Envía a LibreView, Tidepool, Nightscout y Health Connect.- Actúa como API de xDrip+ o Nightscout y emite la glucosa a apps como AAPS.- Familia y amigos ven tu glucosa en directo en sus dispositivos.- Apps complementarias por Bluetooth de cerca o Nostr (internet) de lejos.- Puede leer la glucosa de Juggluco.- Por defecto, todo se queda en tu móvil.
Alarmas y notificaciones- Alarmas muy personalizables.- Cada tipo de alerta con su sonido y vibración.- Sonidos discretos, con intensidad distinta según la alerta.- Elige tu paquete de sonidos o crea el tuyo.- Mínima fatiga: las alertas se callan cuando ya has actuado.- Opcional: alarmas a todo volumen, incluso en No molestar.- Configura cómo se repiten las alarmas.- Una muy baja sin respuesta puede avisar a quienes te siguen.
Registra sin esfuerzo- Plumas de insulina inteligentes: - NovoPen Echo® Plus. - Distingue el purgado de las inyecciones.- Acciones rápidas en notificaciones.- Registro rápido tocando el widget, la notificación o el ajuste rápido.- Añade registros desde las apps complementarias.
Tu glucosa siempre a la vista- Chip en la barra de estado (actualización en directo).- En cualquier sitio de la barra de estado, con configuración avanzada.- Widget de pantalla de inicio. Nunca tienes que abrir la app.- Widget de pantalla de bloqueo, con configuración avanzada. Sin desbloquear ni tocar el móvil.- Notificación permanente con el widget.- Otros dispositivos, como un reloj Garmin.- App de macOS con la glucosa en la barra de menús, alarmas y widgets.
Análisis e informes- Informe: tiempo en rangos, glucosa media, GMI (HbA1c estimada) y variabilidad (CV).- Tu médico o clínica aún recibe tus datos por LibreView o Tidepool.- Importa/exporta tu historial y tus ajustes.- Gamificación: efectos chulos desde el 90 % de tiempo en rango.
Widget y gráfica- Valor y tendencia de la glucosa.- Tiempo en rango de las últimas 24 h.- Tiempo desde tu última insulina o hidratos, o tiempo en rango de 7 días.- Gráfica de 12 h con franjas de rango y colores.- Distribución de la glucosa.- Marcas de insulina e hidratos.- Casos límite: huecos de datos, sensor a punto de caducar, alarmas silenciadas...
Más- Bajo consumo de batería.- Muchos ajustes, pero ordenados y explicados. Fíate de los predeterminados.- Caducidad del sensor bien resuelta, con actualización en directo y recordatorios sutiles.- Multilingüe (el idioma principal es el inglés).- Sin anuncios, analíticas, rastreo ni cuenta.- Libre y de código abierto (GPL-3.0). GitHub: mauriciabad/sukrara.- En desarrollo activo: escríbeme para añadir o cambiar funciones.
Sensores MCG compatiblesFreeStyle Libre 2, 2+, 3 y 3+ de Abbott; Dexcom G6/G7/ONE+; Accu-Chek SmartGuide; Sibionics GS1; CareSens Air; y LinX / AiDEX X. Algunos necesitan Juggluco.
LegalSukrara no es un producto sanitario y no diagnostica, trata, cura ni previene ninguna enfermedad. No tomes decisiones de tratamiento basándote en ella. Úsala bajo tu responsabilidad. Los nombres de productos y empresas son marcas de sus propietarios. Sukrara es un proyecto independiente, sin relación con ellos.Every claim above is in the app today (docs/FEATURES.md); change the listing in the same change as a feature it names.
Google Play: what the owner does in Play Console, in order
Section titled “Google Play: what the owner does in Play Console, in order”Prepared on 2026-11-11 (#142); entered the same day by an agent with the owner deciding on screen, except the bundle,
which the owner uploaded by hand. The bundle: apps/android/app/build/dist/Sukrara-<version>-play.aab from
tools/release/play-bundle.sh (signed with the release key = Play’s upload key; mapping inside), built from a commit
on main. From the next release on, tools/release/release.py uploads it to internal testing through the API
(One-command release).
Done 2026-11-11: App access (No, no part of the app is restricted), Target audience (13–15, 16–17, 18 and over), Privacy policy, Health apps, the store listing en-US + es-ES (draft), internal testing (release 0.13.0, versionCode 13000, Available to internal testers, not reviewed; opt-in link https://play.google.com/apps/internaltest/4700763397995090600), the full-screen intent and exact alarm declarations. Done 2026-11-12: the store listing’s new text (en-US + es-ES), its AI asset declaration (Don’t label assets), saved.
Done 2026-11-13: all of 1–4 below; the release went to production, not open testing (see the account section).
Approved and live (2026-11-16, the account section); the fixed listing icon (#210) live since 2026-11-16. Item 6 passed (below); the website’s Android page tells GitHub users how to switch.
The steps, as they were:
- App content › Data safety: settle the open premise. The definitions, flow by flow, and the recommended No (with this draft as the fallback) are in Privacy answers for both stores. Then Submit. It’s required before any review.
- The video (#185, recorded on the owner’s phone), uploaded
to YouTube as Unlisted (check it plays signed out); then App content › Foreground service permissions
(
connectedDevice): Continuous data transfer to an external device or Other with the description, and the link. Save. - Health Connect declaration, if it appears: the text above.
- Publishing overview: Send changes for review. Answer any question from Play truthfully (root and LSPosed: the text above).
- Install from the internal-testing link on a spare phone or emulator first (on the owner’s daily phone it would
replace the GitHub version: same package and key, the data stays), check Settings › About says Google Play
version. Done 2026-11-16 on the
medium_phoneemulator (Android 16, Play Store, the owner’s account), with the GitHub release APKs against Play’s 0.14.5:- GitHub 0.14.4 installed from the browser (installer Chrome): the listing says The app installed on your device
didn’t come from Google Play. You can update the app from the original source or from Google Play. with
Update from Play, then Update this app from Play? (…will be added to your Play library…). It updates in
place: installer
com.android.vending, Play’s splits,firstInstallTimekept; About 0.14.5 · Google Play version, no updater (noREQUEST_INSTALL_PACKAGES), setup without Keep Sukrara up to date. - GitHub 0.14.4 installed by Sukrara’s own updater (installer
app.mauri.sukrara; the updater doesn’t claim update ownership): plain Update, same result (this account already had Sukrara in its library from the first case). - GitHub 0.14.5 (the same version as Play): only Open. Nothing to switch to until the next version; then it is the first case. Not tested: Obtainium installs, and Play → GitHub on a real phone (adb skips the prompts). Open testing as a beta: dropped, no Play beta track: every release goes straight to production (the owner, 2026-11-16).
- GitHub 0.14.4 installed from the browser (installer Chrome): the listing says The app installed on your device
didn’t come from Google Play. You can update the app from the original source or from Google Play. with
Update from Play, then Update this app from Play? (…will be added to your Play library…). It updates in
place: installer
Garmin
Section titled “Garmin”The planned own watch app (watch face / data field / app, investigation 08) goes to the Connect IQ Store:
- Garmin developer account (18+, accurate registration info), no fee for free apps; paid apps go through the Merchant Service with an annual fee [C1].
- Upload the
.iqfrom Monkey C: Export Project with every supported device in the manifest; Garmin reviews it before it appears in the store and notifies on approval; it can refuse or remove apps at its discretion [C1][C2]. - Privacy policy required if the app collects data; no keeping user data longer than needed [C1].
- Medical: comply with FDA and other laws, and must not seek regulatory permissions or make determinations that could make Garmin’s products regulated [C1] — so the listing must be a display/convenience app with a “not a medical device” statement, never “alarm” or “diagnosis” claims. Precedent: CGM watch faces fed by xDrip/Juggluco servers are in the store (investigation 08; Kerfstok, CGM+).
- No Garmin marks in the app’s marketing without consent [C1]. The
Communicationspermission (web requests to the phone’s local server) is shown on the store page. - Effort: small once the app exists (screenshots for 2–3 device sizes, description, privacy link).
Connect IQ: CI and publishing (2026-11-16, Sukrara Aura)
Section titled “Connect IQ: CI and publishing (2026-11-16, Sukrara Aura)”The owner: “Would be nice if we configure the ci as well as automatic deployments/publishing (or at least leave it
ready to complete later)”. Built: Checks’ garmin job and release.py’s Garmin path; the setup and the owner’s steps
are in DEVELOPMENT.md › Garmin face on CI and › Release.
What CI needs. The SDK is a public download listed in sdks.json [C3]; monkeyc is Java. The
device files (compiler.json & co., without which monkeyc -d <device> can’t build) and the simulator’s fonts come
only through the SDK Manager with a Garmin sign-in; the SDK Manager has no CLI, and a Garmin forum thread still
complains that CI ends up needing the developer’s credentials [C4]. The Linux simulator (9.3.0) links
WebKitGTK 4.0 (libwebkit2gtk-4.0.so.37, read from the binary), which Ubuntu ships up to 22.04, and runs headless
under Xvfb [C5]; monkeydo needs a running simulator and its exit code doesn’t say whether the tests passed
(the last line says PASSED / FAILED) [C5][C6]. Screenshots of the simulator are scriptable on
macOS and Windows by window grabs (ciqkit, not on Linux yet) [C7] or in a container under Xvfb by a GTK hook
(rules_ciq) [C8].
How the device files reach CI (blast radius = what a leak of the credential gives away):
| Option | Blast radius | Reliability, upkeep | Verdict |
|---|---|---|---|
| The owner’s Garmin account, password as a secret | Everything: the watch, health and dive data, the store’s developer identity (the agreement forbids sharing its login, II.a.1 [C1]) | Breaks with two-step verification, which the CLI can’t answer [C9] | No |
A Garmin account only for CI (no watch, no data, no 2-step), password as secrets, signed in by connect-iq-sdk-manager-cli |
An empty account that can download SDK files | Never expires; used only on a cache miss; breaks if Garmin blocks scripted sign-ins (Cloudflare blocked Garmin Connect libraries’ sign-ins from March 2026 [C10][C11]) | Chosen (others: [C12][C13]) |
The same account’s token from a browser sign-in (token.json, OAuth client CIQ_SDK_MANAGER) |
That account’s SDK Manager token; no password stored | Refresh lifetime undocumented; a refreshed token can’t be written back to the secret, so it is replaced by hand when it expires [C14] | Fallback (GARMIN_CI_TOKEN) when sign-ins are blocked |
| A public image with Garmin’s device files (connectiq-tester-resources) | None of ours | Redistributes Garmin’s Program Materials, which the agreement forbids (I.b) [C1][C7]; a third party’s image | No |
| A self-hosted runner on the release Mac (files already there) | The owner’s Mac runs this public repo’s workflow code | GitHub advises against self-hosted runners for public repositories [C22] | No |
The CLI (Apache-2.0, v0.8.4, 2026-02) is pinned by version and sha256; its sign-in is a form post to
sso.garmin.com with clientId=ConnectIqSdkManager, then services.garmin.com/api/oauth/token (read in its source).
The agreement hash is the MD5 the SDK Manager takes of the agreement’s text: pinned, so a new agreement stops the job
until someone reads it. Caching (GitHub drops entries unused for 7 days) keeps sign-ins to a new device or a long
pause.
The developer key. Every build is signed; the store ties an app to the key of its first upload and refuses a
version signed with another (“All app versions have to be signed with the same key pair”); Garmin keeps only the
public key, so a lost key means a new listing that existing users must move to [C15]. CI therefore never gets it:
its builds only run in the simulator and use a key made for the run. The store key stays on the release Mac
(~/.connectiq/sukrara-developer-key.der, backup in the password manager, like the Android release key), and
tools/release/garmin-key.sha256 pins its public SHA-256; garmin-release.sh refuses any other key. Projects that
release from CI keep it as a base64 or GPG-encrypted secret [C16][C17]; Sukrara’s releases already run on the
release Mac with the other keys, so a CI copy would add a place to leak it and save nothing.
Store upload. There is no upload API: uploads go through the developer dashboard (moved to
apps-developer.garmin.com [C18]), Garmin reviews each upload and the store shows it once approved [C2]. A
request for an upload API (May 2026) is Acknowledged with no answer [C19]; others keep the last step by hand with
a checklist [C16][C20]. Scripting the dashboard would need the owner’s full developer account in a browser robot
(two-step verification, Cloudflare, an undocumented form that changes, a stray click submitting the wrong build):
rejected. Beta apps (a separate app id, only the developer’s account sees it, no review) [C21] are uploaded
the same way, so they don’t automate anything either; useful only to try the face’s phone settings before a public
version.
The flow. Every pushed change: the garmin job builds and tests the face. A release (release.py, once
tools/release/garmin-key.sha256 exists): the version step writes the version into the manifest; the gate builds
the store package and every device’s sideload .prg with the store key (debug code compiled out); github puts them
on the normal GitHub release (the .prg for people who sideload); the garmin step prints the upload for the owner:
the file, the version, the What’s New text and the dashboard link (about two minutes), and summary lists it as
the one manual step. If Garmin publishes an upload API, that step becomes a call like play and appstore.
Connect IQ store: what it asks and checks (research 2026-11-16, Sukrara Aura)
Section titled “Connect IQ store: what it asks and checks (research 2026-11-16, Sukrara Aura)”| Topic | What the store wants | Source |
|---|---|---|
| Account | A Garmin account signed in at apps-developer.garmin.com; the first upload asks for a unique developer name (shown on every app and review; the owner chose mauri.app, 2026-11-16). No fee for free apps; the Merchant Account tab is only for paid apps. The Developer License Agreement is accepted by the upload itself (“By submitting this app, you agree…”) |
the dashboard, [C1] |
| Upload | Step 1: the .iq (from monkeyc -e, every product in the manifest), App Version (≤ 20 characters, higher on every upload), the Beta App box. Step 2, once the file is verified: the description and images |
the dashboard, [C2] |
| Beta app | Its own app id in the manifest; only the developer’s account sees it, never reviewed, updated as often as wanted; the public app is a separate upload with the real id and the box unticked. Install it by opening apps.garmin.com/en-US/apps/<id> on the phone |
[C23], [C21], [C24] |
| Updates | Same key forever (“Signature check failed” otherwise), same app id (“App-id deviates”), a higher version | [C15], [C25] |
| Store icon | 500 × 500, sRGB, 10 px margin, a solid background (not black, not transparent), no text, no Garmin branding; for a watch face “a preview of the watch face often works best”. ≤ 300 KB (forum, not documented) | [C26], [C27] |
| Hero image | 1440 × 720, one per language when it has text; the featured carousel uses it (name + tagline); ≤ 2 MB (forum) | [C26], [C28], [C27] |
| Screenshots | No documented size; others upload the device’s resolution (390 × 390 here); ≤ 150 KB each (forum) | [C27], [C29] |
| Description | Plain text, no markdown, ≤ 4000 characters, checked only after the CAPTCHA (count it first) | [C30] |
| What a description must say | Every feature, requirement and dependency (“if the app’s core features do not work without …, you must disclose that”), the compatible devices, no Garmin partnership or affiliation claim, whether it needs payment | [C31] §4 |
| Medical | An app for “diagnosis, cure, mitigation, treatment or prevention” needs regulatory clearance; otherwise the description, features and functionality must not indicate it, “informational purposes only”. Also §1b: nothing that creates a false sense of security | [C31] §1b–c, [C1] |
| Dive watches | Apps for the Descent may not be intended only for use during a dive | [C31] §1b |
| Privacy | A privacy policy when the app collects data; it must say data goes to the developer, not Garmin; don’t move its URL without a redirect | [C31] §3c, [C1] Exhibit A |
| Permissions | Shown on the store page from the manifest: Communications as “Send/receive information to/from the Internet” (a face may use it only in the background, hence Background) | [C32], [C33] |
| Brand | No Garmin branding in the icon without permission; IP of others only with permission; other images aren’t covered (ask Garmin through its contact form) | [C26], [C31] §3a |
| Review | Officially up to 3 days; since October 2026 a backlog of 7–14 days, new faces and updates alike | [C34], [C35] |
Other CGM faces in the store say it the same way: Sugar Sense (“It is not a medical device and is not intended to diagnose, treat, cure, or prevent any disease”, confirm with the CGM app or a meter, never rely on it for alarms) [C36], GlucoPulse (“not a medical device”, not for insulin dosing) [C37].
What follows for Sukrara Aura. The listing follows the Mac App Store listing and the Play one: no accuracy claim, no dosing words, the not-a-medical-device paragraph, the owner’s own-risk line, not affiliated with Garmin or any sensor maker. Garmin Connect is named once, as the requirement the guidelines ask to disclose; never “Garmin” in the title, icon or images. The images use no bezel (the reference bezel prints GARMIN) and no Carbs / Insulin pill (the pill stays in the description as “the state of Sukrara’s alerts”). The Communications permission is explained in the description, since the store words it as the internet while the face only reaches Sukrara on the same phone.
Connect IQ store: the listing (drafts, en + es)
Section titled “Connect IQ store: the listing (drafts, en + es)”Nothing entered yet: Step 2 opens only after an upload is verified. The owner’s display name is set (mauri.app).
| Field | en | es |
|---|---|---|
| Title | Sukrara Aura (the manifest’s AppName, the same in both) |
Sukrara Aura |
| Store icon | docs/img/aura/store/ciq/icon-500.png (500 × 500, 49 KB) |
the same |
| Hero | docs/img/aura/store/ciq/hero-en.png (1440 × 720, 327 KB): Your glucose on your wrist / From Sukrara on your phone |
hero-es.png: Tu glucosa en la muñeca / Desde Sukrara en tu móvil |
| Screenshots, in order | docs/img/aura/store/ciq/screen-*.png (390 × 390, ≤ 70 KB): hero, sparkline, contours, glow, lasers, waterline, muted, hiking fields, always-on, night |
the same (no Spanish one without a pill yet) |
| Category | Watch face (the manifest’s type); any other category the form offers: Health / Medical, whichever is closest | the same |
| Privacy policy / support | https://sukrara.mauri.app/privacy / https://sukrara.mauri.app | the same |
| Price | Free |
The images are made by assets/brand/sukrara/connectiq/render.mjs
from the reference renderer with synthetic data (cases.json): node assets/brand/sukrara/connectiq/render.mjs, and
again once the face’s final look is approved (the digit spacing, defaults and sparkline were still changing on
2026-11-16).
Description, en (3119 characters):
Sukrara Aura shows your glucose on your watch face, next to the time: the value in its range colour, the last hours as a line or the trend arrow, and how long ago it was read. It is the watch face of Sukrara, a free and open-source Android app for people with diabetes who wear a continuous glucose monitor (CGM).
What you need• The Sukrara app on an Android phone, reading your glucose sensor, and Garmin Connect on the same phone. Sukrara sends every reading to the watch face through Garmin Connect.• iPhone is not supported.• Without Sukrara on your phone the face shows the time and your watch's own data, and "No readings".
At a glance• Your glucose in your range's colours, with up to the last 3 hours as a sparkline on a fixed scale, or Sukrara's trend arrow.• A level rail on the right with your own limits marked, and the last 30 minutes as a fading trail.• The reading ages on the watch's own clock: its time appears when it is late, then it is struck through and grey, then "No reading since" and the time. An old value never looks current, even with the phone out of reach.• The state of Sukrara's alerts on your phone (needs you, handled, muted and for how long) and of your sensor (warming up, ending, ended).• A background, the aura, that gathers at your level and spreads the further out of range you are: grain, contours, waterline, lasers or glow; or a map, or plain black.• Always-on and night modes that stay dim.• Private: hides the number until you touch and hold the screen.
Fields• One field on top and two along the bottom: weather, steps, sunset, Body Battery, altitude, notifications, today's time in range, a second time zone, floors, heart rate, or the last treatment you logged in Sukrara.• The watch's battery as a rail, in days, percent or both.
SettingsIn the Connect IQ app, or on the watch (hold MENU on the face › Watch face › Customize): dial, halo, trend (arrow or sparkline), seconds sweep, green in range, the three fields, battery label, private and second time zone.
WatchesRound 390 × 390 AMOLED: Descent Mk3 / Mk3i 43 mm, Venu 3S, Venu 4 41 mm, vívoactive 6, Forerunner 570 42 mm, epix Pro (Gen 2) 42 mm, MARQ (Gen 2) and MARQ Aviator, Approach S70 42 mm.
PrivacyThe face only talks to Sukrara on your phone: readings arrive through Garmin Connect, and every 5 minutes the face asks Sukrara on the same phone for the latest one (that is the Communications permission; nothing goes to the internet). Your watch's data (heart rate, steps, Body Battery, sleep times) stays on the watch. No account, no analytics, no ads. Privacy policy: https://sukrara.mauri.app/privacy
Free and open source (GPL-3.0): https://github.com/mauriciabad/sukraraIn English and Spanish. Help and feedback: https://sukrara.mauri.app
ImportantSukrara Aura is not a medical device and does not diagnose, treat, cure or prevent any condition; it is for information only. Values can be wrong, late or missing, and the watch face sounds no alerts. Don't base treatment decisions on it: check your sensor's own app or a blood glucose meter, and ask your doctor or diabetes care team for medical advice. I made Sukrara for myself and share it with everybody; use it at your own risk.
Sukrara is not affiliated with Garmin or with any sensor maker.Description, es (3307 characters):
Sukrara Aura muestra tu glucosa en la esfera del reloj, junto a la hora: el valor en el color de su rango, las últimas horas como una línea o la flecha de tendencia, y hace cuánto se leyó. Es la esfera de Sukrara, una app Android libre y gratuita para personas con diabetes que llevan un monitor continuo de glucosa (MCG).
Qué necesitas• La app Sukrara en un móvil Android, leyendo tu sensor de glucosa, y Garmin Connect en el mismo móvil. Sukrara envía cada lectura a la esfera a través de Garmin Connect.• No funciona con iPhone.• Sin Sukrara en el móvil, la esfera muestra la hora y los datos del propio reloj, y «Sin lecturas».
De un vistazo• Tu glucosa en los colores de tu rango, con hasta las últimas 3 horas como un minigráfico a escala fija, o la flecha de tendencia de Sukrara.• Una barra de nivel a la derecha con tus propios límites marcados y los últimos 30 minutos como un rastro que se desvanece.• La lectura envejece con la hora del propio reloj: cuando llega tarde aparece su hora, luego se tacha y se vuelve gris, y luego «Sin lectura desde» y la hora. Un valor antiguo nunca parece actual, aunque el móvil esté lejos.• El estado de las alertas de Sukrara en tu móvil (te necesita, atendida, silenciada y hasta cuándo) y el de tu sensor (calentando, acabándose, terminado).• Un fondo, el aura, que se concentra en tu nivel y se extiende cuanto más te alejas del rango: grano, curvas, línea de agua, láseres o brillo; o un mapa, o negro.• Modos siempre encendido y noche que se mantienen tenues.• Privado: oculta el número hasta que mantienes pulsada la pantalla.
Datos• Un dato arriba y dos abajo: tiempo, pasos, puesta de sol, Body Battery, altitud, notificaciones, tiempo en rango de hoy, una segunda zona horaria, pisos, frecuencia cardiaca o el último tratamiento que apuntaste en Sukrara.• La batería del reloj como una barra, en días, porcentaje o ambos.
AjustesEn la app Connect IQ, o en el reloj (mantén MENU en la esfera › Esfera del reloj › Personalizar): esfera, halo, tendencia (flecha o minigráfico), barrido de segundos, verde en rango, los tres datos, texto de batería, privado y segunda zona horaria.
RelojesAMOLED redonda de 390 × 390: Descent Mk3 / Mk3i 43 mm, Venu 3S, Venu 4 41 mm, vívoactive 6, Forerunner 570 42 mm, epix Pro (Gen 2) 42 mm, MARQ (Gen 2) y MARQ Aviator, Approach S70 42 mm.
PrivacidadLa esfera solo habla con Sukrara en tu móvil: las lecturas llegan a través de Garmin Connect, y cada 5 minutos la esfera pide la última a Sukrara en el mismo móvil (ese es el permiso de Comunicaciones; nada sale a internet). Los datos de tu reloj (frecuencia cardiaca, pasos, Body Battery, horas de sueño) se quedan en el reloj. Sin cuenta, sin analíticas, sin anuncios. Política de privacidad: https://sukrara.mauri.app/privacy
Libre y gratuita (GPL-3.0): https://github.com/mauriciabad/sukraraEn inglés y español. Ayuda y comentarios: https://sukrara.mauri.app
ImportanteSukrara Aura no es un producto sanitario y no diagnostica, trata, cura ni previene ninguna enfermedad; es solo informativa. Los valores pueden ser erróneos, llegar tarde o faltar, y la esfera no hace sonar alertas. No tomes decisiones de tratamiento basándote en ella: comprueba la app de tu sensor o un glucómetro, y pide consejo médico a tu médico o a tu equipo de diabetes. Hice Sukrara para mí y la comparto con todo el mundo; úsala bajo tu propia responsabilidad.
Sukrara no está afiliada a Garmin ni a ningún fabricante de sensores.Before pasting, check the texts against the approved face: the setting names (apps/garmin/resources*/strings), the
watch’s Customize path and the devices in the manifest. A new device or setting changes both texts.
Connect IQ store: the build
Section titled “Connect IQ store: the build”tools/release/garmin-release.sh --beta→apps/garmin/bin/dist/SukraraAura-beta.iq:build.sh export-beta, the face under the beta app id635140ec-f724-44fb-bc08-976fa9111250(fixed, so every beta upload updates the one beta app), signed with the store key.tools/release/garmin-release.sh <version>→SukraraAura-<version>.iq(the public app id) and each device’s.prg; needstools/release/garmin-key.sha256(below) and the manifest at that version.- Every
.iqis checked before it is kept: it unpacks (a 7-zip;bsdtar), carries the expected app id, version and every manifest device, itsdev_key.pubis the store key’s public key, and each device’s.prgpassesverify_prg.sh(the id, no debug code). Tried 2026-11-16 on the release Mac: both packages verified (418 KB, one device). Nothing was uploaded. - The beta gets no pushes. Sukrara on the phone pushes to the face’s real id (
AuraLink.APP_ID) and opens the 5-minute fetch only while a watch is known to have that face. The beta face therefore shows readings only while the sideloaded face (same real id) is also on the watch, and only from the fetch (up to 5 minutes late). Enough to try the store install, the Connect IQ app’s settings page and the listing’s look; the push is tried with the public app. - The pin.
tools/release/garmin-key.sha256(the store key’s public SHA-256,1e34106fdcd521d2f6676bf5b0f3d92691a8535cbe667f44064b886e7cdf111fon 2026-11-16) is the switch that puts the face inrelease.py. Commit it in the change that makes the first public upload, so that release writes the version into the manifest and builds the.iq.
Connect IQ store: the owner’s steps (beta first, then public)
Section titled “Connect IQ store: the owner’s steps (beta first, then public)”Marked [owner]: only the owner does it. Everything else an agent can do or prepare. Nothing goes up before the owner approves the face on the watch.
Beta (only the owner’s account sees it, no review):
- [owner] Sign in at https://apps-developer.garmin.com/developer/dashboard (done 2026-11-16; developer name
mauri.app). - An agent runs
tools/release/garmin-release.sh --betaon the release Mac and re-renders the images (node assets/brand/sukrara/connectiq/render.mjs), both from the approvednext. - Upload an App › Choose file:
apps/garmin/bin/dist/SukraraAura-beta.iq; App Version: the manifest’s (0.1.0today); tick Beta App (This app is for testing purposes only). - [owner] Continue. This uploads the file and accepts the Developer License Agreement and Terms of Use.
- Step 2, Enter Details: the title, the en description, the icon, hero and screenshots and the links from the listing; Spanish too if the form has languages. An agent may fill this in; it notes here what the form really asks.
- [owner] Submit.
- [owner] On the phone: open
https://apps.garmin.com/en-US/apps/<beta store id>(the dashboard shows it) in the Connect IQ app, install it on the watch, choose it, and check the settings page in the Connect IQ app.
Public (reviewed, 7–14 days at the moment):
- Commit
tools/release/garmin-key.sha256(above), then buildSukraraAura-<version>.iq: with the next Sukrara release (release.py: the gate builds it, thegarminstep prints the upload) or by hand (tools/release/garmin-release.sh <the manifest's version>). - Upload an App (not Upload a new version of the beta, which has the other id): the
.iq, the version, Beta App unticked. [owner] Continue. - Step 2 as in 5, then [owner] Submit. Garmin e-mails when it is approved; the face is in the store from then.
- After approval: put the store link on the website and the README (the website agent’s part) and on the phone’s Sukrara Aura row. Delete the beta app from the dashboard, and the sideloaded copy from the watch (the store copy replaces it: same id, same key).
Later versions: release.py’s garmin step prints the file, version and What’s New for Upload a new version of
the public app, and the owner submits it (no upload API).
Web and update channels
Section titled “Web and update channels”- sukrara.mauri.app as the install hub: one Download page that detects the platform: Play badge, “APK /
Obtainium / IzzyOnDroid” for power users, notarized dmg,
brew install --cask mauriciabad/tap/sukrara, Garmin store link. Keep the README buttons pointing at the same assets (thewebsite.ymllink rewriting already exists). - Channels:
stable(Play production, Sparkleappcast.xml, cask) andbeta(Sparkleappcast-beta.xmlviasparkle:channel, GitHub pre-releases); no Play beta track: every release goes straight to production (the owner, 2026-11-16). - Privacy page https://sukrara.mauri.app/privacy (
website/src/content/docs/privacy.md, HTML, not PDF [G10]; since 2026-11-10): what stays on the device, what each opt-in feature sends where (Nostr relays: end-to-end encrypted events, public keys, timing, IP; LibreView, Tidepool, Nightscout: what each upload carries; Health Connect, apps on the phone, the calendar, the password manager, the export), followers, the Mac app, how long things last and how to delete them, no analytics / ads / crash data, the contact address. Linked from the site’s home page and Settings › About. The same page serves Play, Garmin and the Mac app; a feature that sends something new changes it in the same commit.
Cross-cutting
Section titled “Cross-cutting”Privacy answers for both stores (drafts, 2026-11-11)
Section titled “Privacy answers for both stores (drafts, 2026-11-11)”These are drafts for the owner’s decision. Nothing here is saved in either console. The owner disputes that Sukrara
“collects” anything, so this checks that premise against each store’s own definitions, one data flow at a time.
Paths below are under apps/android/ (A) or apps/macos/ (M).
The definitions
- Google [G14]:
- Sending data from the app off the device counts as collecting it, whether it goes to the developer or to a third party.
- Not in scope: data processed only on the device, and data that is end-to-end encrypted so that nobody but the sender and the recipient can read it.
- The Data safety FAQ adds a third case: an upload the person makes directly to their own cloud account, governed by that provider’s terms and privacy policy, which the developer never gets. That needn’t be declared either.
- A transfer the person starts, and expects, isn’t sharing.
- Apple [A14]:
- Collecting is sending data off the device in a way that lets the developer, or its “third-party partners”, access it beyond serving the request in real time.
- Third-party partners are the analytics, ad and SDK vendors whose code is in the app.
- Data processed only on the device isn’t collected.
Android (the Play build)
| Flow (default) | Where it goes, evidence | Who can read it | Google: collected? |
|---|---|---|---|
| Sharing over relays (on once sharing is set up) | Readings, alerts, treatments and notes, the profile, mirrored settings: NIP-44 to the read key the followers get in a gift wrap (A core/protocol/…/event/EventFactory.kt:87-95, share/…/crypto/SdkNostrCrypto.kt:58-61). The backup goes to the wearer’s own key (EventFactory.kt:78-81). Public relays nobody on our side runs (core/protocol/…/Wire.kt:45) |
Only the wearer and the approved followers. The relays see the envelope: random public keys, IP, time, size, kind, expiry, the app version | No: the end-to-end exemption. The envelope is transport metadata on servers the developer doesn’t run. A strict reader could call the long-lived public key a Device or other ID (fallback below) |
| Bluetooth (on once someone follows) | The same encrypted events to devices nearby. During Pair nearby (≤ 10 min), the name, picture, invite code and relays, readable nearby (share/…/ShareOwnerModule.kt:132, share/…/ble/NearbyServerCore.kt:289-301) |
The content: only the followers. The pairing offer: anyone in range, for 10 minutes, after the person opens it | No: end-to-end encrypted, device to device. The pairing offer is a transfer the person starts and sees |
| Invite link / QR | The person hands it over. Its secret is in the #, never sent to the website |
Whoever gets it | No: the person’s own transfer |
| LibreView sign-in and upload (off) | E-mail and password, readings, treatments, notes, the sensor’s number, an install ID, and the name and date of birth the account already has. To Abbott, over TLS, into the person’s own account (A integrations/…/libreview/LibreViewUploader.kt:49-53, …/LibreViewClient.kt:180-189) |
Abbott, under its own privacy policy. Never the developer | Debatable. The bare definition says yes (off the device, to a third party). The own-account FAQ says no: the person’s own account, the provider’s terms, and the developer never gets it. Not shared either way |
| Tidepool (off; a follower’s Upload the person you follow, off) | The same kinds of data to api.tidepool.org (A integrations/…/tidepool/TidepoolUploader.kt:49-54) |
Tidepool, under its own privacy policy | As LibreView |
| Nightscout (off) | Readings, treatments, sensor changes, battery, a device name, to the person’s own site, https only (A integrations/…/nightscout/NightscoutUploader.kt:45-53, …/NsConfig.kt:62-63) |
The person’s own server | No: it’s literally the person’s own storage, the FAQ case |
| Health Connect, calendar, broadcasts, xDrip+ server, Nightscout API (all off) | On the phone (the API binds to the Wi-Fi only with Also on this Wi-Fi, off: A integrations/…/localserver/NightscoutApiServer.kt:447-448) |
Apps the person picks; their own devices | No: on the device or the person’s own devices |
| Android backup | Off (A app/src/main/AndroidManifest.xml:28-29, data_extraction_rules.xml). The key backup goes to the person’s own password manager |
— | No |
| Crash reports, analytics, ads | None: no SDK that phones home (A gradle/libs.versions.toml). Play’s own vitals are Google’s, not the app’s |
— | No |
| Updater | Not in the Play build (A app/build.gradle.kts:36, app/src/play/…/Store.kt:25) |
— | — |
Mac (the App Store version)
| Flow (default) | Where it goes, evidence | Apple: collected? |
|---|---|---|
| Following over relays | Follow request with name and picture, profile updates, requests for new keys and missed readings: all NIP-59 gift wraps to the wearer (M Sources/SukraraShare/Follower/FollowerSession.swift:130-160, …/Protocol/NostrSDKCrypto.swift:58-72). The entries added, if allowed: NIP-44 to the read key |
No: neither the developer nor any partner can read it. The relays aren’t the developer’s partners: no vendor code, an open protocol |
| Bluetooth nearby | Mac to the wearer’s phone | No |
| Juggluco on this network (off) | GETs to the person’s own phone on the home network, private addresses only. The API secret only as a hash (M Sources/SukraraShare/Lan/JugglucoApi.swift:32-39) |
No: their own devices |
| Updates, analytics, crash reports, iCloud, HealthKit | None. The App Store executable links no updater (M Package.swift:67, Sources/SukraraAppStore/main.swift:8). The sandbox is network client, Bluetooth and user-selected files (Bundle/appstore.entitlements.in). Keychain items are this-device-only |
No |
Precedent. Juggluco (on Play, with LibreView and Nightscout uploads) declares “No data collected” and “No data shared” [P4]. GlucoseBar (Mac App Store, Dexcom Share and Nightscout) shows Data Not Collected [A6].
Recommendation
- Apple: Data Not Collected. This one is clear-cut: there’s no partner code, and everything that leaves the Mac is end-to-end encrypted or stays on the person’s own devices.
- Google: “No”, the owner’s reading.
- The relays are covered by the end-to-end exemption.
- Nightscout is covered by the own-account FAQ.
- The integrations and the backup stay on the person’s own devices or accounts.
- LibreView and Tidepool are the person’s own accounts, under the provider’s own privacy policy, and the developer never gets them.
- The two weak points, if a reviewer reads strictly:
- LibreView and Tidepool are health services, not the FAQ’s “drive or cloud storage”.
- The relays see a long-lived random public key.
- If Play rejects the Data safety form, the fallback is the conservative draft in Google Play: Data safety…, minus Name and Other info if preferred. That draft says Yes, encrypted in transit, deletion possible, and lists the opt-in uploads as collected, optional, for App functionality, not shared. Optionally add Device or other IDs for the relay key. Saying more than needed carries no penalty; saying less than Play thinks is true does.
- The privacy page must match either answer. It lists every flow and says the developer receives nothing. It was
corrected on 2026-11-11 where the code said more:
- Bluetooth is on by default once someone follows.
- The GitHub version’s daily update check.
- The backup encrypted to the wearer’s own key.
- What the relays see.
- LibreView setting the active sensor.
- The Mac’s Juggluco search.
The exact clicks
- Play Console › App content › Data safety (the saved draft says Yes):
- Data collection and security: Does your app collect or share any of the required user data types? → No. The data-type pages go away.
- Next, Preview, Submit.
- App Store Connect › Sukrara › App Privacy:
- Get Started → No, we do not collect data from this app, then Save.
- Publish. The Privacy Policy URL https://sukrara.mauri.app/privacy is already set for en-US and es-ES.
Names and trademarks. Abbott claims “Libre”, the butterfly logo, the sensor’s look and the colour yellow; use is allowed only to identify Abbott’s products [T1]. Apple forbids third-party brands in the app name/icon without approval [A4]; Garmin forbids its marks in marketing without consent [C1]. So: the name stays Sukrara, the icon never shows a sensor or yellow butterfly, listings say “works with FreeStyle Libre 3 sensors” (nominative use, like Juggluco’s listing [P1]) plus “FreeStyle Libre and LibreView are trademarks of Abbott. Sukrara is not affiliated with or endorsed by Abbott” (already in the README disclaimer). No “LibreView” in titles or screenshots’ headlines.
GPL-3.0-or-later in stores. Distributing binaries requires the Corresponding Source. Play, the Mac dmg and the
Connect IQ store all allow a link: each release must tag the exact commit and the Juggluco revision compiled into
the native core (today an unpinned local checkout: pin it as a submodule or record the hash in the release notes),
and the app’s About page links to the source. GPL’s “no further restrictions” conflicts with store terms only for the
Mac App Store (the long-standing App Store/GPL debate). That debate is about distributing someone else’s GPL code
under the App Store’s terms; the Mac binary contains only the owner’s own code (every commit under apps/macos is
his) plus NostrSDK (MIT) and Apple’s frameworks, and a copyright holder isn’t bound by his own licence, so he can ship
it there. An outside contribution to the Mac app needs the contributor’s permission for the App Store (an additional
permission in that change) before it ships there. Juggluco’s own GPLv3 code is compatible (Android only).
Costs
| Item | Cost | When |
|---|---|---|
| Apple Developer Program (Developer ID, notarization) | 99 USD / year [A1] | before the first notarized release |
| Google Play developer account (personal) | 25 USD once [V2] | before the closed test |
| Android Developer Console | 0 (not needed: Play Console registers outside-Play apps too) [V2][V3] | — |
| Homebrew tap, IzzyOnDroid, F-Droid, Obtainium | 0 | — |
| Garmin Connect IQ (free app) | 0 [C1] | — |
| D-U-N-S / legal entity | not needed (personal account) | — |
| Total | 99 USD/year + 25 USD once |
Effort and timeline
| Step | Who | Effort | Calendar |
|---|---|---|---|
| Enrol in Apple Developer Program | user | 30 min + approval (hours–days) | week 1 |
| Developer ID cert + notarytool profile, first notarized dmg | user (cert, keychain) + agent | 1 h | week 1 |
| Homebrew tap + cask + auto-bump workflow | agent | 2 h | week 1 |
| Sparkle 2 + appcast on the site + EdDSA key | agent (user keeps the key) | 1 day | week 2 |
| Play developer account + identity verification | user | 1 h + verification (days) | week 1–2 |
Release keystore, play/full flavors, rename to app.mauri.sukrara, migration screen |
agent (user stores the key) | 2–3 days | week 2 |
| Privacy page, listing texts, screenshots (synthetic data), Health/FGS/exact-alarm/data-safety forms, FGS demo video | agent drafts, user submits | 1 day | week 2 |
| Closed test: 12 testers × 14 days, then production access + review | user recruits testers | — | weeks 3–5 |
| IzzyOnDroid request (Fastlane metadata, release-signed APK) | agent | 0.5 day | week 3 |
| F-Droid main repo (reproducible build, submodules) | agent | 2–4 days | later |
| Connect IQ store | user (account) + agent | 0.5 day | when the watch app exists |
Recommendation
Section titled “Recommendation”Mac: pay for the Apple Developer Program and ship notarized dmg/zip with Sparkle 2 updates from the
website; serve developers with an own Homebrew tap from the same release; submit to homebrew/cask once it’s
notable. Mac App Store (2026-11-11, #186): go, as a second, sandboxed build of the same app
(review risk), TestFlight first.
Android: one release key, package app.mauri.sukrara, two flavors. Google Play (the reinstated account,
production only, live since 0.14.5) for everyone; GitHub + Obtainium and IzzyOnDroid for the full flavor (with
its own update check; the root features are in both); register the package and key for developer verification in the same Play Console account before the
2027 global rollout. F-Droid main repo later, with reproducible builds.
Garmin: Connect IQ Store, free, display-only claims.
Next steps, in order
- (user) Enrol in the Apple Developer Program (99 USD/year, legal name as seller).
- (user) Create the Developer ID Application certificate and the
sukraranotarytool profile (NEXT.md §5). - (agent) First notarized release with the existing scripts; Homebrew tap + cask + auto-bump; README/site
brewinstructions. - (agent) Sparkle 2 in the Mac app, appcast on sukrara.mauri.app. (user) keeps the EdDSA private key backup.
(user) Create the Google Play developer accountDone 2026-11-10: the old account was reinstated, the app created, our key set for Play App Signing, API access set up (as set up).- (user) Generate and back up the release keystore (an agent can script it; the user owns the file and passwords).
- (agent) Rename to
app.mauri.sukrara,play/fullflavors,SCHEDULE_EXACT_ALARMinplay, migration screen in the last.pocbuild, settings export/import, Juggluco core pinned. Done: the rename, settings export / import, the pinned core, the flavors andtools/release/play-bundle.sh(2026-11-10, Flavors); the migration screen was dropped (the app starts clean). The owner then keptUSE_EXACT_ALARMand the root features inplay(2026-11-11);playonly leaves out the updater. - (agent) Privacy page, store listing (with the not-a-medical-device statement and Abbott disclaimer), synthetic screenshots, Fastlane metadata, FGS demo video script; drafts of the Health apps, data safety, FGS and exact-alarm answers. (user) submits the forms (only the account owner can). Done: the privacy page and the drafts (Data safety, Health apps and permission declarations). Done 2026-11-11: the store listing (en + es), the exact-alarm, FGS and full-screen-intent texts, the phone screenshots and the feature graphic (outside the repo), entered in Play Console the same day except Data safety and the FGS declaration (Play Console, in order). Open: the demo video (the emulator one was rejected; the owner records it, #185), an upload script.
Recruit 12 testers, closed test 14 daysNot required for the reinstated account; internal testing for the first builds, then production directly (no beta track).- Our key is the Play App Signing key (done 2026-11-10); developer verification for outside-Play installs follows
from the Play registration of
app.mauri.sukrarawith that key. (agent) IzzyOnDroid inclusion requestDropped 2026-11-13: IzzyOnDroid rejects AI-written apps (above). Obtainium link on the site.- F-Droid main repo from 2027-01-15 (its 3-month rule; #191); Connect IQ store when the watch app exists (user creates the Garmin account).
Only the user can: pay (Apple, Google), verify identity (Apple, Google Payments profile), own the accounts (Apple ID with 2FA, Play Console, Garmin), create the Developer ID certificate on their Mac, hold the release keystore and Sparkle EdDSA key, submit policy declarations, recruit testers, and decide on medical-device risk.
- Medical-device classification (EU MDR rule 3.3 / Play’s “software interfacing with medical device hardware”) could force a “Medical Device Apps” declaration Sukrara can’t back with a certification → Play rejection or removal. Mitigation: display/convenience framing, the sideload channel as fallback.
- Abbott: a trademark or ToS complaint can pull the Play listing (reported for Juggluco [P2]); the LibreView upload uses an unofficial API.
- Closed-test drop-outs restart the 14-day clock [G6][G7].
- Developer verification may tighten (the advanced flow is new, and F-Droid’s position is unresolved [V4]); losing the release key makes the package unregistrable [V2] — two backups.
- Team ID change on the Mac when moving to the paid team (Keychain prompt, new App Group container).
- Homebrew tap trust rules have changed twice in 2026 [H6]; recheck the cask instructions on each Homebrew major.
Sources
Section titled “Sources”All seen 2026-10-18. “3rd-party” = not the platform owner.
- [H1] Homebrew 5.0.0 release notes — https://brew.sh/2025/11/12/homebrew-5.0.0/
- [H2] Homebrew/brew #20755, removing
--no-quarantine— https://github.com/Homebrew/brew/issues/20755 - [H3] TomatoBar #102, cask disabled 2026-09-02 (3rd-party) — https://github.com/ivoronin/TomatoBar/issues/102
- [H4] Homebrew, Acceptable Casks — https://docs.brew.sh/Acceptable-Casks
- [H5] Example taps: livecheck, auto-bump, postflight quarantine (3rd-party) — https://github.com/nelsonlove/homebrew-tap/pull/3, https://github.com/EricAndrechek/homebrew-tap, https://github.com/HibernalGlow/homebrew-tap
- [H6] Homebrew 7.0.0 migration guide (tap trust) — https://brew.sh/7.0.0-migration-guide/
- [H7] Homebrew/brew #22472,
brew trust— https://github.com/Homebrew/brew/pull/22472 - [A1] Apple Developer Program — https://developer.apple.com/programs/
- [A2] Apple, Enrollment — https://developer.apple.com/help/account/membership/program-enrollment/
- [A3] Apple, Membership details (Developer ID, notarization) — https://developer.apple.com/programs/whats-included/
- [A4] App Review Guidelines (1.4.1, 2.4.5, 2.5, 4.1, 5.1.3, 5.2) — https://developer.apple.com/app-store/review/guidelines/
- [A5] Bluetooth sandbox entitlement — https://developer.apple.com/documentation/bundleresources/entitlements/com.apple.security.device.bluetooth
- [A6]–[A13] seen 2026-11-11 (3rd-party): GlucoseBar — https://apps.apple.com/us/app/glucosebar/id6468110131?mt=12; Sugar Sense: Menu Bar Glucose — https://apps.apple.com/us/app/sugar-sense-menu-bar-glucose/id6796828695?mt=12; Glucose Graph — https://apps.apple.com/us/app/glucose-graph/id1668560499?mt=12; nightguard — https://apps.apple.com/us/app/nightguard/id1116430352; Sugarmate’s removal — https://twitter.com/sugarmateapp/status/1495892882749800450; Shuggah’s removal — https://appshunter.io/ios/app/1586789452, https://www.diabetes.co.uk/forum/threads/shuggah-app-vanished.210952/; Spike’s certificate — https://medium.com/trit1dtech/devastating-news-for-diy-t1d-community-apple-tries-to-clamp-down-on-distribution-of-spike-app-ef57138b6163
- [A14] Apple, App privacy details on the App Store (seen 2026-11-11) — https://developer.apple.com/app-store/app-privacy-details/
- [S1] Sparkle documentation (2.9) — https://sparkle-project.org/documentation/
- [G1] Play Console Help, Closure of inactive developer accounts — https://support.google.com/googleplay/android-developer/answer/11605267
- [G2] XDA, inactive-account policy (2021, 3rd-party) — https://www.xda-developers.com/google-play-policy-crack-down-on-dormant-accounts/
- [G3] Reinstating / new account after inactivity closure (3rd-party) — https://mrhamo.com/blog/reinstate-google-play-developer-account-closed-inactivity/, https://magiskmodule.gitlab.io/blog/google-play-console-has-old-inactive-account-in-it-how-do-i-create-a-new-developer-account-to-publish-app/
- [G4] Play Console Help, Create and set up your app (package names) — https://support.google.com/googleplay/android-developer/answer/9859152
- [G5] Play Console Help, account types and required information — https://support.google.com/googleplay/android-developer/answer/13628312
- [G6] Play Console Help, App testing requirements for new personal developer accounts — https://support.google.com/googleplay/android-developer/answer/14151465
- [G7] 12-tester rule explained, organization exemption (3rd-party) — https://www.choicely.com/blog/google-play-12-tester-rule, https://ontest.app/blog/google-play-12-testers-14-days-requirement-explained
- [G8] Play Console Help, Target API level requirements — https://support.google.com/googleplay/android-developer/answer/11926878
- [G9] Play Console Help, Health apps declaration form — https://support.google.com/googleplay/android-developer/answer/14738291
- [G10] Play Console Help, Health Content and Services — https://support.google.com/googleplay/android-developer/answer/16679511
- [G11] Play Console Help, Permissions and APIs that access sensitive information (exact alarms) — https://support.google.com/googleplay/android-developer/answer/16558241
- [G12] Play Console Help, Foreground service and full-screen intent requirements — https://support.google.com/googleplay/android-developer/answer/13392821
- [G13] Play policy, Device and Network Abuse — https://support.google.com/googleplay/android-developer/answer/16559646
- [G14] Play Console Help, Data safety section — https://support.google.com/googleplay/android-developer/answer/10787469
- [G15] Play Console Help, Play App Signing — https://support.google.com/googleplay/android-developer/answer/9842756
- [V1] Android developer verification — https://developer.android.com/developer-verification
- [V2] Developer verification FAQ — https://developer.android.com/developer-verification/guides/faq
- [V3] Android Developers Blog, verification rolling out to all developers — https://developer.android.com/blog/posts/android-developer-verification-rolling-out-to-all-developers-on-play-console-and-android-developer-console
- [V4] Enforcement in four countries; F-Droid 2.0 (3rd-party) — https://techaiwire.com/articles/android-developer-verification-enforcement-four-countries/, https://pinggy.io/blog/f_droid_2_0_android_developer_verification/
- [V5] Register your app on open source platforms — https://developer.android.com/developer-verification/guides/open-source-app-registration
- [R1] MDCG 2019-11 (software qualification/classification, MDR Annex VIII 3.3) — https://health.ec.europa.eu/document/download/b45335c5-1679-4c71-a91c-fc7a4d37f12b_en?filename=mdcg_2019_11_en.pdf
- [R2] 21 CFR 862.1350 — https://www.ecfr.gov/current/title-21/chapter-I/subchapter-H/part-862/subpart-B/section-862.1350
- [R3] FDA product code PJT — https://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfpcd/classification.cfm?id=PJT
- [P1] Juggluco on Google Play — https://play.google.com/store/apps/details?id=tk.glucodata
- [P2] FUDiabetes forum, Juggluco back on Play (3rd-party) — https://forum.fudiabetes.org/t/juggluco-back-on-play-store/15038
- [P3] xDrip+ installed from GitHub (3rd-party) — https://forum.fudiabetes.org/t/upgrade-to-libre-3-from-libre-2-using-xdrip-on-android/14774
- [P4] Juggluco’s Data safety on Google Play (seen 2026-11-11) — https://play.google.com/store/apps/datasafety?id=tk.glucodata&hl=en
- [F1] Obtainium releases (1.7.0) — https://github.com/ImranR98/Obtainium/releases
- [F2] F-Droid Inclusion Policy — https://f-droid.org/docs/Inclusion_Policy/
- [F3] F-Droid Anti-Features — https://f-droid.org/docs/Anti-Features/
- [F4] IzzyOnDroid App Inclusion Policy / new app inclusions — https://izzyondroid.org/docs/general/AppInclusionPolicy/, https://izzyondroid.org/contributing/NewAppInclusions/
- [F5] Accrescent, The Future of Accrescent — https://accrescent.app/blog/posts/the-future-of-accrescent/
- [F6] Accrescent publishing requirements — https://accrescent.app/docs/guide/appendix/requirements/
- [C1] Garmin Connect IQ Developer Agreement (Exhibit A) — https://developer.garmin.com/downloads/connect-iq/sdks/agreement.html
- [C2] Garmin, Submit an app — https://developer.garmin.com/connect-iq/submit-an-app/
- [C3]–[C22] seen 2026-11-16: Garmin’s SDK list — https://developer.garmin.com/downloads/connect-iq/sdks/sdks.json; [C4] Garmin forum, ConnectIQ Docker image and GitHub Action — https://forums.garmin.com/developer/connect-iq/f/discussion/303170/connectiq-docker-image-and-github-action; [C5] matco/connectiq-tester (Dockerfile, tester.sh) — https://github.com/matco/connectiq-tester; [C6] monkeyc and monkeydo on Linux (3rd-party) — https://nettek.ca/blog/monkeyc-and-monkeydo-garmin-linux/; [C7] ciqkit — https://github.com/JohannesHoh/ciqkit; [C8] rules_ciq — https://github.com/semolina-solutions/rules_ciq; [C9] ues-widget #14, the CLI can’t answer 2FA — https://github.com/dnullproject/ues-widget/issues/14; [C10] garth, Deprecating Garth — https://github.com/matin/garth/discussions/222; [C11] python-garminconnect #337, 429 at sign-in — https://github.com/cyberjunky/python-garminconnect/issues/337; [C12] coachd #31, CI with a dedicated account — https://github.com/stefiix92/coachd/pull/31; [C13] BartSte/garmin-connect-iq, CI with the CLI — https://github.com/BartSte/garmin-connect-iq; [C14] foulee #466, token.json from a browser sign-in — https://github.com/EnO33/foulee/issues/466; [C15] Garmin forum, Developer Key lost (Garmin’s answer) — https://forums.garmin.com/developer/connect-iq/f/connect-iq-web-store/402228/developer-key-lost; [C16] foulee #467, release workflow, manual upload — https://github.com/EnO33/foulee/issues/467; [C17] garmin-connectiq-release-action — https://github.com/blackshadev/garmin-connectiq-release-action; [C18] Garmin, Changes to the Connect IQ Store — https://forums.garmin.com/developer/connect-iq/b/news-announcements/posts/changes-to-the-connect-iq-store; [C19] Garmin forum, upload API request — https://forums.garmin.com/developer/connect-iq/i/bug-reports/connect-iq-upload-applications-updates-to-store-with-the-batch-api; [C20] connectiq-starter (“not automatable”) — https://github.com/oleg-koval/connectiq-starter; [C21] Garmin forum, beta apps — https://forums.garmin.com/developer/connect-iq/f/discussion/3643/beta-testing-uploaded-app/55912; [C22] GitHub, self-hosted runners and public repositories — https://docs.github.com/en/actions/security-for-github-actions/security-guides/security-hardening-for-github-actions#hardening-for-self-hosted-runners
- [C23]–[C37] seen 2026-11-16: [C23] Garmin, Beta Apps — https://developer.garmin.com/connect-iq/core-topics/beta-apps/; [C24] garmin-russia-trains #4, beta app id and install workaround — https://github.com/andreiyurik/garmin-russia-trains/pull/4; [C25] Garmin forum, “App-id deviates” — https://forums.garmin.com/developer/connect-iq/f/connect-iq-web-store/443221/two-apps-stuck-in-pending-since-aug-31-replacement-upload-rejected-with-a-misleading-manifest-id-error/2059294; [C26] Garmin, Connect IQ brand guidelines (icon, hero) — https://developer.garmin.com/brand-guidelines/connect-iq/; [C27] Garmin forum, image size limits — https://forums.garmin.com/developer/connect-iq/f/connect-iq-web-store/427625/i-want-nice-things-reasonable-image-size-limitations; [C28] Garmin, We want you to feel seen (hero images) — https://forums.garmin.com/developer/connect-iq/b/news-announcements/posts/we-want-you-to-feel-seen; [C29] foulee #468, store visuals — https://github.com/EnO33/foulee/issues/468; [C30] Garmin forum, 4000-character limit — https://forums.garmin.com/developer/connect-iq/f/discussion/7753/ciq-store-doesn-t-enforce-4000-char-limit-while-typing-only-after-captcha; [C31] Garmin, Connect IQ App Review Guidelines (2021-10-13) — https://developer.garmin.com/connect-iq/app-review-guidelines/; [C32] Garmin forum, the Internet permission’s wording — https://forums.garmin.com/developer/connect-iq/f/discussion/6588/where-does-the-permission-send-receive-information-to-from-the-internet-come-from; [C33] Garmin forum, watch face permissions — https://forums.garmin.com/developer/connect-iq/f/discussion/6328/how-to-specify-permissions-for-watch-face-deployment; [C34] the5krunner, Connect IQ store delays (2026-10-16) — https://the5krunner.com/2026/10/16/connect-iq-store-delays/; [C35] Garmin forum, review delays — https://forums.garmin.com/developer/connect-iq/f/connect-iq-web-store/445602/in-review-delay-multiple-watch-faces-pending-approval-some-for-7-days-already; [C36] Sugar Sense Watch Face (store listing) — https://apps.garmin.com/en-US/apps/5bf02aaf-f9da-40d9-aded-76bb8158fb52; [C37] GlucoPulse (store listing) — https://apps.garmin.com/en-US/apps/b309a480-c7f4-4dca-b2ec-ca1f4fd63cc2
- [T1] Abbott trademark notice (via its Play listings and site, 3rd-party summary) — https://play.google.com/store/apps/details?id=com.abbott.adc.freestyle.libre.us