Rust · Tauri · E2EE · No server

Shadow720

Serverless, end-to-end encrypted group location, chat, and file sharing. Tauri v2 + Rust, backed by Nostr relays that store only ciphertext.

Role
Architect & sole developer
Stack
Rust · Tauri v2 · React 19
Status
v0.1.9 · Nostr backend
Platform
Windows · Android · Linux
Live map with four group members, activity badges, and travel trails
The live map — real trails, real activity, refreshed every 15 seconds.
Wide desktop map with the member list beside the map and a left navigation rail
On desktop the app opens wide — a 1260×720 window with a left navigation rail and the map beside the member list.
$0 to run, forever
367 Rust unit tests passing
0 servers, accounts, or companies in the middle
E2EE before anything leaves the device
Encrypted group chat with text and file messages
Messages and files sealed on the phone before they leave it.
Settings showing group diagnostics, members, and host controls
Key epochs, member roles, rotation, and a wipe button that actually wipes.

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.

Shadow720Typical family-locator app
Monthly price$0$5–$15 per group
Per-seat fee$0Often
Server to runNoneRequired
Who can read your locationOnly your groupThe vendor
Account requiredNoneYes, per member
Data retention you controlYes — you hold the keysVendor 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.

Group setup screen with group code and display name fields
Create a group — a keypair is generated on the device and the group key is sealed inside the invite.
Group code sheet showing the device fingerprint and reveal invite button
The group code is the secret — share it only with people you trust.
The group code is the secret

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 tableNostr primitiveConcurrency safety
Member roster + live locationkind 30078, addressable per membereach member only ever writes their own d-tag slot, so N phones never collide
Group chatkind 30079, addressable per messageappend-only
File pointerskind 8096, non-replaceablerelays retain multiple files from the same author
Encrypted file vaultBlossom blobs, addressed by SHA-256content-addressed, so a re-upload is a no-op
Rotation / closure / controlkinds 30081, 30082, 8098signed by the pinned host
Deletionkind 5 (NIP-09), author-signedadvisory 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

PropertyMechanism
ConfidentialityXChaCha20-Poly1305 for all payloads, invites, and file blobs
IntegrityAEAD tag over every payload; SHA-256 over every file blob
AuthenticityEd25519 over a length-prefixed canonical form including protocol version, key epoch, sender key, nonce, and ciphertext
Key agreementthe group key rides inside the self-contained GRP2- invite; legacy GRP1- invites are sealed with a join password via Argon2id
At restsealed vault file whose key is wrapped by the OS keystore — Android Keystore, Windows DPAPI
Rotationkey epochs: a removed member loses access to everything written after the rotation
Transportrustls only, no OpenSSL; WebSocket for relays, HTTPS for blobs
Memory hygienezeroize on key material, no plaintext kept in React state longer than a render

What the storage provider can see

VisibleNot visible
That some pubkey published an event at some timePositions, messages, file contents, display names
Event sizes and countsGroup membership (roster entries are encrypted)
Which relays you connect toYour group code or group key
The map viewport you are looking at (tile requests)Anything about who else is in the group
Threat model, stated plainly

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.

Related projects