No internet. No server. No account.

Every phone becomes a node in the network.

AstraMesh turns nearby Android devices into a self-organizing, encrypted mesh — discovering peers over Bluetooth LE, relaying messages hop by hop, and delivering them later if a recipient is temporarily offline. Built for disaster zones, blackouts, and anywhere the network you can't rely on is the one everyone else controls.

8
max relay hops per message
256-bit
AES-GCM end-to-end encryption
0
servers required
26+
Android API minimum

Most chat apps assume the internet is always there.

AstraMesh doesn't. It was built on the opposite assumption: the network you can trust is the one made of the people standing near you.

Cellular and Wi-Fi both fail together

Disasters, blackouts, and remote terrain take out the cell towers and the Wi-Fi at the same time — the two networks most chat apps assume will always be there.

A central server is a single point of failure

If the app needs a backend to relay a message between two phones sitting next to each other, the app doesn't work exactly when it's needed most.

Store-and-forward isn't optional, it's the point

A message sent while someone is briefly out of range shouldn't just fail. It should wait, and arrive the moment a route reappears.

A protocol built for hops, not hosts.

Bluetooth LE discovery
Every device advertises and scans simultaneously — there's no fixed access point, so any two nearby phones can find each other directly.
ECDH handshake
Phones exchange public keys on first contact (HELLO / HELLO_ACK) and derive a shared AES-256 session key locally. The private key never leaves the device.
Encrypted, always
Every chat payload is sealed with AES-GCM under that session key before it touches the radio. A relay node forwards ciphertext it cannot read.
Epidemic relay
Messages hop through intermediate devices with deduplication and a bounded TTL, so delivery doesn't need a direct link — just a path.
Store-and-forward
If the next hop is offline, the packet is queued locally — still encrypted — and retried automatically the moment that peer reappears.
Delivery you can see
Pending, sent, relayed, delivered, or failed: every message shows its real state, derived from an actual ACK round-trip through the mesh.

Fourteen modules, one direction of dependency.

The protocol layer knows nothing about Android. The routing engine knows nothing about Bluetooth. Every layer above only depends on the interfaces of the layer below it — which is what makes the whole mesh pipeline testable on the JVM, no emulator required.

L4App
appfeature-chatfeature-discoveryfeature-filesfeature-broadcastfeature-settings

Compose UI + ViewModels. Never talks to Bluetooth or crypto directly.

L3Mesh
core-meshcore-ui

MeshCoordinator ties transport, routing, security, and persistence together.

L2Core engines
core-routingcore-securitycore-transportcore-persistence

Pure Kotlin where possible — routing and security are unit-tested with zero Android dependency.

L1Protocol
core-domaincore-protocol

Entities, packet envelope, and typed payloads. Everything else is built on this.

Full dependency graph and design rationale: see docs/architecture.md in the repository.

What happens between tapping send and seeing “Delivered”.

  1. 01

    Discover

    Devices advertise and scan over Bluetooth LE. No pairing screen, no PIN — just presence.

  2. 02

    Handshake

    On first contact, both sides exchange public keys and derive a shared session key locally via ECDH.

  3. 03

    Send

    A message is persisted as PENDING, sealed with AES-GCM, wrapped in a versioned packet, and handed to routing.

  4. 04

    Relay

    If the destination isn't a direct peer, the packet hops through relay-capable neighbors — deduplicated, TTL-bounded.

  5. 05

    Store, if needed

    No route right now? The packet queues, still encrypted, and retries the moment a peer reappears.

  6. 06

    Deliver + ACK

    The destination decrypts, persists the message, and sends an encrypted ACK back through the same mesh.

The interface, in the same black.

One monochrome system across the app and this page — built with Jetpack Compose on device, and the same color tokens here.

Nearby

Nearby Nodes

Scanning

3 peers nearby

Live
node-b3f1
ACTIVE
node-7a02
HANDSHAKING
node-e9c4
DISCOVERED

Chat thread

node-b3f1 Connected
Reached the shelter, all four of us are safe.
10:42 Delivered
Good. Sending water coordinates now.
10:43 · relayed ×2

Emergency broadcast

Broadcast

CRITICAL

Bridge on Route 9 unstable. Do not cross. Rescue staged at north lot.

Reached 11 nodes · relayed ×3

Diagnostics

Diagnostics

Chat sent

128

Chat received

112

Relayed

47

Dedup cache

203

Built on stable, boring technology.

No experimental frameworks in the parts that need to just work in a blackout.

Mobile app

  • Kotlin
  • Jetpack Compose
  • Material 3
  • Coroutines & Flow
  • Hilt
  • Room
  • Kotlin Serialization

Networking

  • Bluetooth LE advertising & scanning
  • GATT sessions
  • Transport-agnostic packet envelope

Security

  • ECDH (secp256r1)
  • AES-256-GCM
  • Per-peer session keys
  • Local-only private keys

This website

  • Next.js
  • Tailwind CSS
  • shadcn/ui
  • Radix primitives
  • Motion
  • Lenis

Get the app on your phone.

The APK is debug-signed by Android's default keystore, so it installs directly after enabling “install from unknown sources” — no separate signing step. minSdk 26, targetSdk 35.

Latest release
The permanent download path. Every tagged version (v0.1.0 and up) publishes an installable APK as a GitHub Release asset.
Open latest release
Latest build (CI artifact)
Every push to main builds and tests fresh. Grab the astramesh-debug-apk artifact from the most recent successful run — expires after 90 days.
Open GitHub Actions

Bluetooth LE requires BLUETOOTH_SCAN, BLUETOOTH_ADVERTISE, and BLUETOOTH_CONNECTat runtime on Android 12+. Grant them when prompted — the mesh can't discover peers without them.