Shadow720
Serverless, end-to-end encrypted group location, chat, and file sharing. Tauri v2 + Rust, backed by Nostr relays that store only ciphertext.
The core principle
Shadow720 is a private group app for the people you actually trust — your family, your hiking group, your crew. It shows everyone on a live map, carries a group chat, and moves files between you.
The difference is what it doesn't have: no server, no account, no company in the middle. Every position, message, and file is encrypted on your device with XChaCha20-Poly1305 and signed with Ed25519 before it is stored anywhere. The place it gets stored — a public Nostr relay — only ever holds ciphertext. It cannot read your group, and neither can I.
| Shadow720 | Typical family-locator app | |
|---|---|---|
| Monthly price | $0 | $5–$15 per group |
| Per-seat fee | $0 | Often |
| Server to run | None | Required |
| Who can read your location | Only your group | The vendor |
| Account required | None | Yes, per member |
| Data retention you control | Yes — you hold the keys | Vendor policy |
There is nothing to host, so there is nothing to pay for. The storage is free-tier infrastructure that already exists: public Nostr relays and Blossom blob servers. The app is MIT-licensed and the whole thing runs on your hardware.
Getting a group running
A keypair is generated on the device, the group key is sealed inside the invite, and you get a GRP2-… string to share. Joining is a single paste — no account, no email, no verification, no password.
Anyone holding the GRP2- code can join the group. Share it only with people you trust, over a channel you trust. Legacy GRP1- codes still work and are sealed with a password via Argon2id.
What's new in v0.1.9
- Positions survive a lost connection. A fix that cannot reach a relay is sealed into an on-device outbox and published automatically when the connection returns.
- The offline stretch is in your history. Cached fixes are written to the local track log as they are captured, so the map's history view shows where you actually went.
- You can see that sharing is deferred. A banner reports how many positions are cached and offers a retry.
- Joining is a single paste. Invites are now self-contained
GRP2-codes — no join password to remember or transmit. - Tap a name to fly there. Selecting a member in the roster centres and zooms the map on them.
- A month of history. Every device keeps a 31-day track log, grouped by day and week, with distance, dominant activity, and lowest battery.
- Background location survives the app closing. The foreground service publishes straight into the Rust core over JNI, so the pin keeps moving with the screen off.
Under the hood
The Rust core owns every decision that matters: what gets encrypted, what gets signed, when a position is worth publishing, and how hard to back off when a relay pushes back. The React layer is a view over typed commands — it never touches a key.
| Logical table | Nostr primitive | Concurrency safety |
|---|---|---|
| Member roster + live location | kind 30078, addressable per member | each member only ever writes their own d-tag slot, so N phones never collide |
| Group chat | kind 30079, addressable per message | append-only |
| File pointers | kind 8096, non-replaceable | relays retain multiple files from the same author |
| Encrypted file vault | Blossom blobs, addressed by SHA-256 | content-addressed, so a re-upload is a no-op |
| Rotation / closure / control | kinds 30081, 30082, 8098 | signed by the pinned host |
| Deletion | kind 5 (NIP-09), author-signed | advisory by design |
Movement and cadence policy
Publishing every GPS fix would burn battery and flood relays, so the core gates it: a fix under 15 m isn't worth publishing, a 30-second floor between publishes, a 4-minute heartbeat so a still member stays fresh, ±25% jitter so 50 phones never align into a herd, and adaptive backoff when a relay stops answering.
Activity is inferred from reported speed: under 0.8 m/s stationary, under 1.5 walking, under 4.0 running, under 8.0 cycling, above that driving. A rolling median over the last three samples plus two-sample hysteresis means one noisy fix cannot flip a member between "walking" and "driving".
Offline cache
A fix that the movement gate decided was worth publishing can still fail to reach a relay. Rather than dropping it, the core seals it into an on-device outbox and replays it when a relay answers — so a tunnel, a flight, or a dead Wi-Fi network no longer leaves the group looking at a stale pin. The cache is bounded (at most 512 fixes, nothing older than 24 hours), sealed with the group key, and removed with the vault.
Each device also keeps a month-long local track log of every member it has seen, grouped by day and week with distance, dominant activity, and lowest battery. It is sealed with the group key and never published.
Security model
| Property | Mechanism |
|---|---|
| Confidentiality | XChaCha20-Poly1305 for all payloads, invites, and file blobs |
| Integrity | AEAD tag over every payload; SHA-256 over every file blob |
| Authenticity | Ed25519 over a length-prefixed canonical form including protocol version, key epoch, sender key, nonce, and ciphertext |
| Key agreement | the group key rides inside the self-contained GRP2- invite; legacy GRP1- invites are sealed with a join password via Argon2id |
| At rest | sealed vault file whose key is wrapped by the OS keystore — Android Keystore, Windows DPAPI |
| Rotation | key epochs: a removed member loses access to everything written after the rotation |
| Transport | rustls only, no OpenSSL; WebSocket for relays, HTTPS for blobs |
| Memory hygiene | zeroize on key material, no plaintext kept in React state longer than a render |
What the storage provider can see
| Visible | Not visible |
|---|---|
| That some pubkey published an event at some time | Positions, messages, file contents, display names |
| Event sizes and counts | Group membership (roster entries are encrypted) |
| Which relays you connect to | Your group code or group key |
| The map viewport you are looking at (tile requests) | Anything about who else is in the group |
A relay operator sees ciphertext and metadata but cannot read your group. A stolen device yields a vault file that is useless without the OS keystore. A removed member keeps whatever they already downloaded — rotation is not retroactive. The app's authors have no server, no telemetry, and no way to reach your data.
Engineering choices
The dependency list is deliberately small. Every crate is doing a job that cannot be done safely by hand: tauri 2 for the shell and IPC, chacha20poly1305 and ed25519-dalek for crypto, argon2 for key derivation, secp256k1 for Nostr keypairs, tokio-tungstenite for relay transport, reqwest with rustls-tls so there's no OpenSSL dependency, and zeroize to wipe key material on drop.
There is no map library. The map is a canvas with its own Web Mercator projection and gesture model — one projection, one event model, no extra dependency, and a none basemap mode that skips the network entirely.
Why Nostr is the only backend
Identity is a keypair generated on your device, so there is no signup, no token, and no repository to create. Each member signs their own events, so a guest can only write their own roster slot — the "every guest can destroy the shared store" problem that a token-based backend has simply does not exist here.
Anyone can download the app, create a group, and invite whoever they like. There is no central account, no allow-list, and no per-install provisioning: relays and Blossom servers default to built-in public lists, and a group is just a keypair plus a group key.
Status
The Rust core has 367 unit tests, all passing; the TypeScript UI is tsc --noEmit clean and the production bundle builds. Prebuilt packages are attached to each release: a Windows installer (.exe / .msi), a signed Android APK for Android 8.0+ (arm64), a Play bundle (.aab), and Linux packages (.deb, .rpm, .AppImage).
Honest limitations: deletion is advisory (relays and other clients may retain copies), rotation is not retroactive, the map fetches OpenStreetMap tiles so the tile server sees the viewport being requested, and the offline path has not yet been exercised on a physical device.