No phone number. No cloud. No trace.

Your messages, calls, and voice notes are locked on your device with a key that only the recipient's device can unlock. The server in the middle just shuffles bytes around — it physically can't read what you sent, even if a court ordered it to. Same protection for text, voice messages, and live calls.

Every conversation in Offline has a unique safety number — six groups of five digits — generated from both of your encryption keys. Both phones calculate the exact same number from the math. If you compare the digits with your contact (in person, or over another trusted channel) and they match, you've confirmed your connection is genuinely between just the two of you. It's an extra layer of confidence, not something most people need to do every chat — think of it like checking the seal on a package. Useful for sensitive conversations, optional for everyday chats.

Encryption protects what's inside the package, but you also want to know the package is going to the right person. The safety number is how you confirm your messages are reaching exactly who you think they are. If the number changes unexpectedly later, it means your contact reinstalled the app on a new device — Offline will let you know so you can re-verify with them.

Both phones take both public keys, sort them in the same order, and run them through SHA-256 — a standard one-way hash function. The result is split into six 5-digit groups. Same math on both sides means matching numbers. No central server is involved; the calculation happens entirely on your devices.

People who care more about privacy than convenience. Journalists protecting sources. Activists in countries where SIM cards are registered to the state. Anyone who thinks a chat app shouldn't require handing over their phone number, location, and social graph to a corporation in exchange for basic communication.

Signal is the gold standard for protecting individuals — and we use the same core cryptographic protocol they invented (Double Ratchet, sealed sender, ECDH + AES-GCM). The differences:

What Signal does that we don't (yet): independent third-party security audits, decade of production hardening, billions of users worth of attack mitigation.

What we do that Signal doesn't: no phone number required, no real-world identity at all, constant-size packets, continuous cover traffic, rotating session tokens, randomized send delays, Tor hidden service. Signal protects individuals; Offline also protects relationships — the social graph an observer could otherwise reconstruct from network traffic.

Forward secrecy means each message gets its own encryption key, and old keys are destroyed after use. So if someone steals your phone tomorrow and extracts your current keys, they still can't read what you sent last week — those keys no longer exist. Combined with post-compromise security (the Double Ratchet), the inverse also holds: if your keys leak today, your future messages still become unreadable to the attacker as soon as the next key rotation happens.

Even with end-to-end encryption, an observer watching the network can see when you send messages and how often. That alone reveals a lot — whether you're online, whether you're talking to someone, who you're probably talking to. Cover traffic sends realistic-looking encrypted dummy packets in the background, so an observer can't tell when you're actually communicating versus idle. The recipient's app silently drops the dummies after decryption.

If you visit Offline through our .onion address using Tor Browser, your traffic goes through three encrypted hops before reaching us. We can't see your IP. Your ISP can't see what you're doing. It's the strongest network-level anonymity possible without running our own decentralized mixnet (which is on the roadmap). Available now to anyone who wants it; clearnet access stays the default for convenience.

Open Settings → Security & verification inside the app. You'll see a SHA-256 hash of the running app.html. Compare that hash with the one published on our GitHub release. If they match exactly, no one has tampered with the app between us and you. The whole client is one HTML file with no build step — every line is auditable in your browser's DevTools.

The basic messenger is free forever. Later, premium features (larger file transfers, multi-device sync, custom human-readable handles) may cost a small subscription. We will never run ads. We will never sell data. We have nothing to sell.

Your messages are gone. That's the tradeoff for having no cloud backup. If we can't read your messages, we can't restore them either. Your contacts can re-verify you with a new ID via safety-number comparison.

QR code, shared link, or typing someone's ID directly. The web app can generate a QR you scan in person. Your contact list lives only on your device.

Not in the MVP. Multi-device is planned but requires careful key distribution to avoid becoming a security hole. We'd rather launch one device done right than three done poorly.

A small team with backgrounds in smart contract security and cryptography. We've written audit reports on DeFi protocols holding hundreds of millions in user funds. We take privacy seriously because we know exactly what it costs when it fails.

The relay server will be open source at launch. Clients (web / iOS / Android) will be open-sourced in phases as they stabilize. We believe you can't claim to protect privacy with closed-source code.

You shouldn't. Trust the math. Trust the open-source code. Trust the warrant canary. We designed Offline so that trusting us isn't required — the server architecture genuinely cannot leak what it doesn't store.