Pulshade is designed so that the people who run it know as little as possible. Not because we promise to look away, but because there is very little for us to see.
Your account is just keys
When you open Pulshade for the first time, it makes your account on your device: a set of keys that come from 32 random bytes. There’s no phone number, email address or username to give, and nothing that identifies you is sent to us.
You get a recovery code. It’s the only way back into your account if you lose your device or forget your passcode. We never see it and can’t recover it for you, which is why the app asks you to write it on paper and never offers it for copying.
Your passcode seals the account on the device. It’s mixed with a secret only that device’s Secure Enclave can produce, so a copy of the file can’t be guessed at on another computer.
Every message, sealed twice
Each conversation runs through a Double Ratchet, a well-studied design used by modern secure messengers. In everyday terms:
- Every message has its own key, used once and then deleted. Someone who steals your device’s keys today can’t open the messages it already received.
- It heals itself. Every reply mixes in a fresh key exchange, so even after a theft, the next round of replies locks the thief out again.
- Nothing you say is signed. Your friend knows a message came from you, but can’t prove it to anyone else.
The encrypted message is then put in a sealed envelope that hides who sent it, padded to one of a few set sizes so its length says little. The server only ever sees sealed envelopes arriving at random mailboxes.
Reactions, typing dots, unsends, story views and disappearing timers all travel the same way, so the server can’t tell one from another.
Ready for quantum computers
Someone could record encrypted traffic today and hope to break it later with a quantum computer. Pulshade plans for that. Every chat starts with a handshake that combines a classical key exchange (X25519) with a post-quantum one (ML-KEM-768), so breaking one isn’t enough.
New post-quantum secrets keep being mixed in as you talk, about every 35 to 40 messages in a back-and-forth chat. They travel in small pieces inside ordinary messages, so no message is bigger than another. Envelopes, group keys and important control messages use post-quantum protection too.
Tor, built in
Encryption hides what you say. Tor hides where you are. Pulshade has Tor built into the app on both iPhone and Mac, so there’s nothing else to install.
The first time you open Pulshade, before anything connects, it asks how you want to connect:
- Tor. Pulshade’s server is reached as a Tor onion service, so no one learns where it runs, and the server sees a made-up address for each connection instead of your IP address. Each persona, inbox and call uses its own Tor circuits, so they can’t be tied together by address. If Tor can’t connect, requests fail; nothing quietly falls back to a direct connection.
- Fast. Skips Tor for speed. The app explains the cost first: the server then sees your IP address and roughly where you are, and your personas could be tied together by it. It doesn’t log your address, but on Fast you’re trusting it not to.
You can change this any time in Settings → Network. If your network blocks Tor, bridges disguise the first step: Snowflake looks like a video call, and webtunnel looks like ordinary web traffic. You can also paste your own private bridge.
Curious what the server sees? Settings → Network → Anonymity Report shows the address the server sees for you, the Tor circuits in use, and a checklist of the settings that matter.
What our server sees
Pulshade runs its own servers, and the official app talks to nothing else. The server is a small program built to know as little as possible.
What it can see
- That a sealed envelope arrived at a random mailbox
- When, and roughly how big (within a few set sizes)
- Public @handles and profiles, if you choose to have one
What it can’t
- What you say, send or share
- Who sent an envelope: there are no accounts and envelopes carry no sender
- Your IP address, when you use Tor
- Your contacts or your groups’ members
Envelopes are deleted once they’re collected, or after 30 days. While they wait they’re sealed on the server’s disk with keys the server holds only in memory, so a copy of the disk holds nothing that can be opened. The server keeps no request logs, and its rate limits use only a hash of an address with a salt that changes every hour.
Files you send (up to 100 MB) are sealed on your device, sealed a second time by the server, and erased when the message is deleted or after 30 days (7 in groups). The person you sent it to opens it from memory; it isn’t saved unless they choose “Save a copy”.
Friends, personas and handles
Adding a friend works by scanning a QR code in person, or sending a one-time invite link. Each invite works for one person and opens a fresh mailbox, so two contacts can’t compare invites to link you.
Pulse check lets you confirm you’re really talking to each other. You both see the same ten emoji, 30 digits, colours and QR code, made from both your keys. If they match, nobody is in the middle.
Personas are separate identities with their own keys, mailboxes, contacts and chats, each reaching the server over its own Tor circuit. A friend who knows two of your personas sees two unrelated people. A burner is a persona with a timer: when it ends, its keys, contacts and chats are destroyed and the other side is told to forget it.
@handles are optional. Claim one if you want people to find you. Lookups are by exact name only, with no listing or search, and a request waits for you to accept it before anything is set up.
One-time chats use a throwaway identity for both sides and end when you choose. You can share one as a 20-digit code to read out loud, so nothing has to pass through another app.
Groups and channels
A group posts each message once to a shared mailbox that every member reads, for up to 1,000 people. Inside a group, you’re known by a key made for that group alone, so the group can’t be tied to your profile or your other groups, and members never get each other’s mailboxes.
The group’s name, roles and member list are one signed document that only someone allowed can change. When someone is removed, everyone else gets a new key that person never sees. Someone who joins doesn’t get what was said before. Each member’s device keeps its own chain of keys that moves forward with every post, so someone who takes a member’s phone can’t open posts it had already read, beyond about the last hour.
In a channel, followers can’t see who else follows; only the channel’s staff keep that list.
Your devices
One account can be on your iPhone and your Mac. To link a device, the one you’re logged in on shows a QR code; the new one scans it, both screens show six digits to compare, and you approve.
Each device has keys of its own, made on it and never sent anywhere, and vouched for by your account. Your friends remember each device’s keys. If a new device appears on a friend’s account, their chat with you says so, and you can choose to hold your messages until you’ve allowed it. So even someone who got hold of a friend’s recovery code couldn’t quietly pose as one of their devices.
The sealed backup keeps your profile, @handles, contacts, groups, personas and settings on the server, sealed with a key only your recovery code can make. It never holds chats or chat keys, it isn’t tied to your account, and switching it off in Settings erases it at once.
On your device
- Chats live in an encrypted vault, kept out of backups. On iPhone, the files can’t be read while the phone is locked.
- Screenshots and screen recordings of Pulshade come out blank. On iPhone it also covers itself while the screen is recorded, mirrored or shared.
- Voice notes are recorded and played from memory, never saved as a file. Received files open from memory too.
- The message box has autocorrect off, so the keyboard doesn’t learn what you type.
- Notifications say only “New message” unless you choose otherwise.
- A decoy passcode opens a separate, empty account that looks like yours. A panic passcode quietly destroys the real account and opens an empty one. The disk always looks the same, so it doesn’t show whether either is set up.
Lock, Detach and Burn
All three are on the Burn tab.
- Lock closes the vault. Everything stays on the device, encrypted, until your passcode or Touch ID opens it again.
- Detach wipes this device at once, with no waiting on the network. Your other linked devices keep the account. Your profile, contacts and groups come back with the recovery code; chats on this device are gone for good.
- Burn deletes the account as if it never existed: every chat for both sides, every contact forgets you, every @handle is retired, the server’s backup and waiting messages are erased, and every device is wiped. It can’t be undone.
If you’re offline when you Burn, your device is still wiped at once. It keeps a signed order and sends it again until the server confirms.
Notifications on iPhone
iOS only wakes a closed app through Apple. With Wake when locked on (Settings → Notifications), when a message arrives the server asks Apple to wake your phone with a push that says only “New message”, nothing about who or what. Your phone then fetches and decrypts the message itself.
Apple learns that your iPhone was woken for Pulshade, and when. To register, the phone also contacts Apple outside Tor. If you need the strongest anonymity, turn it off; messages then arrive while Pulshade is open. Wake-ups are only used for your main identity, never a persona. The Mac doesn’t need them, because the app keeps running.
For experts
The design in brief. The apps are open source under the MIT License, so the details can be checked against the code.
- Identity
- A 32-byte random seed made on the device; every key is derived from it. The seed is sealed in
identity.lockwith PBKDF2-SHA256 (600,000 rounds) and AES-GCM, the key mixed with a Secure Enclave secret, and the whole file sealed again with a Keychain key that’s replaced on every lock. - Handshake
- Hybrid: three X25519 exchanges, two of them with ephemeral keys, plus ML-KEM-768. Each side’s device signs the handshake, and both device public keys go into the session root.
- Ratchet
- Double Ratchet with per-message keys and an X25519 step on every reply, for forward secrecy and post-compromise healing. A sparse post-quantum ratchet exchanges fresh ML-KEM-768 keys and ciphertexts in fixed-size, erasure-coded pieces carried in every message (random filler when there’s nothing to send); each completed exchange is mixed into the root key at the next chain, about every 35 to 40 messages in a back-and-forth chat.
- Envelopes
- Two seals around each ratchet message. The outer uses a fresh X25519 key and ChaCha20-Poly1305, padded to fixed sizes, and hides the sender’s agreement key. The inner mixes an X25519 exchange between both identity keys. Both also mix in an ML-KEM-768 secret for the recipient. Messages are deniable: the signing key vouches once for the agreement key, never for a message.
- Signatures
- Key setup and control messages are signed with both Ed25519 and ML-DSA, and both must verify. Once a contact’s post-quantum keys are known, nothing classical-only is accepted from them, so there’s no downgrade.
- Device keys
- Each device has its own Ed25519 and ML-DSA-65 keys from 32 random bytes that never leave it (sealed with a device-only Keychain key, excluded from backups and linking). The account signs each device’s public keys with both of its signing keys. Contacts pin each device’s keys on first proof; different keys under any id count as a new device, announced in the chat and optionally held.
- Mailboxes
- A mailbox is a secret receive key; senders write to its SHA-256 hash. Each invite opens a new mailbox and works once. Each persona and public inbox is fetched on its own connection and schedule.
- Groups
- One shared mailbox per group. Members appear under per-group keys. Each sender device keeps its own chain, started from fresh random bytes and advanced with every post; announce keys that let new readers follow a chain move forward every hour. Epoch keys are sealed with X25519 and ML-KEM-768 together. Removing a member starts a new epoch they never receive. The group document (name, roles, members) is signed and versioned.
- Files
- Sealed on the device in 1 MiB pieces with ChaCha20-Poly1305 under a fresh 256-bit key, each piece bound to its position. The key, id and an erase secret travel only inside the end-to-end encrypted message. The relay seals the pieces again under a per-file key and destroys that key on erase.
- Calls
- The call key travels only inside the encrypted chat. Each direction has its own key, every packet is numbered and replays are refused, and every packet is padded to the same size so speech patterns don’t show.
- Network
- Tor via Arti, built into the app and the server; the server is an onion service hosted inside itself. Every lane (each persona, inbox, sending, linking, each call) gets isolated circuits. Rate-limited requests carry a short, single-use proof of work so new circuits don’t buy new allowances. Bridges: Snowflake and webtunnel.
- Server storage
- Waiting envelopes are sealed in segment files with per-segment keys, indexed under a storage key held only in memory (never written to the server’s disk). Collected segments have their key forgotten and their file overwritten and deleted. No request logs; core dumps are off.
- Sealed backup
- Sealed with a key made only from the recovery code, filed under a throwaway public key derived from it, padded to a power of two (64 KB minimum), and re-saved at random intervals after changes. Holds no chat keys.
- Verification
- Pulse check: ten emoji (60 bits), 30 digits, colours and a QR code derived from both identities’ signing-key fingerprints and agreement keys.
Found a problem? Please report it privately.