Skip to content
docs usepoof.chat Create a quant-room

understand

  • Start here
  • Philosophy
  • How a quant-room works
  • Super Quant-Rooms & payment
  • Payments
  • The AI model
  • Relay nodes
  • Poof Secretz

explore

  • The quantum problem
  • Harvest now, decrypt later
  • Post-quantum & hybrid keys
  • Quantum Lab

verify

  • Security architecture
  • Data lifecycle
  • Threat model
  • Verify it yourself
  • Responsible disclosure

build

  • Developer guide
  • API reference

reference

  • Glossary
  • FAQ

brand

  • Brand book
  • Brand kit

Poof documentation

A chatroom that forgets.

Poof is a private chatroom that lives in a browser tab. No account, no phone number, no email. You open a quant-room, share it, talk. When the timer runs out, the quant-room is gone. Poof.

These docs explain what Poof is, why it exists, how it works, what it protects you from, what it does not, and how you can check every claim yourself.

Poof at a glance

WhatDetails
IdentityNone. No accounts, no email, no phone number, no username.
Quant-Room10 minutes, 2 people, text. Free.
Super Quant-Room1 hour or 24 hours, up to 10 people, files up to 2 MB, an optional uncensored AI model. From $0.49, paid from a wallet. More
PaymentUSDC on Ethereum, Base or Solana, or USDG on Robinhood Chain. A blind-signed one-time pass keeps the payment and the room apart. More
AI modelOptional, in a sealed hardware enclave. Your browser encrypts the conversation straight to it. More
JoiningA link, a QR code or a four-word phrase.
EncryptionEnd-to-end, in your browser: AES-256-GCM with a hybrid key (the link's key + ML-KEM-768). More
TransportDirectly between browsers over WebRTC. Poof's servers never carry your messages.
StorageNo messages are stored anywhere. Quant-room state on the server is deleted when the room ends. More
TransparencyOpen source (MIT), with signed builds you can verify. More

Read at your own depth

  1. Understand. What Poof is and why. Philosophy, How a quant-room works, Super Quant-Rooms & payment, Payments, The AI model, Relay nodes, Poof Secretz.
  2. Explore. Why quantum computers matter to a chat app. The quantum problem, Harvest now, decrypt later, Post-quantum & hybrid keys, Quantum Lab.
  3. Verify. How it is protected, and how to check. Security architecture, Data lifecycle, Threat model, Verify it yourself.
  4. Build. The protocol, step by step. Developer guide, API reference.
nextPhilosophy
The HostOpens the door, then gets out of the way.

on this page

  • Poof at a glance
  • Read at your own depth

About & philosophy

Less data, by design.

Privacy is not only about hiding information. It is also about reducing how much information exists in the first place.

Storage is cheap, so most of the internet keeps everything, just in case. Every message, contact list and login stays on someone's server for years. Each of those copies is something that has to be protected, forever.

MORE DATA ──▶ MORE STORAGE ──▶ MORE METADATA ──▶ MORE ATTACK SURFACE ──▶ MORE TO PROTECT, FOREVER

Poof starts from the opposite default. A conversation exists for as long as people are having it, and not much longer.

LESS DATA ──▶ LESS RETENTION ──▶ SMALLER ATTACK SURFACE ──▶ LESS LONG-TERM EXPOSURE

Honest footnote

Keeping less does not make a system secure on its own. It removes some risks completely: a breached database, a subpoena for old messages, someone decrypting an archive years from now. Other risks stay exactly where they were, like a compromised phone or someone taking a screenshot. The threat model lists both.

Privacy is not the same as security

IdeaThe question it answers
PrivacyWho can learn things about me?
SecurityCan someone without permission read or change my data?
ConfidentialityWho can read the content?
IntegrityCould it be changed without anyone noticing?
AuthenticityCan I tell who really sent it?
AnonymityCan this activity be tied to a real person?
EphemeralityHow long does any of it exist?

Poof is built around confidentiality and ephemerality. It helps with privacy because it never asks who you are. It is not an anonymity tool on its own: the network still sees which IP addresses connect, and when.

Create, use, expire, poof Concept

Grass grows, exists for a season, then returns to the soil. Nothing about it is meant to last forever, and that is not a flaw. Poof treats a conversation the same way.

NATURE                      POOF
──────                      ────
seed            ──▶         create quant-room
grow            ──▶         people join
exist           ──▶         messages are used
change          ──▶         timer runs down
return          ──▶         quant-room state disappears · poof

An analogy, not a security proof. What actually expires, and where, is described in Data lifecycle.

Why “Poof”?

Because that is what the quant-room does at the end.

previousStart herenextHow a quant-room works
The SleeperShows up whenever something has expired.

on this page

  • Privacy is not the same as security
  • Create, use, expire, poof
  • Why “Poof”?

How it works

The life of a quant-room.

From the moment you press “Create Quant-Room” to the moment it disappears: what your browser does, what Poof's server does, and what nobody ever gets to see.

Lifetime
10 minutes
People
2
Messages
Text, up to 5,000 characters
Price
Free
Encryption
Hybrid post-quantum, end-to-end
Account
None. Ever.
  YOU                          POOF SERVER                       GUEST
   │                                │                              │
   │  1  create quant-room ─────────▶│  id + expiry, short-lived     │
   │  2  your browser makes the     │                              │
   │     quant-room key (never sent)│                              │
   │  3  share: link · QR · 4 words ─────────────────────────────▶ │
   │◀──── 4  signaling relay: "how to reach each other" ─────────▶│
   │                                │   (no keys, no messages)     │
   │◀═══════════ 5  direct encrypted channel (WebRTC) ═══════════▶│
   │◀═══════════ 6  post-quantum key exchange (ML-KEM-768) ══════▶│
   │◀═══════════ 7  talk: every message encrypted in-browser ════▶│
   │                                │                              │
   │                8  timer ends ─▶ quant-room state deleted ─▶ poof

1 · Create

When you press Create Quant-Room, your browser first makes a random 32-byte creator secret. It keeps the secret in this tab and sends Poof's server only its SHA-256 fingerprint. The server answers with a fresh quant-room id (16 random bytes) and the moment the quant-room ends, 10 minutes later.

Only after that answer does your browser generate the quant-room key: 32 random bytes from the browser's own Web Crypto API. The key is made in your tab, after the server has already spoken, so there is no request it could ever travel in.

Anatomy of a quant-room link

usepoof.chat/join/#Q2xL…4yHg.k9Fz…7wQe

usepoof.chat/join/   ──▶  WEB PAGE        loads the app
#Q2xL…4yHg           ──▶  POOF SERVER     room id, 22 characters: finds the room
.k9Fz…7wQe           ─ ─  THIS TAB ONLY   quant-room key, 43 characters: never sent

Everything after the # is the link's fragment. Browsers never put the fragment in a request. Your browser reads the room id from it and tells Poof's server which room to open, but the key next to it stays in the tab. Poof's server never receives the key, so it can never read the quant-room.

the creator secret is not in the link

Only the browser that created the quant-room holds it, in its local storage, and only until the quant-room ends. That's how the server knows who may press Poof it now, even after a reload, without ever knowing who you are. The quant-room key is kept apart from it, in this tab only.

Create a quant-roomengine API
import {
  createRoom, RoomSession, browserSocketFactory, browserRtcFactory,
} from "/engine/poof-engine.js";

const API = "https://api.usepoof.chat";

// Ask for a quant-room. The key is generated here, after the server answers.
const room = await createRoom({ fetch, origin: API });
room.path;        // "/join/#<22-character id>.<43-character key>"
room.ownerSecret; // stays in this tab: it's what "Poof it now" proves

// Join it and follow the status.
const session = new RoomSession({
  roomId: room.roomId,
  roomKey: room.key,
  origin: API,
  appOrigin: location.origin,
  ownerSecret: room.ownerSecret,
  fetch: fetch.bind(window),
  createSocket: browserSocketFactory,
  createPeerConnection: browserRtcFactory,
});
// waiting → connecting → sealed
session.subscribe((state) => console.log(state.status));
await session.start();

2 · Invite

MethodHowTrade-off
LinkSend the full link through a channel you trust.The key travels inside the link. Anyone who sees the link can join, so share it privately.
QR codeYour guest scans your screen in person.The key never touches the network.
Four wordsPress Show a phrase and read it out, like orbit velvet tunnel cabin.Works once, and only for 3 minutes. Made for a phone call, not for a chat history.

How four words become a link

ORBIT VELVET TUNNEL CABIN   4 of 2,048 words · 44 bits
        │
        ▼
PBKDF2-SHA-256              200,000 rounds, in your browser
        │
        ▼
ADDRESS + LOCK KEY          both come from the same slow derivation
        │
        ▼
LOCKED LINK                 AES-256-GCM, kept by Poof · one read, 3 minutes max
        │
        ▼
OPENED · POOF               the first reader takes it, then it's gone

The four words come from a fixed list of 2,048 everyday words, so a phrase holds 44 bits of chance. Your browser stretches it with PBKDF2-SHA-256 over 200,000 rounds and splits the result into two things: a mailbox address and a lock key. It locks the quant-room link with AES-256-GCM and leaves only the locked copy at that address.

Your guest types the same four words, in any case, separated by spaces, dashes or commas. Their browser repeats the derivation, finds the mailbox and opens it. Opening it empties it on the spot, and an unread mailbox disappears after 3 minutes. Poof's server sees an address and a locked blob, never the words: every guess would cost 200,000 rounds across about 17.6 trillion possible phrases, far longer than a phrase lives.

The opened link must point to usepoof.chat and be a well-formed quant-room link, so a tampered mailbox can't send your guest anywhere else.

Share with four wordsengine API
// You: put the link behind a fresh phrase (one use, 3 minutes).
const { code, expiresAt } = await session.createPhrase();
code; // "orbit-velvet-tunnel-cabin"

// Your guest: turn the words back into the link, then open it.
const path = await joinByPhrase({
  fetch, origin: API, appOrigin: location.origin,
  code: "Orbit velvet tunnel cabin",
});
location.assign(path); // "/join/#<id>.<key>"

3 · Connect

WAITING ──▶ CONNECTING ──▶ SEALED ──▶ POOF
alone       handshake       chat on        wiped

To find each other, the two browsers swap connection details through Poof's server. This is signaling: the server relays them, stamps who sent what, and stores none of it. It also holds the door. A Quant-Room has two seats, the server decides who gets one, and a third visitor is turned away.

Once a direct WebRTC data channel is open, the browsers run a post-quantum key exchange over it, mix the result with the quant-room key, and prove to each other that they arrived at the same keys. Only then does the quant-room switch to sealed and the message box opens. If the proof fails, the connection is refused instead of downgraded.

If the two networks can't reach each other directly, traffic goes through a relay over TLS. The relay forwards encrypted bytes it can't read, and its credentials are issued only once two people are paired and stop working when the quant-room ends.

StatusWhat you seeWhat's happening
waitingYour link, QR code and phrase buttonYou're in the quant-room alone. The server knows a seat is taken.
connectingYour guest arrivedThe browsers are finding a route to each other.
connectedA moment moreThe direct channel is open and the post-quantum key exchange runs.
sealedThe message box is openBoth browsers confirmed the same hybrid keys. Everything from here on is encrypted.
ended“Poof.”Someone left, the creator ended it, or the timer ran out. See below.

Opened the link inside Instagram, Facebook or TikTok? Their built-in browsers can run their own code in every page they show. Poof spots the common ones and suggests opening the link in your real browser.

4 · Talk

Every message is encrypted in your browser with AES-256-GCM before it leaves, using a key that only travels in your direction, and it carries a sequence number. Your guest's browser checks that number: a message that was altered, replayed, dropped or reordered closes the connection instead of slipping through. Poof's servers are not on the message path at all.

Messages hold up to 5,000 characters. Each person gets a default name, like Amber Fox, that looks the same on both screens until they pick their own (up to 32 characters). The “typing…” hint travels the same encrypted way and carries no text. The developer guide shows every byte of a message on the wire.

Talkengine API
await session.sendMessage("hi"); // encrypted here, then sent
session.setTyping(true);            // a hint, no text
session.setNickname("Ana");         // travels only over the encrypted link

5 · Poof

What happensThe conversationPoof's server
Your guest leavesWiped from your screen at once, input switched offFrees the seat. The quant-room still ends on its timer
Someone reloads the pageKept for 30 seconds while they come back. Nobody else can take the seatLets the same browser back in
The creator presses Poof it nowEnds for both of youDeletes the quant-room at once
The creator removes the guestKept for the creator, who goes back to waitingKeeps that guest out for good
The timer runs outThe connection closes. What's on your screen stays readable until you leave the pageDeletes everything it held about the quant-room

After that, opening the link only shows that the quant-room no longer exists. There is no archive and no backup to recover it from.

Leave or end itengine API
await session.leave();   // anyone: leave, the other side is told
await session.destroy(); // creator only: "Poof it now", for everyone

What the server knows

SeesNever sees
That a quant-room exists, how many seats it has and when it endsThe quant-room key
The fingerprint of the creator secretThe creator secret itself
IP addresses while people connect, used only to count requests and never storedMessages, names or typing hints
Roughly when people connectWho you are: there's no account, email or phone number

Limits

WhatLimit
People2, decided by the server
Lifetime10 minutes
Message5,000 characters
New quant-rooms5 per minute from one address
Joining10 attempts per minute from one address
Four-word phraseOne use, 3 minutes

Need more time, more people or files? That's a Super Quant-Room.

previousPhilosophynextSuper Quant-Rooms & payment
The KeeperHolds the keys. Never hands them to the server.

on this page

  • 1 · Create
  • 2 · Invite
  • 3 · Connect
  • 4 · Talk
  • 5 · Poof
  • What the server knows
  • Limits

Quant-rooms

When ten minutes isn't enough.

A Super Quant-Room gives the conversation more time, more seats, files and an optional AI model. The privacy architecture is exactly the same: keys made in your browser, messages encrypted end-to-end, nothing kept.

Lifetime
1 hour or 24 hours
People
2 to 10, or just you with the AI
Messages
Text and files up to 2 MB
AI model
Optional, uncensored
Price
From $0.49
Account
None. Ever.
Quant-RoomSuper Quant-Room
Lifetime10 minutes1 hour or 24 hours
People22 to 10, or 1 with the AI model
MessagingTextText and files
EncryptionHybrid post-quantum, end-to-endHybrid post-quantum, end-to-end
Creator toolsPoof it now, remove the guest, pin a messageThe same, plus upgrade
Uncensored AI modelNoOptional: +$2 for 1 hour, +$5 for 24 hours
CostFreeFrom $0.49, paid from a wallet

What it costs

You pay once, for one quant-room. The price depends on how long it lives and how many seats it has.

Lifetime
$0.588 $0.49 for two + 2 × $0.049
LifetimeFor twoEach extra personAI model
1 hour$0.49+ $0.049+ $2
24 hours$1.49+ $0.009+ $5

Ten people for 24 hours cost $1.562. With the AI model you can also open a quant-room just for yourself.

Two ways in

Start super. On usepoof.chat pick Super Quant-Room, choose the lifetime and the number of people, pay, and the quant-room opens already unlocked.

Upgrade on the way. Already talking in a free Quant-Room and the timer is running low? The creator presses Upgrade quant-room, pays, and the room changes in place. Same link, same keys, same conversation. Everyone inside is told, the new lifetime counts from the moment of the upgrade, and the number of seats only ever goes up.

QUANT-ROOM ──▶ PAY ──▶ ONE-TIME PASS ──▶ SUPER QUANT-ROOM
10 min · 2     wallet  blind-signed       1 h or 24 h · up to 10
                                          same link, same keys
Create or upgrade with a passengine API
// A new Super Quant-Room: the pass decides lifetime and seats.
const room = await createRoom({ fetch, origin: API, pass });

// Or upgrade the quant-room you're in (creator only).
await session.upgrade(pass);
session.getState().expiresAt; // now + 1 hour or 24 hours

How a group stays private

        YOU ════ ANA
       ╱  ╲    ╱  ╲
     KAI ═══╳═══ LEO        every pair has its own encrypted link
       ╲  ╱    ╲  ╱         no group key, no server in the middle
        SAM ════ MIA
one message to 5 people = 5 separate encryptions

There is no group key. Every pair of people in a Super Quant-Room builds its own direct connection and runs its own post-quantum handshake, exactly as in a Quant-Room for two. When you send a message, your browser encrypts it once for each person, with that pair's keys, and sends it down each connection. Ten people means 45 separate encrypted links.

Poof's server still only holds the door: it decides who gets one of the paid seats, and nobody can squeeze in once the room is full. People can leave and come back while the room lives. The quant-room goes on until its timer ends or the creator ends it. If two people briefly see a different list of who's inside, for example while someone is still joining, the room shows it instead of hiding it.

Files

photo.jpg · 2 MB ──▶ ▪▪▪▪▪▪▪▪ ──▶ ▪▪▪▪▪▪▪▪ ──▶ GUEST
                     16 KiB      each piece     SHA-256 checked
                     pieces      encrypted      delivered

Drop files onto the chat or pick several at once. Images show a preview right in the conversation. Each file is cut into pieces of 16 KiB, every piece is encrypted on its own and travels over a separate encrypted channel for files, to each person in the room. The receiving browser checks the size, the number of pieces and finally the SHA-256 fingerprint of the whole file. Only then does it show as delivered.

RuleValue
Size per fileUp to 2 MB
Piece size16 KiB, so a 2 MB file is 128 pieces per person
OrderOne file at a time in each direction, the rest wait in line
CancelThe sender or the receiver can stop a transfer at any time
Where it goesBrowser to browser, or through the relay when a direct path is blocked. Always encrypted, never stored on a server

Saved a file? That copy is yours now and stays on your device after the quant-room is gone. Everything you didn't save disappears with the room.

Send a fileengine API
const fileId = await session.sendFile(input.files[0]); // encrypted per person
session.abortTransfer(fileId);                          // stop it, for everyone

Creator tools

ToolWhat it does
Poof it nowEnds the quant-room for everyone. Poof's server deletes it at once.
Remove someoneThe server disconnects that person and keeps them out for the rest of the room's life. Everyone drops their link to them.
Pin a messageHover a message and press the pin. One pinned message for everyone, shown again to people who join later. It travels encrypted, like any message.
Upgrade quant-roomMore time and more seats, without leaving the room.

The creator proves who they are with the creator secret kept in their tab, never with an account. Everyone gets a default name like Amber Fox and can pick their own. Type / in the message box for the shortcuts:

CommandWhoWhat it does
/name new nameEveryoneChange your name
/ban nameCreatorRemove someone from the quant-room
/unpinCreatorTake down the pinned message
Creator toolsengine API
session.ban(peerId);        // remove someone, for good
session.pin(messageId);     // pin a message for everyone
session.pin(null);          // unpin
await session.destroy();   // Poof it now

An uncensored AI model

When you create a Super Quant-Room you can add an uncensored AI model to it. Talk to it alone, in a quant-room just for you, or bring it into a group: in a room with other people, start a message with @ai to ask it something.

The model runs inside a sealed hardware enclave (Intel TDX) hosted by an AI infrastructure partner. Your browser encrypts the conversation straight to the enclave. Poof's servers only pass the encrypted text along, and nobody outside the enclave, Poof included, can read it.

YOUR BROWSER ──▶ checks the enclave's proof ──▶ encrypts to the enclave
      │
      ▼
POOF SERVER: passes ciphertext along, can't read it
      │
      ▼
ENCLAVE (Intel TDX): reads, answers, encrypted back to you
      │
      ▼
the answer goes to everyone over the room's encrypted links

Before anything leaves your browser, it asks the enclave for a fresh proof of what it is running, checks that the proof covers the model's key, and only then encrypts to that key. The answer streams back encrypted to your browser, which decrypts it and shares it with everyone in the room over the same encrypted links as any message.

what changes with the AI on

To answer, the model has to read. When someone asks it a question, their browser sends the recent conversation along with it, so the model sees what was said in the room. It keeps no logs and no memory between quant-rooms, and it leaves when the timer ends. Without the AI, nothing changes: no server ever sees your messages. One honest limit: your browser checks what the enclave's proof says, while Intel's signature on that proof is confirmed by the hosting partner, not yet by your browser.

Limit1 hour24 hours
Questions per quant-room150600
Questions per minute1010
Longest answer1,024 tokens1,024 tokens

A question the model never answered doesn't count against the room. More on the AI model page.

How payment works

STABLECOINS ──▶ ONE-TIME PASS ──▶ SUPER QUANT-ROOM ──▶ TIMER ENDS ──▶ POOF
USDC · USDG     blind-signed      same encryption,
to Poof's wallet                  same nothing-kept

Poof doesn't need to know who you are to give you more. You pay from a wallet, on one of four networks:

NetworkPay with
EthereumUSDC
BaseUSDC
SolanaUSDC
Robinhood ChainUSDG

The price on the site is the amount you send: every token is a dollar stablecoin, paid at face value. On a computer, pay from the wallet in your browser. On a phone, Ethereum, Base and Robinhood Chain wallets connect by scanning a code; for Solana, open this site inside your wallet's own browser (Phantom, Solflare).

The payment and the quant-room stay apart through blind signatures. Before you pay, your browser prepares a random one-time pass and “blinds” it. After the payment, Poof signs the blinded pass without being able to see it, and your browser unblinds it. When you spend the pass, Poof can check its own signature, but it has never seen that pass before, so it can't tell which payment the quant-room came from. Each pass works exactly once.

where the money goes

Every payment goes to Poof's treasury on the network you paid on: 0x68222E6dC73e161045233B2b76a47d98F84A7e8C on Ethereum, Base and Robinhood Chain, AGQzMmBEgxTeLonpt11isEu6KBDv4h3VbPofCEy4i8Et on Solana. Once POOF is listed, the whole amount buys back POOF and burns it.

Payments are public on the blockchain, like any transfer: your wallet and the amount can be seen there. What nobody can see is which quant-room that payment opened. Every step is on the Payments page.

previousHow a quant-room worksnextPayments
Super Quant-Room unlockedMore time, more people. Same privacy.

on this page

  • What it costs
  • Two ways in
  • How a group stays private
  • Files
  • Creator tools
  • An uncensored AI model
  • How payment works

Quant-rooms

Pay without an account.

A Super Quant-Room is paid from a wallet, with no sign-up and no profile. Blind signatures keep the payment and the quant-room apart, so Poof can tell that someone paid, but not which room that payment opened.

Networks
Ethereum, Base, Solana, Robinhood Chain
Pay with
USDC or USDG
Account
None. Ever.
What you get
A one-time pass
Link to the room
None, by design
Test networks
Never
YOUR BROWSER                     POOF SERVER                  BLOCKCHAIN
1  make a pass, blind it
2  wallet pays Poof's treasury ───────────────────────────────▶
3  wallet signs: payment + blinded pass ──▶
4                                  reads the payment ─────────▶
5  ◀────────── blind signature
6  unblind: a pass Poof has never seen
7  spend the pass ───────────────▶ Super Quant-Room · pass used up

Step by step

1 · Choose

Pick the lifetime, the number of people and, if you want it, the AI model. That choice is the pass's variant, for example “1 hour, 4 people”. See what it costs. Your browser makes a random pass for that variant and blinds it before anything else happens.

2 · Pay

Connect a wallet: the one in your browser, or, on Ethereum, Base and Robinhood Chain, a phone wallet through WalletConnect. On Solana, a phone pays from the wallet's own browser. The wallet sends the price to Poof's address on the network you picked.

NetworkPay withCounts after
EthereumUSDC2 confirmations
BaseUSDC1 confirmation
SolanaUSDCFinality, about 15 seconds
Robinhood ChainUSDG1 confirmation

Every token is a dollar stablecoin with six decimals, paid at face value: the price on the site is exactly the amount sent. Only mainnet payments count, never a test network.

3 · Prove it's your payment

Anyone can see a transaction on the blockchain, so seeing it isn't proof that you made it. Your wallet signs one short message that ties the payment to your blinded pass:

What your wallet signsexact text
Poof: unlock a Super Quant-Room
Chain: base
Transaction: 0x…your transaction…
Quant-room: 3600-4
Pass: <fingerprint of your blinded pass>

Poof checks that the signature comes from the wallet that paid (on Solana, the wallet signs the same text with its own key). Someone who copies your transaction id can't use it: they don't have your wallet to sign with. 3600-4 means 1 hour (3,600 seconds) for 4 people; a variant with the AI model ends in -ai.

4 · Get the pass

Poof reads the payment straight from the blockchain. While it's still confirming, the answer is “pending” and your browser simply asks again. Once it counts, Poof signs your blinded pass, without being able to see it, and your browser unblinds the signature. Now you hold a pass that Poof can recognise as its own, but has never seen.

5 · Spend it

Your browser uses the pass to create a Super Quant-Room, or to upgrade the one you're in. Poof checks its signature, records that this pass is used up, and opens the room. Each pass works exactly once.

Paying, from the browserengine API
// Treasury, networks and the pass keys.
const cfg = await fetchPayConfig({ fetch, origin: API });

// 1 hour, 4 people: a random pass for it, blinded.
const variant = { lifetime: 3600, people: 4, ai: false };
const pending = await startPass(cfg.keys, variant);

// The wallet pays cfg.treasury, then signs:
const text = await paymentMessage("base", txHash, pending);

let out;
for (;;) {
  out = await redeemPayment({ fetch, origin: API, chain: "base", token: "USDC",
                              txHash, pending, payer, signature });
  if (out.status !== "pending") break; // else: still confirming
  await new Promise((r) => setTimeout(r, 5000));
}

const room = await createRoom({ fetch, origin: API, pass: out.pass });

How a blind signature works

PASS ──▶ BLINDED ──▶ SIGNED, STILL BLIND ──▶ UNBLINDED PASS + SIGNATURE ──▶ USED ONCE
random   your browser  Poof signs without     only your browser            Poof knows it's real,
         hides it      seeing it              can do this                  not where it came from

Picture a letter sealed in an envelope lined with carbon paper. Poof signs the outside of the envelope after checking your payment. The signature presses through onto the letter, but Poof never sees the letter. Later you show the letter on its own: the signature on it is clearly Poof's, yet Poof has no way to tell which envelope it signed.

In technical terms, Poof uses RSA blind signatures (RFC 9474, the RSABSSA-SHA384-PSS-Randomized variant), with one signing key per variant, so a pass is worth exactly what was paid for it. Each key's id is its own fingerprint, and your browser checks it, so a key can't be passed off under another key's name. The blinding factor, the one secret that could connect the two ends, never leaves your browser.

What Poof keeps

Kept, per paymentNever kept
Network and transaction hashWhich quant-room the payment opened
Token, variant, price and the amount that arrivedThe pass itself before it's spent
Status: issued or underpaidThe blinding factor
A fingerprint of the blinded pass, so a retry gets the same answerNames, emails or accounts (there are none)

When a pass is spent, Poof stores only a fingerprint of it, to refuse it a second time. Your browser keeps a payment in progress and any unused passes in its local storage, so a reload doesn't lose what you paid for. Clear your browser data before spending a pass and it's gone from there.

When something goes wrong

What happenedWhat you seeWhat to do
The payment is still confirming“Pending”Wait, it picks up by itself
Less arrived than the priceThe price and what arrivedWrite to us with the transaction
The payment is more than a day old“Older than a day”Write to us with the transaction
You signed with a different wallet“Came from another wallet”Sign with the wallet that paid
The pass got lost before you used itNo pass in this browserThe same payment can be redeemed for a new pass once

Write to contact@usepoof.chat with the network and the transaction hash. That's all we need, and all we'll ask for.

Where the money goes

Poof's treasury

0x68222E6dC73e161045233B2b76a47d98F84A7e8C

The same address on Ethereum, Base and Robinhood Chain.

AGQzMmBEgxTeLonpt11isEu6KBDv4h3VbPofCEy4i8Et

On Solana. Every payment goes to one of the two, and anyone can follow them on the blockchain. Once POOF is listed, the whole amount buys back POOF and burns it.

What it doesn't hide

  • The payment itself is public. Your wallet, the amount and the time are on the blockchain for anyone to see, like any transfer.
  • The variant is visible. A pass shows what it buys, for example 24 hours for 6 people. If few people buy that exact kind, it narrows things down.
  • The keys are Poof's word. Poof publishes one key per variant at api.usepoof.chat/api/pay/config. A dishonest server could, in principle, hand someone a key of their own to recognise them later. Anyone can compare the published keys with what others see.
  • Timing can hint. Spending a pass seconds after paying, on a quiet day, makes the two easier to match up. Waiting a while before you use it helps.
previousSuper Quant-Rooms & paymentnextThe AI model
The KeeperTakes the payment. Never learns the room.

on this page

  • Step by step
  • How a blind signature works
  • What Poof keeps
  • When something goes wrong
  • Where the money goes
  • What it doesn't hide

Quant-rooms

An AI in the room.

Any Super Quant-Room can include an uncensored AI model. Talk to it alone, or ask it something in the middle of a group conversation. It answers, and when the timer ends it leaves with everything else.

Where it runs
A sealed hardware enclave (Intel TDX)
Who can read
Only the enclave
Price
+$2 for 1 hour, +$5 for 24 hours
Questions
150 per 1-hour room, 600 per 24-hour room
Memory
None between quant-rooms
Logs
None

The model runs inside a sealed hardware enclave (Intel TDX) hosted by an AI infrastructure partner. Your browser encrypts the conversation straight to the enclave. Poof's servers only pass the encrypted text along, and nobody outside the enclave, Poof included, can read it.

How to use it

Quant-roomHow you ask
Just you and the AIEvery message goes to the model. Open one by choosing 1 person with the AI model.
A group with the AIStart a message with @ai. Other messages are never sent to the model on their own, but recent ones travel along as context when someone asks.
In a groupexample
Ana        are we still on for saturday?
Amber Fox  yes, but where?
Ana        @ai three quiet places for a long lunch in Cluj, one line each
AI         1. ... 2. ... 3. ...    ← everyone in the room sees the answer

The answer streams in for the person who asked. When it's complete, their browser shares it with everyone in the room over the same encrypted links as any other message.

How a question travels

YOUR BROWSER                    POOF SERVER                  ENCLAVE
1  ask for a fresh proof ───────────────────────────────────▶
2  ◀────────────────────────────────────── proof + model key
3  check the proof
4  question, encrypted to the enclave ─────────────────────▶   (Poof sees ciphertext only)
5  ◀───────────────────────────── answer, encrypted to you
6  decrypt, share with the room

1-3 · The proof comes first

Before a single word leaves your browser, it sends the enclave 32 fresh random bytes and asks for a proof of what it is. The proof comes back signed into the hardware's own report, and your browser checks it:

  • it's a report from an Intel TDX enclave;
  • the enclave doesn't run in debug mode, where its memory could be read;
  • the report contains the model's key, so that key lives inside this enclave;
  • the report contains your 32 random bytes, so it was made just now, for you;
  • it's the model Poof uses, and nothing else.

If any check fails, nothing is sent.

4-5 · Encrypted both ways

Your browser encrypts the question to the model's key with a fresh one-time key for every message (elliptic-curve key agreement, HKDF-SHA-256 and AES-256-GCM). It also sends a temporary key of its own, and the enclave encrypts every piece of the answer to it. Poof's server forwards the ciphertext both ways and turns away anything that isn't encrypted. Your browser does the same: an answer that arrives unencrypted is refused.

Who may ask

Anyone who is in the quant-room. Each browser derives an AI token from the quant-room key, and the creator registers only the token's fingerprint with Poof. Poof can check that a question comes from someone with the link, without ever learning the key.

What the model sees

To answer well, the model needs the conversation. With each question, the asking browser sends the recent messages along, oldest dropped first, up to about 120 KB of text, with each line marked by the speaker's name. Poof's instructions to the model are public and only explain the format:

The model's instructionsexact text
You are the AI in a private, temporary group chat.
Messages from people are prefixed with their name, like "Ana: ...", and your
own earlier answers with "AI: ...". Answer the latest message, which is
addressed to you. Reply in the language it was written in. Be direct and
concise unless asked for detail. You have no memory beyond this conversation
and no access to the internet.

There are no other rules on top. What “uncensored” means is the model's own behaviour.

Limits

Limit1 hour24 hours
Questions per quant-room150600
Questions per minute1010
Longest answer1,024 tokens1,024 tokens
Conversation sent alongAbout 120 KBAbout 120 KB

A question the model never answered is given back to the room's count.

What it doesn't promise

the AI reads what it's asked about

Turning the AI on is a choice to let a model read the conversation it's asked about. Without it, no server ever sees your messages. With it, the enclave does, for as long as it takes to answer.

  • The proof is checked in part by the partner. Your browser checks what the enclave's report says. Intel's signature on that report, and which exact software image the enclave runs, are confirmed by the hosting partner, not yet by your browser.
  • Answers are shared. In a group, everyone in the room sees every answer.
  • Models get things wrong. Treat answers as you would any other message: useful, not authoritative.
previousPaymentsnextRelay nodes
The WatcherChecks the proof before a word leaves.

on this page

  • How to use it
  • How a question travels
  • What the model sees
  • Limits
  • What it doesn't promise

Network

Relay nodes.

Most quant-rooms connect browser to browser. When a network won't allow that, a relay carries the encrypted traffic between you. It forwards bytes it can't read. Relay nodes are the next step: more independent relays, run by more operators, under the same rule.

coming next

Relay nodes aren't live yet. Everything under Relays today is how Poof works right now. Relay nodes describes the next feature we're building, and this page changes when it ships.

First choice
A direct link, browser to browser
Relay used
Only when a direct link fails
Transport
TURN over TLS only
Credentials
Issued once two people are paired
Credentials last
Until the quant-room ends, 24 hours at most
The relay sees
IP addresses, timing, volume

Relays today

Two different things in Poof are called a relay. Neither one ever holds a key.

RelayWhat it carriesWhat it never carries
Signaling, on Poof's serverConnection details: offers, answers and network candidates. The server stamps who sent what and keeps none of it.Messages, files, names, keys. Chat never falls back to this path, not even when a link fails.
Traffic relay (TURN)Your encrypted traffic, when two browsers can't reach each other directly.Anything readable. It forwards encrypted bytes and has no key to open them.

Direct, or via a relay

YOU                          RELAY                         GUEST
1  try a direct path ──────────────────────────────────────▶
2                                         blocked by the network
3  encrypted, inside TLS ──▶
4                                  ──▶ forwarded as it is
5                                  ◀── answer, encrypted
6  ◀── forwarded as it is
7  sealed · via relay

Every link tries a direct path first. Each browser learns its public address from a STUN server, and the two swap candidates through the signaling relay. If a direct pair works, traffic goes straight from one browser to the other.

Some networks don't allow that: strict office firewalls, some mobile carriers, routers that change your address for every connection. Then the link goes through the relay. Poof only hands out the relay's TLS address, so relayed traffic looks like ordinary encrypted web traffic on the wire.

What the quant-room shows

Once a link is sealed, the status line says sealed · direct or sealed · via relay. Your browser reads which network path the connection picked. If either side goes through the relay, or it can't tell, it says relay: the careful answer. The two browsers also tell each other what they saw, and relay wins. In a group, one relayed link is enough for the quant-room to say via relay.

Read the pathengine API
session.subscribe((state) => {
  if (state.status !== "sealed") return;
  // "direct", or "relay" if any link uses one
  const relay = state.connectionType === "relay";
  show(relay ? "sealed · via relay" : "sealed · direct");
});

Credentials that run out

  • Relay credentials are issued only when two people are paired, never from a public endpoint.
  • They last as long as the quant-room has left: at least 60 seconds, at most 24 hours. Nobody holds a working relay credential after the quant-room is gone.
  • When a quant-room becomes a Super Quant-Room, everyone gets fresh credentials for the new end time, and relayed links reconnect with them before the old ones run out.
  • Only TLS relay addresses are handed out. Plain UDP and TCP relay addresses are dropped.

If relay credentials can't be issued within 3 seconds, the quant-room carries on with direct links only. On networks that allow a direct path nothing changes. On networks that don't, people can't connect until the relay answers again.

What a relay can and can't do

A relay canA relay can't
See the IP addresses of both endsRead messages, files or names. They travel inside DTLS and, inside that, Poof's own AES-256-GCM frames, under a key made with ML-KEM-768 that the relay never sees.
See when you're connected and how much traffic goes throughChange a message. Every frame is numbered and authenticated, so an altered, replayed, dropped or reordered frame closes the link.
Stop forwardingGet a key, or turn a relayed link into a weaker one. A failed handshake refuses the connection; it's never quietly downgraded.

Files follow the same limits direct or via the relay.

Relay nodes: what comes next

coming next

Not live yet. Today every relayed connection goes through one infrastructure provider.

One provider means one place that sees which IP addresses talk through it, and one dependency if it has a bad day. Relay nodes spread that out: independent relays, run by more operators, so no single company carries all of Poof's relayed traffic.

What won't change

These hold because of how the encryption works, not because of who runs the relay:

  • A node forwards encrypted bytes. End-to-end encryption and the hybrid key stay exactly as they are, and a node never gets a key.
  • A node can't alter, replay or reorder anything without the link closing.
  • Credentials stay short-lived and tied to one pairing.
  • Direct links stay the first choice. A node only carries traffic when a direct path fails.

What a node will still see

The same as today's relay: IP addresses, timing and volume. Spreading relays out lowers how much any one operator sees. It doesn't make relayed traffic anonymous.

Before it ships, this page will say

  • who can run a node, and what it needs;
  • how your browser picks a node;
  • how a node that misbehaves is spotted and dropped;
  • where the node code lives, open source like the rest of Poof.

What it doesn't promise

  • A direct link shows your IP address to the other person. Their browser connects to yours, the way any direct connection does. There's no relay-only switch in quant-rooms today. Use a VPN if you need to hide your address.
  • A relay sees who is connected. Not what is said, but which addresses, when, and how much.
  • A relay can refuse service. It can't read or change your traffic, but it can stop carrying it, and the link ends.
previousThe AI modelnextPoof Secretz
The WorkerCarries what it can’t read.

on this page

  • Relays today
  • Direct, or via a relay
  • Credentials that run out
  • What a relay can and can't do
  • Relay nodes: what comes next
  • What it doesn't promise

One-time messages

Poof Secretz.

A secret that opens once. It's encrypted in your browser, the server keeps only what it can't read, and the first reading erases it. Read once. Then poof.

Encryption
AES-256-GCM, in your browser
The key
32 random bytes, only in the link after #
Password
Optional, needed together with the link
Readings
One
Lifetime
10 minutes, 1 hour or 24 hours
Size
Up to 10,000 characters

How a secret travels

WRITER                       POOF SERVER                   READER
1  encrypt in this browser
2  ciphertext + 2 hashes ──▶
3  the link, your channel ─────────────────────────────────▶
4                                   ◀── reveal (POST, token)
5                                   ──▶ ciphertext, erased now
6                                        decrypt in this browser
7                                   ◀── a second reveal
8                                   ──▶ gone

You write the secret at usepoof.chat/secretz/. Your browser makes a random key and encrypts the secret with it before anything is sent. The server receives the ciphertext, a lifetime and two hashes, and answers with nothing more than when the secret will disappear.

The link looks like usepoof.chat/secretz/#<id>.<key>. Everything after # stays in the browser: it isn't sent with any request, so the key never reaches Poof. You send the link the way you choose.

Opening the link doesn't read the secret. The page says This secret can be read once and waits. Only when the reader presses Reveal secret does the browser ask the server for it. The server hands the ciphertext over and erases it in the same step, so a second request, from anyone, gets gone.

Link previews in Telegram, X or WhatsApp fetch the page, not the secret: a secret is only handed over to a POST that carries the right token, which a preview never sends.

The keys, and the token

LINK KEY (32 bytes, after #) + PASSWORD (optional, PBKDF2 ×200,000)
  ──▶ HKDF-SHA-256 (salt: the secret id)
      ──▶ AES-256-GCM key: encrypts the secret
      ──▶ reveal token: the server keeps only its hash

From the link's key, and the password if there is one, the browser derives two separate things with HKDF-SHA-256: the AES-256-GCM key that encrypts the secret, and a reveal token. The server stores only a SHA-256 hash of the token. To read a secret, a browser has to show the token, which only someone with the key (and the password) can compute.

  • Someone who learns only a secret's id can't use it up. Without the key there's no token.
  • A wrong password doesn't erase the secret. The token doesn't match, the server refuses, and the secret stays. After ten wrong tries, the secret deletes itself.
  • The secret id is part of the encryption's associated data, so a ciphertext can't be moved to another secret without failing to decrypt.
  • With a password, the link ends in .p, so the page asks for it before anything is requested. The server never learns that a password exists.

What the server sees

Poof's server seesPoof's server never sees
A random secret id, the ciphertext and its sizeThe secret, the key or the link after #
The lifetime you picked, and when the secret was read, deleted or expiredThe password, or whether there is one
A hash of the reveal token and a hash of the writer's secretThe reveal token or the writer's secret themselves
Your IP address on each request, for rate limits, never written downWho you sent the link to, or how

Nothing is logged. The ciphertext is erased by the reading itself; what remains is a marker that says read or deleted, so the writer can see what happened, and that marker is wiped at the end of the secret's lifetime along with everything else.

For the writer

When you create a secret, your browser also makes a writer's secret and sends only its hash. With it, the page you wrote the secret on shows a live status (waiting, read, deleted or expired, never any content) and a Delete now button that erases the secret before anyone reads it.

The link is shown once and isn't kept anywhere. The writer's id and secret stay in that browser tab only, so a reload keeps the status and the delete button; closing the tab forgets them.

LimitValue
Text10,000 characters, at most 16 KiB once encrypted (text outside ASCII takes more room)
Lifetime if nobody reads it10 minutes, 1 hour or 24 hours
New secrets10 per minute from one IP address
Readings, status checks and deletes30 per minute from one IP address
Wrong passwords10, then the secret deletes itself

By four words

A link is hard to say out loud. The writer can turn it into four words instead, through the same one-time mailbox as quant-room invites: the link is encrypted under a key derived from the words, which work once, for 3 minutes. The reader types them on usepoof.chat/secretz/, gets the secret's link back in the browser, and still decides when to reveal it.

Four words are a short secret. They're meant to be used within minutes; a new phrase replaces an expired one while the secret is waiting.

For developers

Write, then read onceengine API
// the writer
const note = await createNote({ fetch, origin, appOrigin, text, ttl: 3600 });
send(note.url); // usepoof.chat/note/#<id>.<key>

// the reader, only when they choose to
const link = parseNoteFragment(location.hash);
const text = await revealNote({ fetch, origin, link }); // a second call throws note_gone

The routes are POST /api/notes, POST /api/notes/:id/reveal, POST /api/notes/:id/status and DELETE /api/notes/:id. See the API reference.

What it doesn't promise

  • Whoever opens the link first reads the secret. If someone else gets the link before the person you meant, they can read it, and the secret is gone for your reader. Add a password, or send the link and the password through different channels.
  • The reader can keep it. They can copy the text or take a screenshot. Read once is about the server, not about what the reader does.
  • The link is as safe as the way you send it. A chat app that stores your messages stores the link too. That's what the password and the four words are for.
  • Symmetric encryption only. A secret uses AES-256 and a key carried in the link. There's no key exchange with public keys, so nothing in it depends on a key agreement holding up, and there's nothing to verify about who wrote it.
  • A password is only as strong as you make it. It's stretched with PBKDF2 and needs the link too, but a short one is easier to guess for someone who has the link.
previousRelay nodesnextThe quantum problem
The SleeperOne reading. Then nothing is left.

on this page

  • How a secret travels
  • The keys, and the token
  • What the server sees
  • For the writer
  • By four words
  • For developers
  • What it doesn't promise

Quantum, part 1

What happens to today's secrets when tomorrow's computers arrive?

Encryption is a bet that some maths problems are too hard to solve. Quantum computers change which problems are hard. This page explains how, without the hype.

Bits and qubits

A normal bit is 0 or 1. A qubit can be in a combination of both, called superposition, until you measure it, and then it becomes a plain 0 or 1. Quantum algorithms use quantum gates to arrange those combinations so that wrong answers cancel out and right answers become likely when you measure. That is not “trying every answer at once”. It only helps for problems with special structure. Try it in the Quantum Lab.

Two kinds of encryption, two kinds of risk

Public-key cryptography (RSA, elliptic curves, ECDH key exchange, digital signatures) lets two strangers agree on a secret. It relies on problems like factoring large numbers or computing discrete logarithms. Symmetric cryptography (AES) encrypts the actual data once both sides share a key. It relies on the key simply being too big to guess.

          CLASSICAL COMPUTER                       QUANTUM COMPUTER
                  │                                        │
         ┌────────▼────────┐                     ┌─────────▼─────────┐
         │  RSA · ECC      │                     │  Shor's algorithm  │
         │  factoring /    │                     │  factoring and     │
         │  discrete logs  │                     │  discrete logs     │
         └────────┬────────┘                     └─────────┬─────────┘
                  ▼                                        ▼
        impractical to solve                 solvable, on a large enough
                                             error-corrected machine

A picture of the idea, not a description of how Shor's algorithm works inside. Concept

AlgorithmUsed forQuantum attackEffect
RSAKey exchange, signaturesShorBroken by a large enough quantum computer
ECDH, ECDSA, Ed25519Key exchange, signaturesShorBroken by a large enough quantum computer
AES-256Encrypting dataGroverWeakened (roughly the strength of a 128-bit key). Still considered strong.
SHA-256HashingGrover-typeMargins shrink, still considered safe for most uses

So the weak spot is the handshake

The data itself (AES-256) holds up well. The vulnerable moment is when two parties agree on a key with RSA or elliptic curves. If someone can later recover that key exchange, they can unlock everything it protected.

Today vs tomorrow

No quantum computer is publicly known to break RSA or elliptic-curve keys at the sizes used on the internet. That would take a large, error-corrected machine, often called a “cryptographically relevant quantum computer”. Nobody can give a reliable date for one. The reason to act now anyway is on the next page.

previousPoof SecretznextHarvest now, decrypt later
The WatcherLooks at threats before they arrive.

on this page

  • Bits and qubits
  • Two kinds of encryption, two kinds of risk
  • So the weak spot is the handshake

Quantum, part 2

Harvest now, decrypt later.

You do not need a quantum computer today to attack today's messages. You only need to record them and wait.

TODAY                                         SOMEDAY
─────                                         ───────
encrypted traffic                             quantum capability
      │                                              │
      ▼                                              ▼
┌──────────────┐   store   ┌──────────────┐   ┌──────────────────┐
│   attacker   │ ────────▶ │  encrypted   │──▶│ try to recover   │
│ records it   │           │   archive    │   │ the key exchange │
└──────────────┘           └──────────────┘   └──────────────────┘

Anyone who can watch a network (an internet provider, a compromised router, a state agency) can save encrypted traffic cheaply and keep it for years. If that traffic relied only on RSA or elliptic-curve key exchange, a future quantum computer could unlock it. For conversations that must stay private for a long time, the risk starts the day they are recorded.

How Poof answers it

  MINIMIZE WHAT EXISTS          nothing stored on servers, quant-rooms expire
+ HYBRID POST-QUANTUM KEYS      classical key + ML-KEM-768
+ FRESH KEYS PER QUANT-ROOM           each quant-room gets new keys, then they're gone
+ KEYS STAY IN THE BROWSER      the server never holds them
──────────────────────────
= LESS LONG-TERM EXPOSURE

Ephemerality alone is not enough. Poof deleting things does not stop someone else from recording traffic on the network. That is why the encryption itself holds up against future quantum attacks, which is the job of the hybrid post-quantum key. See it play out in the Quantum Lab.

What this does not solve

  • A compromised device. If your phone or browser is infected, messages can be read before they are encrypted.
  • The link. The classical half of the key travels in the quant-room link. Someone who captured the link and broke the post-quantum exchange could read the quant-room. Both are needed.
  • Metadata. A recorder still sees that two IP addresses talked, when, and for how long.
previousThe quantum problemnextPost-quantum & hybrid keys
The WorkerDoes the boring work today so the future can’t undo it.

on this page

  • How Poof answers it
  • What this does not solve

Quantum, part 3

Two locks on every quant-room.

Post-quantum cryptography is ordinary software that runs on today's devices, built on maths problems believed to be hard even for quantum computers.

The NIST standards

In 2024 the U.S. National Institute of Standards and Technology published the first post-quantum standards:

StandardNameJobBased on
FIPS 203ML-KEMAgreeing on a shared keyModule lattices
FIPS 204ML-DSADigital signaturesModule lattices
FIPS 205SLH-DSADigital signaturesHash functions only

Poof uses ML-KEM-768 for its key exchange.

What a KEM does Concept

A key encapsulation mechanism works like a lockbox. Your guest publishes an open padlock (public key). You put a random secret in a box, snap the padlock shut and send it (ciphertext). Only your guest has the key that opens it. Now you both share the same secret, and anyone who watched only saw a locked box.

ML-KEM-768 in numbers

ItemML-KEM-768For comparison: X25519
Public key1,184 bytes32 bytes
Ciphertext1,088 bytes32 bytes
Shared secret32 bytes32 bytes
Security levelNIST category 3Not quantum-resistant

The keys are bigger, but for a chat handshake a couple of kilobytes, once per quant-room, makes no noticeable difference.

Why hybrid

Post-quantum algorithms are newer than RSA or elliptic curves. A hybrid design does not bet everything on one of them: it combines a classical secret with a post-quantum one, so an attacker has to break both.

  QUANT-ROOM KEY (classical)                    ML-KEM-768 SHARED SECRET
  256-bit, made in your browser,          agreed directly between browsers
  carried in the link after #             over the encrypted data channel
            │                                         │
            └──────────────┐          ┌───────────────┘
                           ▼          ▼
                     ┌────────────────────┐
                     │    HKDF-SHA-256    │  both in, bound to the exchange
                     └─────────┬──────────┘
                               ▼
                 HYBRID KEY · AES-256-GCM
                 one key per direction, every message

Both secrets go into HKDF-SHA-256 together, as one input, with a fixed, versioned Poof label and a hash of the whole exchange: the room, the two people, the public key and the ciphertext. The result stays secret as long as either half does. From it each side derives one key per direction and a confirmation key. Before any message, both browsers prove they arrived at the same result with an HMAC-SHA-256, each side using its own label, so a confirmation can't simply be bounced back. A tampered handshake fails this check and the connection is refused. Every label is on the developer guide.

Implementation notes

  • In the browser. Browsers don't ship ML-KEM yet, so Poof uses a pinned open-source implementation bundled into its engine, never fetched from a third-party server at runtime. AES-GCM, HKDF and HMAC come from the browser's own Web Crypto API.
  • Side channels. The ML-KEM library is written to avoid secret-dependent branches, and MAC checks go through Web Crypto, which compares in constant time. JavaScript in a browser can't promise strict constant time for everything, so the hybrid design never relies on one half alone.
  • Signatures. Poof does not use post-quantum signatures. Quant-room integrity comes from the shared keys and key confirmation, not from long-term identities.
previousHarvest now, decrypt laternextQuantum Lab
Hybrid key confirmedBoth halves agree. The quant-room switches over.

on this page

  • The NIST standards
  • What a KEM does
  • ML-KEM-768 in numbers
  • Why hybrid
  • Implementation notes

Quantum Lab Concept

Play with the ideas.

Three small experiments that make the quantum chapters tangible. They are teaching models, not simulations of real hardware or of Poof's code.

1 · A qubit, measured

|0⟩
|1⟩

Before measurement the qubit holds both possibilities. Each measurement gives a plain 0 or 1, and the pattern of results reveals the probabilities.

2 · Two locks

The session key comes from both secrets. Knowing one of them is not enough.

3 · Harvest now, decrypt later

Recorded conversationStatus
Classical key exchange only (RSA / ECDH)
Poof: hybrid key (classical + ML-KEM-768)
Copies on Poof's servers

You choose the year. Nobody can reliably predict it, which is exactly why protection has to be in place before it.

previousPost-quantum & hybrid keysnextSecurity architecture
The WorkerRuns the experiments so you don’t have to.

on this page

  • 1 · A qubit, measured
  • 2 · Two locks
  • 3 · Harvest now, decrypt later

Security

Every lock, and what it rests on.

For each protection: the threat it answers, the mechanism, what has to be true for it to work, and where it stops.

┌─────────────────────── YOUR BROWSER ──────────────────────────┐
│  quant-room key (from the link) ─┐                            │
│                                  ├─▶ HKDF ─▶ keys ─▶ AES-256-GCM │──┐
│  ML-KEM-768 secret  ─────────────┘                            │  │ ciphertext only
└───────────────────────────────────────────────────────────────┘  │
        │ signaling (no keys, no content)                           ▼
┌───────▼────────┐                                   ┌────────────────────┐
│  POOF SERVER   │ room id + end time, short-lived   │ WebRTC data channel│
│  no message    │                                   │ direct, or via a   │
│  storage       │                                   │ TURN relay         │
└────────────────┘                                   └────────────────────┘

The locks

End-to-end encryption

threatServers or networks reading messages

mechanismAES-256-GCM in the browser, a separate key for each direction, a counter for every frame

assumesYour browser and device are not compromised

limitDoesn't protect what's on screen

Key in the fragment

threatThe server learning the key

mechanismThe key lives after #, is generated after the server's answer and is never put in a request

assumesThe code you run is genuine

limitAnyone with the link has the key

Hybrid post-quantum key

threatRecorded traffic decrypted later

mechanismQuant-room key and ML-KEM-768 secret mixed with HKDF-SHA-256, bound to the room and both people

assumesAt least one of the two stays secret

limitMetadata stays visible to recorders

Key confirmation

threatTampering with the handshake

mechanismMutual HMAC-SHA-256 over the whole exchange, checked in constant time

assumesThe link reached the right person

limitSomeone with the link could sit in the middle; the safety code that would show it isn't on screen yet

Strict frame order

threatReplayed, dropped or reordered messages

mechanismPer-direction counters, header authenticated with every frame

assumesNone beyond the keys

limitA broken link ends the conversation instead of repairing it

Short-lived server state

threatOld data leaking later

mechanismOne small server object per quant-room, deleted when it ends; no message storage

assumesServer configuration as published

limitCan't erase copies someone else made

No logs

threatLogs revealing who talked to whom

mechanismThe API writes no logs and platform logging is off; no analytics or cookies

assumesHosting layers follow the same policy

limitThe hosting provider keeps request metrics; networks keep their own logs

A narrow API

threatOther sites or scripts abusing it

mechanismOnly usepoof.chat may call it from a browser, JSON only, a size and rate limit on every input

assumesBrowsers enforce CORS and origin checks

limitDenial of service by sheer volume

The client distrusts the server

threatA hostile server exhausting your browser

mechanismPeer counts, file sizes and relay lists are capped in the browser too

assumesNone

limitThe server can still refuse service

Relay (TURN)

threatNetworks that block direct connections

mechanismCredentials only once two people are paired, valid until the room ends, TLS only

assumesThe relay only forwards

limitThe relay sees IP addresses and volume

Four-word phrase

threatGuessing the phrase

mechanismPBKDF2-SHA-256, 200,000 rounds; one read; gone after 3 minutes

assumesThe phrase is used within minutes

limitShort phrases are not long-term secrets

Blind passes

threatLinking a payment to a quant-room

mechanismRSA blind signatures (RFC 9474), one-time passes

assumesPoof publishes the same keys to everyone

limitThe payment itself is public on the blockchain

AI in an enclave

threatAnyone but the model reading AI questions

mechanismFresh enclave proof checked in the browser, end-to-end encryption to the enclave

assumesThe hardware enclave holds

limitIntel's signature on the proof is confirmed by the hosting partner, not yet by the browser

Hardened pages

threatA downgrade to plain HTTP, Poof shown inside another site, links revealing where you came from, injected code loading from or sending data to somewhere else

mechanismHTTPS enforced for a year (HSTS), a Content Security Policy that lets the pages load code and connect only to Poof and a short list of named services (fonts, a code CDN, chain nodes, WalletConnect), no embedding in other sites, no referrer sent to external links, no guessing of file types, and camera, microphone, location, payments and USB switched off

assumesThe browser honours the headers

limitInline scripts are still allowed, because the pages carry their own code inline, so the policy can't stop an injected inline script from running. The signed engine checksum is how you check the code that holds your keys

In-app browser warning

threatApps injecting code into the page

mechanismInstagram, Facebook, TikTok and similar are detected

assumesThe person follows the advice

limitPoof can only warn, not stop the app

Limits the code enforces

InputLimit
New quant-rooms5 per minute per IP address
Joining a room10 per minute per IP address
Four-word phrases10 per minute per IP address; a locked link of at most 2 KiB, one read, 3 minutes
Request bodiesAt most 4 KiB, cut off while reading
WebSocket messagesText only, at most 32 KiB, schema-checked; the second malformed one closes the socket
Connection details (signals)At most 16 KiB each, 200 per pairing
Chat message5,000 characters, normalised
Files2 MB; browsers refuse anything over 64 MiB whatever the server says
Payments and AI30 requests per minute per IP address; AI 10 questions per minute per room

Rate limits count per IP address and per data center. The address is used only to count, never stored. Every limit has tests that go past it, and every parser is fuzzed.

Supply chain

  • Five small libraries in the engine, all cryptography or the word list, locked to exact versions and checked for known vulnerabilities (pnpm audit) on every change.
  • Dependabot for libraries and for the build pipeline, whose actions are pinned to exact commits.
  • Reproducible, signed releases of the API and the engine. See Verify it yourself.
previousQuantum LabnextData lifecycle
The KeeperKnows exactly what each lock protects.

on this page

  • The locks
  • Limits the code enforces
  • Supply chain

Where does data go?

Everything Poof touches, and when it's gone.

CREATE ──▶ PROCESS ──▶ TRANSMIT ──▶ USE ──▶ EXPIRE ──▶ DELETE ──▶ POOF

On Poof's server

DataCreatedHow longThen
Quant-room record: id, seats, end time, fingerprint of the creator secretWhen you create a quant-roomThe room's lifetime: 10 minutes, 1 hour or 24 hoursDeleted at the end, or at once on Poof it now
Who is connected right now (random peer ids)When someone joinsWhile they're connectedGone with the room
Connection details (offers, answers, ICE)While two browsers connectPassed straight throughNever stored
Four-word mailbox: a locked linkWhen you show a phraseUp to 3 minutes, or one readDeleted after it's read or expires
IP addressWith every requestOnly as a counter for rate limitsNever stored or logged by Poof
Payment record: network, transaction, variant, amountsWhen a payment is redeemedKept, for reconciliation and complaintsHolds no quant-room and no account
Fingerprint of a spent passWhen a pass is usedKept, so it can't be used twiceCan't be traced back to the payment

In your browser

DataLives inHow longThen
Quant-room keyThe link's fragment, memory, and this tab's session storage so a reload brings you backWhile the tab is open and the room livesGone when the tab closes or the room ends
Creator secretThe creator's browser, local storageUntil the room endsRemoved, and swept on the next visit if the tab closed first
ML-KEM keys and the shared secretMemory, per pair of peopleThe handshakeWiped once the keys are derived
Session keysMemoryWhile the link is upGone when it closes
Messages, names, received filesYour screen and memoryUntil the conversation endsWiped when the other person leaves; after the timer, readable until you leave the page
A payment in progress, unused passesLocal storageUntil the pass is spentRemoved when used

Elsewhere

DataWhereHow long
Encrypted trafficThe relay, when a direct path is blockedForwarded, never stored by Poof
An AI question and the conversation sent with itThe AI enclaveWhile it answers; no logs, no memory
Your paymentThe blockchainForever, like every transaction

Backups: none for quant-rooms. Their state exists only while the room lives, so there is nothing to back up.

What Poof can't erase

Screenshots, copied text, files your guest saved, payments on the blockchain, and logs kept by internet providers along the way. Ephemerality covers what Poof controls.

previousSecurity architecturenextThreat model
The SleeperWaits for the timer. Then nothing is left.

on this page

  • On Poof's server
  • In your browser
  • Elsewhere
  • What Poof can't erase

Threat model

Who can learn what.

A security promise is only useful if it says who it protects you from, and who it doesn't.

protects against

  • Poof's own servers reading your messages, with or without the AI model
  • Network eavesdroppers reading content
  • Messages tampered with, replayed or reordered on the way
  • Old servers or databases leaking conversations later
  • Recorded traffic decrypted by a future quantum computer (both keys needed)
  • A payment being linked to the quant-room it opened

does not protect against

  • A compromised phone, computer, browser extension or in-app browser
  • The person you're talking to (screenshots, copying)
  • Someone who gets the link or the phrase
  • The AI model, in rooms where it's on: it reads what it's asked about
  • Network observers seeing that you connected, and when
  • Anyone reading your payment on the blockchain

Attacker by attacker

AttackerCan learnCannot learn
Passive network observerThat you use Poof, timing, traffic sizeMessage content
Active network attackerThe same, and can block connectionsContent. Tampering fails key confirmation, and altered frames close the link
Poof's server, honest but curiousQuant-room ids, seats, end times, IP addresses and timing while connectedKeys, messages, files, names, the four words behind a phrase
Poof's server, hostile, without the linkThe same, and it can deny serviceContent. It can sit in the middle of the handshake, but without the link's key the confirmation fails
Poof's server, hostile, with the linkEverything, by sitting in the middleIt can't hide once the safety code is on screen
Someone serving altered page codeEverything, as with any web appNot unnoticed: the engine is open and attested, see Verify
Someone with the linkJoins if a seat is free; could sit between two peopleNothing more than any participant
Compromised relay (TURN)IP addresses, traffic volumeContent
The AI enclave (only with the AI on)The question and the conversation sent along with itAnything from quant-rooms without the AI. It keeps no logs and no memory
Blockchain observerYour wallet, the amount, the time of a paymentWhich quant-room it opened
Malicious guestEverything you send themNothing protects you here
Malware, a bad extension or an in-app browserEverything on screen, and the keyNothing protects you here
Future quantum attacker with recordingsMetadataContent, unless they also captured the link and broke ML-KEM

Known limits, in plain words

  • No safety code on screen yet. The engine computes it; the quant-room doesn't show it. Until it does, a link that reaches the wrong person can be used to sit in the middle. Share links privately.
  • The AI enclave's proof is partly checked by the partner. Your browser checks what the proof says. Intel's signature on it, and which software the enclave runs, are confirmed by the hosting partner.
  • Payment keys are Poof's word. A dishonest server could, in principle, hand someone their own pass key to recognise them later. The published keys can be compared by anyone.
  • Rate limits are per data center. Someone with many addresses can still flood the service.

The web-app problem

Any website can be changed by whoever runs the server. In theory, a compromised server could send you code that leaks your key. Poof's answer is to make the code that matters checkable: the engine that holds your keys is one open, unminified file, built reproducibly, signed with every release, and served next to its checksum. A change to it can't go unnoticed by anyone who looks. See Verify it yourself.

previousData lifecyclenextVerify it yourself
The SkepticAppears wherever we tell you what Poof can’t do.

on this page

  • Attacker by attacker
  • Known limits
  • The web-app problem

Transparency

Don't trust the docs. Check the code.

Every claim on these pages points to something you can inspect: the source, the build that produced the live server, and the exact engine file your browser runs.

PUBLIC COMMIT ──▶ GITHUB ACTIONS ──▶ ATTESTED RELEASE ──▶ LIVE API          ──▶ ENGINE IN YOUR BROWSER
on main           tests, same bytes    signed checksums      /api/health = commit    sha256 matches the release

Claim by claim

ClaimWhere to lookHow to check
The key never reaches the serverHow browsers treat the # fragment; packages/core/src/api.tsDevTools → Network: no request contains the key
Messages are end-to-end encryptedpackages/core/src/crypto/Read it; the WebSocket only ever carries connection details
Post-quantum key exchangecrypto/handshake.ts and its testsCheck the ML-KEM-768 library and crypto.test.ts
Nothing is kept after a room endsworker/src/room-do.ts, worker/wrangler.jsoncRoom state is deleted at the end; logging is switched off
The live API runs the published codeThe Deploy workflow and its attestationsSteps 1 and 2 below
Your browser runs the published engineusepoof.chat/engine/poof-engine.jsStep 3 below
The pages are hardenedThe response headers of usepoof.chatcurl -sI https://usepoof.chat/
Open sourcegithub.com/usepoofchat/poof-app, MITRead it, build it, run it

1 · Which commit is live

Ask the APIany terminal
curl -s https://api.usepoof.chat/api/health
# {"ok":true,"version":"1","commit":"bf268bfa…"}

Every push to main runs the Deploy workflow. It tests the code, bundles the API, checks that bundling twice gives identical bytes, signs the result and deploys exactly those bytes. Then it checks that the live API reports that commit. A server that answers "commit":"dev" wasn't deployed this way.

2 · Check the release

Verify the signed releaseGitHub CLI
# The Deploy run for that commit
gh run list --repo usepoofchat/poof-app --workflow deploy.yml

# Its signed files, kept for 90 days
gh run download RUN_ID --repo usepoofchat/poof-app -n release -D release
gh attestation verify release/worker-checksums.sha256 --repo usepoofchat/poof-app
gh attestation verify release/worker-bundle/index.js  --repo usepoofchat/poof-app
gh attestation verify release/poof-engine.js          --repo usepoofchat/poof-app

A successful check means GitHub's signing service vouches that these exact files were built by the repository's own workflow, from that public commit.

3 · Check the engine your browser runs

Compare the served engine with the releaseany terminal
curl -s https://usepoof.chat/engine/poof-engine.js | sha256sum
curl -s https://usepoof.chat/engine/poof-engine.js.sha256
cat release/engine-checksums.sha256
# all three must show the same 64 characters

The engine is the part of the web app that holds your keys: room creation, the key exchange, every encryption and decryption. usepoof.chat serves it as one plain, unminified file next to its checksum and the commit it was built from, so anyone can read it and compare it with the signed release.

4 · Rebuild it yourself

Same commit, same bytesNode 22, pnpm 10
git clone https://github.com/usepoofchat/poof-app && cd poof-app
git checkout COMMIT
pnpm install --frozen-lockfile
pnpm --filter @poof/worker run bundle ../out
sha256sum out/index.js                   # = release/worker-checksums.sha256
pnpm build:engine
sha256sum dist-engine/poof-engine.js     # = release/engine-checksums.sha256

Try one right now

You can check the first claim without trusting Poof. It's how every browser works:

  1. Open any link with a #something at the end.
  2. Open DevTools (F12) → Network and reload.
  3. Look at the request URL. Everything after # is missing. It never left your browser.

Then, inside a quant-room, open the WS filter in the same panel and click the WebSocket. You'll see the connection details going back and forth and nothing you typed: your messages travel on a different, direct channel, already encrypted.

What this proves, and what it doesn't

ProvesDoesn't prove
The signed files were built by GitHub Actions from that public commit, by the repository's own workflowWhat runs on the server at this second. Nobody outside the hosting provider can download it, and a server could report any commit. The API never sees keys or messages, so this concerns metadata, not what you say
Those exact bytes were uploaded as the live APIThe web page around the engine. The HTML of usepoof.chat is published openly but isn't part of the signed release
The engine file usepoof.chat serves can be matched to a signed build, byte for byteAnything about your own device, browser or extensions
previousThreat modelnextResponsible disclosure
The WorkerShows the receipts.

on this page

  • Claim by claim
  • 1 · Which commit is live
  • 2 · Check the release
  • 3 · Check the engine
  • 4 · Rebuild it yourself
  • Try one right now
  • What it proves

Security reports

Found something? Tell us first.

If you believe you've found a security issue in Poof, we want to hear about it, privately, before anyone else does.

How to report

  • Email security@usepoof.chat with a description, steps to reproduce and the impact you expect.
  • Please don't test against other people's quant-rooms, and don't publish details until we've had time to fix it.
  • Include your PGP key if you'd like an encrypted reply.
  • Mention the commit you tested. https://api.usepoof.chat/api/health shows the live one.
  • We acknowledge every report within 48 hours, assess severity, agree a fix plan and coordinate the disclosure date with you. We credit reporters publicly if they wish.

Severity

LevelExamples
CriticalReading message content, recovering keys, bypassing end-to-end encryption
HighJoining quant-rooms without the link or phrase, linking payments to quant-rooms
MediumMetadata leaks beyond what the threat model describes
LowHardening gaps without a direct impact

Safe harbour

We won't take legal action against good-faith research that avoids privacy violations, data destruction and service disruption, accesses no more than needed to show the issue, and gives us reasonable time to fix it before disclosure.

Out of scope

  • Attacks that need a compromised device or browser, including a malicious extension or an in-app browser, and social engineering.
  • Denial of service through volume. Rate limits count per IP address and per data center.
  • Issues in third-party services outside Poof's control.
  • Missing security headers on the API's JSON responses. They aren't documents, and they carry nosniff and no-store.
  • Reports that only come from automated scanners, without a concrete impact.

Only the current version is supported: there are no older releases to patch. Reports that show a gap between these docs and the code are exactly what we want.

previousVerify it yourselfnextDeveloper guide
Thank youEvery report makes the next quant-room safer.

on this page

  • How to report
  • Severity
  • Safe harbour
  • Out of scope

For developers

The protocol, step by step.

How the Poof engine talks to Poof's server and to other browsers. Every name, size and label on this page comes from the open-source code, so you can read it side by side with the repository.

Engine
TypeScript, built to one ES module
Protocol
Version 1, every message schema-checked
Licence
MIT
Source
usepoofchat/poof-app
API
api.usepoof.chat
Libraries
5: ML-KEM, curves, hashes, blind RSA, word list

Building blocks

LayerTechnology
TransportWebRTC, with two ordered, reliable DataChannels per pair: poof-ctl for chat and control, poof-files for files
SignalingWebSocket at wss://api.usepoof.chat/ws/rooms/:id. The server relays connection details and never keeps them
Quant-room stateOne short-lived server object per quant-room, deleted when it ends. No message storage, ever
ClientThe engine: TypeScript compiled to one file, poof-engine.js, the same bytes on every build. Nothing is loaded from third-party servers at runtime
Classical cryptoThe browser's Web Crypto API: AES-256-GCM, HKDF-SHA-256, HMAC-SHA-256, SHA-256, PBKDF2
Post-quantumML-KEM-768 (FIPS 203), from a pinned open-source implementation bundled into the engine
Wire formatProtocol version 1. Every HTTP body, WebSocket message and frame is checked against a schema, with a size limit
NAT traversalSTUN, plus TURN over TLS only (turns:)

From click to sealed

YOU                              POOF SERVER                         GUEST
1  POST /api/rooms {ownerHash} ──▶
2  ◀── roomId + expiry
3  make the 32-byte key (never sent)
4  WebSocket join ───────────────▶ welcome
5                                  ◀──────────────── joins with the link
6                                  paired: roles + relay credentials ──▶ both
7  offer · answer · ICE, relayed through the server ─────────────────▶
8  ◀═══════════════ two DataChannels open (DTLS) ═════════════════════▶
9  ◀═══════════════ hybrid handshake (ML-KEM-768) ════════════════════▶
10 sealed: chat is on

The server pairs people by itself. When someone joins, it sends paired to both sides, with a role and the relay credentials. The member who joined first is the initiator: it makes the WebRTC offer and starts the key exchange. The server stamps the sender of every signal itself, from the socket it came on, so nobody can pretend to be someone else in the room. In a group, every pair goes through steps 6 to 10 on its own.

The hybrid handshake

INITIATOR (A)                                        RESPONDER (B)
──────────────                                       ──────────────
        ════════ 2 DataChannels open (DTLS) ════════
(pk, sk) = ML-KEM-768.KeyGen()
  1 ── pq.hello { pk }  (1,184 bytes) ───────────────▶
                                       (ct, SQ) = ML-KEM-768.Encaps(pk)
                                       T = transcript hash · K = master key
  2 ◀────────────── pq.reply { ct (1,088 bytes), MAC_R } ──
SQ = Decaps(sk, ct) · K · check MAC_R
  3 ── pq.confirm { MAC_I } ─────────────────────────▶  check MAC_I
sealed: one AES-256-GCM key per direction, derived from K

The handshake runs inside the DataChannel, before any chat. Both sides mix two secrets: K_C, the 32-byte quant-room key from the link, and SQ, the shared secret from ML-KEM-768. The derivation is bound to everything the two sides just exchanged:

Key derivationexact labels
T = SHA-256( "poof/v1/transcript" ‖ len‖roomId ‖ len‖initiatorId ‖ len‖responderId
             ‖ len‖pk ‖ len‖ct )

K = HKDF-SHA-256( ikm  = K_C ‖ SQ,
                  salt = "poof/v1/salt",
                  info = "poof/v1/master" ‖ T )

confirm key = HKDF(K, "poof/v1/confirm")
A → B key   = HKDF(K, "poof/v1/key/initiator-to-responder")
B → A key   = HKDF(K, "poof/v1/key/responder-to-initiator")
safety code = HKDF(K, "poof/v1/sas")

MAC_R = HMAC-SHA-256( confirm key, "poof/v1/mac/responder" ‖ T )
MAC_I = HMAC-SHA-256( confirm key, "poof/v1/mac/initiator" ‖ T )

Putting both secrets into the same input is the standard hybrid combiner: K stays secret as long as either K_C or SQ does. Binding the room id and both member ids into T means a handshake can't be replayed or spliced between a different pair of people. Each side checks the other's MAC in constant time. If a check fails, the connection is refused, never quietly downgraded.

honest limit

Someone who doesn't have the link can't derive K, so even a hostile server sitting in the middle fails the MAC check. Someone who does have the link could run two separate handshakes, one with each of you, and both would pass. Comparing the safety code on two screens would expose that. The engine already derives it; the room doesn't show it yet. Until it does, share the link only with the person it's meant for.

Frames on the wire

header (11 bytes, sent in clear, authenticated)    encrypted
version · channel · type · seq (8 bytes)           AES-256-GCM(payload) + tag (16 bytes)

nonce = channel ‖ 00 00 00 ‖ seq   (12 bytes, never sent, never repeats)
AAD   = the 11 header bytes

After the handshake every message is a binary frame. Each direction has its own key and each channel its own counter, starting at 0 and going up by exactly 1. The receiver rebuilds the nonce from the header and checks the counter before decrypting. DataChannels are ordered and reliable, so any gap, repeat or reflection can only be tampering: the link is closed.

TypeChannelCarries
0x01 chatctl{ id, text, ts }, text up to 5,000 characters
0x02 ctlctlconnection_type, bye, hello (name), members, typing, ai, pin
0x03 aictlA finished AI answer, shared by whoever asked
0x10 file.metafiles{ fileId, name, size, mime, chunks, sha256 }
0x11 file.chunkfilesfileId (16 bytes) ‖ index (4 bytes) ‖ up to 16 KiB
0x12 file.endfilesEvery chunk is out
0x13 file.abortfilesReason: cancelled, not_allowed, too_large, busy, invalid
0x14 file.ackfilesThe receiver's verdict after hashing the whole file

A 16 KiB file chunk makes a frame of 11 + 20 + 16,384 + 16 bytes, far below the 64 KiB every browser accepts per DataChannel message.

Using the engine

The web app at usepoof.chat loads the engine as one file, /engine/poof-engine.js. Everything the browser does lives there: room creation, links and phrases, the key exchange, frames, WebRTC and the room's state. A page only renders state and calls a handful of commands.

A whole quant-roomengine API
import {
  createRoom, RoomSession, parseInviteFragment,
  browserSocketFactory, browserRtcFactory,
} from "/engine/poof-engine.js";

const API = "https://api.usepoof.chat";

// Creator: a new room. A guest instead reads the link it was given:
// const { roomId, key } = parseInviteFragment(location.hash);
const room = await createRoom({ fetch, origin: API });

const session = new RoomSession({
  roomId: room.roomId, roomKey: room.key, ownerSecret: room.ownerSecret,
  origin: API, appOrigin: location.origin, fetch: fetch.bind(window),
  createSocket: browserSocketFactory, createPeerConnection: browserRtcFactory,
});

session.subscribe((s) => {
  s.status;     // loading, waiting, connecting, connected, sealed, terminated, expired, error
  s.inviteUrl;  // the full link, for copying or a QR code
  s.expiresAt;  // already corrected for clock skew
});
await session.start();
await session.sendMessage("hi");
CommandWhat it does
sendMessage(text)Encrypt and send to everyone connected
sendFile(file), abortTransfer(id)Files, Super Quant-Rooms only
setNickname(name), setTyping(on)Your name and the typing hint
createPhrase()Put the link behind four words, one use, 3 minutes
ban(peerId), pin(id), destroy()Creator tools
upgrade(pass)Turn the room into a Super Quant-Room
suspend(), leave()Reload without leaving, or leave for good

Rules the code keeps

  1. Keys are made in the browser and stay there. The room key lives in the link's fragment and in memory, never in a request, a header or a log.
  2. The server never sees content. Chat, files, file names and names travel only as end-to-end encrypted frames.
  3. Signaling is a relay, not a transport. Chat never goes over the WebSocket, not even as a fallback.
  4. The server enforces capacity. It decides who gets a seat; a client can't talk its way past it.
  5. Quant-rooms are ephemeral. Server state is deleted when a room expires or ends.
  6. Logging stays off. The API writes no logs, and there are no analytics, cookies or third-party scripts.
  7. The API stays narrow. Only usepoof.chat may call it from a browser, and it serves nothing but /api/* and /ws/*.
  8. Every input has a limit, a schema, and tests that go past it.
  9. The client doesn't trust the server for resources. Peer counts, file sizes and relay lists are capped in the browser too.
  10. Wire changes are versioned. Any incompatible change bumps the protocol version.
  11. Builds are reproducible and attested. Same commit, same bytes. See Verify it yourself.

Running it locally

Start Poof on your machineNode 22+, pnpm 10
git clone https://github.com/usepoofchat/poof-app && cd poof-app
corepack enable
pnpm install
pnpm dev          # the smoke-test page on :5173, the API on :8787

Open http://localhost:5173 in two browser profiles (or one normal and one private window) and create a quant-room between them. The page shows the status, whether the path is direct or relayed, the chat and the raw log of the handshake. Add ?relay=1 before the # to force the connection through the relay.

CommandWhat it runs
pnpm checkTypes, lint, unit tests and the engine against a real local API
pnpm test:browserReal Chrome over real WebRTC: rooms for two and a 4-person group
pnpm build:engineBuilds poof-engine.js, the same bytes every time
previousResponsible disclosurenextAPI reference
The WorkerReads the spec so you can read the code.

on this page

  • Building blocks
  • From click to sealed
  • The hybrid handshake
  • Frames on the wire
  • Using the engine
  • Rules the code keeps
  • Running it locally

For developers

API reference.

Everything Poof's server answers to, at https://api.usepoof.chat. It's deliberately small: it creates quant-rooms, introduces browsers to each other, holds four-word mailboxes for a few minutes and turns payments into passes. It never sees a key or a message.

Base URL
api.usepoof.chat
Paths
/api/* and /ws/* only
Format
JSON, schema-checked
Browsers
Only usepoof.chat (CORS)
Auth
None. Proofs, not accounts
Logs
None

Browsers may call the API only from https://usepoof.chat, without cookies or credentials. Requests without an Origin header, like curl, are fine. Every POST and PUT needs Content-Type: application/json and a body of at most 4 KiB. Rate limits count per IP address, per data center, and the address is never stored.

Endpoints

Method and pathWhat it doesLimit
GET /api/healthIs it up, and which commit is live
POST /api/roomsCreate a quant-room (with a pass: a Super Quant-Room)5 / min
GET /api/rooms/:idPublic facts about a live room30 / min
POST /api/rooms/:id/upgradeCreator: turn the room into a Super Quant-Room30 / min
PUT /api/handshakes/:idLeave a locked link behind four words10 / min
POST /api/handshakes/:id/takeTake it, once10 / min
POST /api/notesStore an encrypted Poof Secretz secret10 / min
POST /api/notes/:id/revealRead it, once (erased in the same step)30 / min
POST /api/notes/:id/statusFor the writer: waiting, read, deleted or expired30 / min
DELETE /api/notes/:idFor the writer: delete it unread30 / min
GET /api/pay/configNetworks, each with Poof's address and its tokens, and the pass keys
POST /api/pay/redeemPayment in, blind signature out30 / min
POST /api/rooms/:id/aiCreator: register the room's AI token fingerprint30 / min
POST /api/ai/attestationA fresh proof from the AI enclave30 / min
POST /api/ai/chatForward one encrypted question, stream the encrypted answer30 / min, 10 per room
GET /ws/rooms/:id?peerId=The WebSocket for signaling and presence10 joins / min

Rooms

HealthGET /api/health
curl -s https://api.usepoof.chat/api/health

{ "ok": true, "version": "1", "commit": "bf268bfa…" }
Create a quant-roomPOST /api/rooms
// Request: only the fingerprint of the creator secret (SHA-256, base64url).
{ "ownerHash": "3vQ…43 characters" }
// A Super Quant-Room adds:  "pass": { variant, keyId, msg, signature }

// Response
{
  "roomId": "Q2xL8vT0b3nZkR1pWq4yHg",
  "expiresAt": 1791200400000, "serverNow": 1791199800000,
  "plan": "free", "tier": "free", "maxPeers": 2,
  "limits": { "fileTransfer": false, "fileMaxBytes": 2097152 },
  "ai": false
}

The key is not part of any of this. The browser generates it after this answer arrives and keeps it in the link's fragment. GET /api/rooms/:id returns the same fields plus peers, the number of people inside. tier is free, 60m or 24h.

Upgrade (creator only)POST /api/rooms/:id/upgrade
{ "ownerSecret": "…43 characters", "pass": { … }, "aiHash": "…" }

The server checks the secret against the fingerprint it was given at creation. The new lifetime starts now, seats only go up, and everyone in the room gets room.upgraded.

Four-word mailboxes

Leave and take a locked linkPUT, POST /api/handshakes
// :id = 43 characters derived from the four words (PBKDF2, 200,000 rounds)
PUT  /api/handshakes/:id        { "blob": "base64(nonce ‖ AES-GCM(link))" }   → 201 { "expiresAt" }
POST /api/handshakes/:id/take                                        → 200 { "blob" }

The blob is at most 2 KiB and lives for 3 minutes. take returns and deletes it in one step, so the second attempt gets handshake_not_found. An id that already holds a blob can't be filled again until it's taken or expires (handshake_exists).

Poof Secretz

Store, read once, check, delete/api/notes
// :id = 22 characters, made by the writer's browser; the key never leaves it
POST   /api/notes             { "id", "ciphertext", "ttl": 600 | 3600 | 86400, "creatorHash", "revealHash" }  → 201 { "id", "expiresAt" }
POST   /api/notes/:id/reveal  { "revealToken" }    → 200 { "ciphertext" } · 403 wrong_secret · 410 note_gone
POST   /api/notes/:id/status  { "creatorSecret" }  → 200 { "state", "expiresAt" }
DELETE /api/notes/:id         { "creatorSecret" }  → 200 { "state": "deleted" }

The ciphertext is base64url, at most 16 KiB decoded; the request body at most 32 KiB. reveal returns and erases the ciphertext in one step, so the second attempt gets note_gone. A wrong token leaves the secret in place; the tenth deletes it. Secrets travel in the body, never in the URL. See Poof Secretz.

Payments

Redeem a paymentPOST /api/pay/redeem
{
  "chain": "base", "token": "USDC", "txHash": "0x…",
  "variant": { "lifetime": 3600, "people": 4, "ai": false },
  "keyId": "…", "blindedMsg": "…",
  "payer": "0x…", "signature": "0x…"
}
// On Solana: "chain": "solana", with txHash, payer and signature in base58.
→ 202 { "status": "pending", "confirmations": 0, "needed": 1 }
→ 200 { "status": "ok", "blindSignature": "…" }

Variants are written lifetime-people, with -ai when the AI model is included: 3600-4, 86400-10-ai. The whole flow is on the Payments page.

AI model

All three calls carry the room id and the room's AI token, which the browser derives from the quant-room key. /api/ai/chat accepts only hex ciphertext, forces the model and its settings, and streams the encrypted answer back untouched. See The AI model.

The WebSocket

Connect to wss://api.usepoof.chat/ws/rooms/:id?peerId=<22 characters>. The peer id is random per session and stays the same across reconnects. Messages are JSON text of at most 32 KiB, each carrying "v": 1. A plain ping every 20 seconds gets a pong; no answer within 8 seconds means the socket is dead. The second malformed message closes it.

Browser → serverMeaning
signalAn offer, answer or ICE candidate for one member (to), at most 16 KiB, 200 per pairing
claimThe creator proves who they are, with the creator secret
banCreator: remove one member for good
destroyCreator: end the room for everyone
leaveLeave on purpose
Server → browserMeaning
welcomeYou're in: room facts, server time, members, limits
pairedConnect to this member: your role and the relay credentials
signalConnection details, with from stamped by the server
ownerThis member proved they created the room
peer.leftSomeone left: closed, leave or banned
room.upgradedNew lifetime, seats and fresh relay credentials
room.expired, room.destroyedThe end
banned, replaced, rejectedThis socket is being closed, and why
errorprotocol_error, signal_too_large, signal_rate_exceeded, not_paired, not_owner
Close codeMeaning
4000Protocol error
4001The room expired
4002The room was destroyed
4003The room is full
4004No such room
4005Rate limited
4006The same peer id connected again; this socket was replaced
4007The page's origin isn't allowed
4008The creator removed you

Errors

Every error looks like thisJSON
{ "error": { "code": "rate_limited", "message": "Rate limit exceeded. Try again later." } }
GroupCodes
Requestsinvalid_request, unsupported_media_type, payload_too_large, method_not_allowed, not_found, forbidden_origin, rate_limited, internal_error
Roomsroom_not_found, not_owner
Phrasesinvalid_handshake, handshake_exists, handshake_not_found
Poof Secretznote_exists, note_gone, wrong_secret, not_owner
Paymentspay_unavailable, chain_unavailable, payment_invalid, payment_underpaid, payment_used, key_changed, pass_invalid, pass_used
AI modelai_not_enabled, ai_not_ready, ai_forbidden, ai_budget_exhausted, ai_unavailable
previousDeveloper guidenextGlossary
The WorkerAnswers to very little, on purpose.

on this page

  • Endpoints
  • Rooms
  • Four-word mailboxes
  • Poof Secretz
  • Payments
  • AI model
  • The WebSocket
  • Errors

Reference

Glossary.

Every term in three steps: plain words, the technical version, and why it matters to Poof.

Qubit

simpleA bit that can be 0, 1, or a mix of both until measured.

technicalThe basic unit of quantum information, described by complex amplitudes; measurement yields a classical bit.

for poofLarge numbers of reliable qubits are what would threaten today's key exchanges.

Superposition

simpleBeing in a combination of states at once.

technicalA qubit state is a linear combination of basis states.

for poofIt's why quantum algorithms can do things classical ones can't, for some problems.

Entanglement

simpleQubits whose results are linked, however far apart.

technicalA joint state that can't be written as separate per-qubit states.

for poofA resource quantum algorithms rely on.

Quantum gate

simpleAn operation that changes qubits.

technicalA unitary transformation applied to one or more qubits.

for poofAlgorithms like Shor's are sequences of gates.

Physical vs logical qubit

simpleRaw hardware qubits vs error-corrected ones built from many of them.

technicalError correction encodes one logical qubit across many noisy physical qubits.

for poofBreaking RSA needs many logical qubits, which is why it isn't possible yet.

Quantum error correction

simpleFixing quantum errors without looking at the data.

technicalCodes that detect and correct errors on encoded qubits.

for poofThe main engineering hurdle between today's machines and dangerous ones.

Quantum advantage

simpleA quantum computer beating classical ones at some task.

technicalDemonstrations exist for specific, mostly artificial problems.

for poofNot the same as breaking encryption. Headlines often mix them up.

Shor's algorithm

simpleA quantum recipe for factoring and discrete logarithms.

technicalPolynomial-time algorithm for integer factorization and discrete log.

for poofBreaks RSA and elliptic-curve key exchange on a big enough machine.

Grover's algorithm

simpleA quantum speed-up for searching.

technicalQuadratic speedup for unstructured search.

for poofWeakens symmetric keys; AES-256 stays strong.

Post-quantum cryptography

simpleEncryption designed to resist quantum attacks, running on normal computers.

technicalSchemes based on problems like lattices or hash functions.

for poofPoof's handshake uses it (ML-KEM-768).

Quantum-safe

simpleExpected to hold up against quantum computers.

technicalInformal term; depends on assumptions and correct implementation.

for poofWe say “designed to resist”, never “unbreakable”.

Harvest now, decrypt later

simpleRecord encrypted data today, unlock it later.

technicalStore-and-wait attack against long-lived ciphertext.

for poofThe reason post-quantum matters before quantum computers exist.

KEM

simpleA way to agree on a shared secret using a public key.

technicalKey encapsulation mechanism: encapsulate / decapsulate.

for poofHow Poof's browsers agree on the post-quantum half of the key.

Lattice cryptography

simpleMaths based on hard problems in multi-dimensional grids.

technicalSecurity from problems like Module-LWE.

for poofThe foundation of ML-KEM and ML-DSA.

ML-KEM

simpleThe NIST-standard post-quantum key exchange.

technicalFIPS 203, module-lattice KEM; ML-KEM-768 is NIST category 3.

for poofPoof uses ML-KEM-768.

ML-DSA

simpleThe NIST-standard lattice signature scheme.

technicalFIPS 204.

for poofNot used by Poof.

SLH-DSA

simpleA signature scheme built only on hash functions.

technicalFIPS 205, stateless hash-based signatures.

for poofNot used by Poof.

Forward secrecy

simpleOld conversations stay safe even if a key leaks later.

technicalSession keys are ephemeral and not derivable from long-term keys.

for poofEach Poof quant-room uses fresh keys that disappear with the quant-room.

URL fragment

simpleThe part of a link after #.

technicalNot sent to the server in HTTP requests.

for poofWhere Poof keeps the classical quant-room key.

WebRTC

simpleBrowser technology for direct connections.

technicalPeer-to-peer media and data channels with DTLS encryption.

for poofHow messages travel between browsers without Poof's servers.

TURN relay

simpleA fallback server that forwards traffic when a direct link fails.

technicalRelays packets; sees only encrypted payloads.

for poofLets quant-rooms work behind strict networks.

HKDF

simpleA recipe for mixing secrets into a key.

technicalHMAC-based key derivation function (RFC 5869).

for poofCombines the classical and post-quantum secrets.

AES-GCM

simpleFast, standard encryption that also detects tampering.

technicalAuthenticated encryption with associated data.

for poofEncrypts every message in a quant-room.

Quant-room

simpleA temporary, private chatroom in Poof.

technicalA short-lived room on Poof's server that introduces browsers, plus end-to-end encrypted links between them.

for poofA Quant-Room lasts 10 minutes; a Super Quant-Room 1 hour or 24 hours.

Signaling

simpleIntroducing two browsers so they can connect.

technicalExchanging WebRTC offers, answers and ICE candidates through a server.

for poofPoof's server passes them along and stores nothing. Chat never goes this way.

DataChannel

simpleA direct pipe between two browsers.

technicalA WebRTC channel for any data, protected by DTLS.

for poofPoof opens two per pair, one for chat and one for files, each carrying its own encrypted frames.

Nonce

simpleA number used once.

technicalA per-message value that must never repeat under the same key.

for poofPoof builds it from a counter, so it never repeats and a missing message is noticed.

Key confirmation

simpleProving both sides got the same key, without showing it.

technicalEach side sends a MAC over the handshake transcript, under a key derived from the result.

for poofA failed check refuses the connection; it's never quietly downgraded.

Safety code

simpleA short code two people compare to rule out someone in the middle.

technicalA short authentication string derived from the session's keys.

for poofThe engine derives it; the quant-room doesn't show it yet.

PBKDF2

simpleA deliberately slow way to turn a password into a key.

technicalPassword-based key derivation with many rounds of HMAC.

for poofTurns four words into a mailbox address and a lock key, over 200,000 rounds.

Blind signature

simpleSigning something without seeing it.

technicalRSA blind signatures (RFC 9474): the signer signs a blinded message that only the requester can unblind.

for poofLets Poof sign a one-time pass without linking it to your payment.

One-time pass

simpleA ticket that works once.

technicalA blind-signed message, spent once and remembered only as a fingerprint.

for poofWhat a payment turns into, and what opens a Super Quant-Room.

Hardware enclave

simpleA sealed area inside a processor that even the machine's owner can't look into.

technicalA trusted execution environment, here Intel TDX, whose memory the hardware encrypts.

for poofWhere the AI model reads and answers.

Attestation

simpleA signed proof of what a machine is.

technicalA hardware-signed report that binds keys and fresh data to an enclave.

for poofYour browser checks one before it asks the AI anything.

Reproducible build

simpleThe same source always produces the same file.

technicalA deterministic build whose output can be hashed and compared by anyone.

for poofLets you match the live engine and API to the public code.

Poof Secretz

simpleA message that can be read once, then it's gone.

technicalAES-256-GCM ciphertext made in the browser; the server hands it over once and erases it in the same step.

for poofWritten at usepoof.chat/secretz/. The key lives only in the link, after #.

Reveal token

simpleProof that you hold a note's key, without showing the key.

technicalA value derived with HKDF from the link key (and the password); the server stores only its SHA-256.

for poofWithout it nobody can use a note up, and a wrong password doesn't erase it.

previousAPI referencenextFAQ

Reference

Questions.

41 short answers. Most link to a page with the full story.

What is Poof?

A private chatroom in your browser that doesn't ask who you are and disappears when the timer ends.

Why is it called Poof?

Because that's what the quant-room does at the end.

What does ephemeral mean?

Temporary by design. Quant-rooms have a fixed lifetime and nothing about the conversation is kept after it.

Do I need an account?

No. No email, no phone number, no username. Ever.

What is Poof Secretz?

A one-time message. You write it at usepoof.chat/secretz/, your browser encrypts it, and you send the link. It opens once, then it's gone from the server. See Poof Secretz.

Can someone else read my secret first?

Yes, if they get the link before your reader does: whoever opens it first reads it. Add a password and send it another way than the link. The reader can always copy or screenshot what they read. See Poof Secretz.

How long does a quant-room last?

A Quant-Room lasts 10 minutes. A Super Quant-Room lasts 1 hour or 24 hours.

How many people can join?

Two in a Quant-Room, up to ten in a Super Quant-Room, or just you with the AI model. The server holds the door, so nobody squeezes in once it's full.

How do I invite someone?

Send the link privately, show the QR code, or press Show a phrase and read out the four words. See How a quant-room works.

Is the four-word phrase secure?

For what it's for, yes: it works once and disappears after 3 minutes, and every guess costs 200,000 rounds of PBKDF2. Don't reuse it as a password.

What happens if I reload the page?

You go straight back into the quant-room. In a room for two, the other person's screen keeps the conversation for 30 seconds while you return.

What happens when the other person leaves?

The conversation is wiped from your screen at once. In a group, the room goes on without them.

What happens when the timer ends?

The connection closes and Poof's server deletes everything it held about the room. What's on your screen stays readable until you leave the page, then it's gone.

Can I end a quant-room early?

The person who created it can press Poof it now. It ends for everyone, and the server deletes it at once.

Can the creator remove someone?

Yes. That person is disconnected and can't come back into that room. The creator can also pin one message for everyone.

Can I send files?

In a Super Quant-Room, up to 2 MB per file. Files go browser to browser, encrypted piece by piece, and are checked on arrival. See Super Quant-Rooms.

Can Poof read my messages?

No. The key stays in your browser and Poof's servers never have it. Messages travel directly between browsers, already encrypted.

What does Poof's server know?

That a quant-room exists, how many seats it has, when it ends, and which IP addresses are connected while they are. Not what was said. See Data lifecycle.

What is stored after a quant-room ends?

Nothing about the conversation. See Data lifecycle.

Is Poof anonymous?

Not on its own. It never asks who you are, but networks can still see your IP address. Use Tor or a VPN if you need to hide that.

What's the difference between privacy and security?

Privacy is about who can learn things about you. Security is about whether data can be read or changed without permission. See Philosophy.

How do I pay for a Super Quant-Room?

From a wallet, in USDC on Ethereum, Base or Solana, or USDG on Robinhood Chain. No account. See Payments.

Can Poof link my payment to my quant-room?

No. Blind signatures give you a one-time pass Poof has signed but never seen, so it can't tell which payment a room came from. The payment itself is public on the blockchain, like any transfer.

Where does the money go?

To Poof's treasury, 0x68222E6dC73e161045233B2b76a47d98F84A7e8C. Once POOF is listed, the whole amount buys back POOF and burns it.

Can I talk to an AI in a quant-room?

Yes, in a Super Quant-Room: add the uncensored AI model when you create it (+$2 for 1 hour, +$5 for 24 hours). Talk to it alone, or start a message with @ai in a group. See The AI model.

Who can read what I ask the AI?

Only the model. It runs inside a sealed hardware enclave (Intel TDX) hosted by an AI infrastructure partner. Your browser encrypts the conversation straight to the enclave, and Poof's servers only pass the encrypted text along. To answer, the model reads the question and the recent conversation sent with it.

Is there mining or AI training?

No. Poof doesn't store conversations, and the AI model keeps no logs and no memory, so there's nothing to train on.

What is post-quantum cryptography?

Encryption designed to resist future quantum computers, running on today's devices.

Why should I care about quantum computers now?

Because traffic recorded today could be decrypted later. See Harvest now, decrypt later.

Can quantum computers decrypt messages today?

No machine is publicly known to be able to break today's key exchanges at real-world sizes.

What is Shor's algorithm?

A quantum algorithm that would break RSA and elliptic-curve key exchange on a large, error-corrected quantum computer.

What is ML-KEM?

The NIST-standard (FIPS 203) post-quantum way to agree on a key. Poof uses ML-KEM-768.

What is a KEM?

A key encapsulation mechanism: one side locks a random secret with the other side's public key.

Why hybrid instead of only post-quantum?

So an attacker has to break both a classical and a post-quantum secret. Neither alone is enough.

Can a hacked device still leak messages?

Yes. Encryption protects messages on the way, not on a compromised screen.

What if Poof's server is hacked?

It never has the keys or the messages. It could try to serve altered code, which is why the engine that holds your keys is open, signed and checkable. See Verify it yourself.

What if the relay (TURN) is compromised?

It only ever sees encrypted traffic and IP addresses.

Can the other person screenshot the chat?

Yes. No app can stop that.

Is Poof open source?

Yes, under the MIT licence: github.com/usepoofchat/poof-app. See Verify it yourself for how to check the build.

Is there an API?

Yes, a small one, and it never sees a key or a message. See API reference.

How do I report a security issue?

Privately, by email to security@usepoof.chat. See Responsible disclosure.

previousGlossarynextBrand book
Hi.Short answers. Links go deeper.

Brand

The Poof brand.

One fox, one checkerboard, one orange. Everything here exists to keep Poof recognizable wherever it shows up: on the site, in a post, in a quant-room.

Writing about Poof or making something for the community? Use this page for the rules and the Brand kit for the files.

Essence

Poof is a private chatroom that forgets. You open a quant-room, talk, and when the timer runs out, it is gone. The brand carries that idea: things appear, do their job, and disappear.

LineWhere it goes
Talk freely. Then poof.The main line. Closings, covers, the end of the site.
Private by default. Temporary by design.The descriptor. Page titles, bios, share images.
Nothing is kept.The short promise. Captions, small spaces.

The personality is calm, direct and a little dry. Poof never shouts, never scares people into privacy and never pretends to be more than it is.

Voice

Short sentences. Plain words. Present tense. Say what Poof does, and just as clearly what it doesn't.

write

  • No account. No email. No phone.
  • The quant-room closes in 10 minutes. Then nothing is left.
  • Poof can't stop someone taking a screenshot.

avoid

  • Unhackable, 100% secure, military-grade.
  • Dates for when quantum computers arrive.
  • Fear, urgency, or long technical words where a short one works.

Logo

The logo has two parts. The mark is a 4×4 checkerboard with the top-left cell empty, always in rust. The wordmark is "Poof" drawn from Chakra Petch SemiBold, with three pixel details: a flag on the P, a drip under the f, and two o's that are eyes looking up and to the right.

Poof logo on a dark background

On dark

cream wordmark · rust mark

Poof logo on a light background

On light

ink wordmark · rust mark

Clear space. Keep at least one mark cell (a quarter of the logo's height) free on every side. Minimum size. 18 px tall on screen for the full logo, 16 px for the mark alone.

The dashed line is the clear space: one mark cell around the logo.

Don't change the logo. These are all wrong:

Stretched
Recolored
Rotated
POOF
Typed in a font
Effects and glows
Low contrast

Color

Rust is the only loud color. Everything else stays quiet so it can do its job. Click a color to copy its hex code.

Frost only appears next to quantum and future topics. No violet, cyan or neon, anywhere.

Typography

Geist

Talk freely. Then poof.

headlines and body · SemiBold for headlines, tight tracking

Geist Mono

quant-room k7q2 · closes in 09:59

labels, system details, crypto · never for long text

Chakra Petch lives only inside the logo. Never use it for text, and never type "Poof" in any font as a logo.

The fox

Poof has one mascot: the fox. It is the same character everywhere, in new poses and moods but never redesigned.

  • Proportions. Upright on two legs, stocky, broad torso, short legs, a slightly oversized head.
  • Face. No beard or facial hair. Expressive, a bit rugged, charming.
  • Look. 3D, rendered with an ordered dither, sometimes as ASCII. Only brand colors.
  • Roles. The Host (idle), the Sleeper (dozing, for anything expired), the Keeper (presenting), the Watcher (gazing up), the Worker (busy), the Skeptic (shrugging, for limits), plus a raised paw for success and a wave for hello.

don't

Add other mascots, change the species or proportions, give it a beard, or recolor it outside the palette.

Emoji

Poof has its own animated emoji for Telegram: the mark, four coins in the brand colors, a poof, and the fox in four moods. They follow the same rules as everything else: brand colors only, pixel edges, quick and quiet motion.

  • Use them in the Poof community and anywhere you talk about Poof.
  • Don't recolor them, stretch them or draw new versions of the fox from them.

All ten are in the Brand kit, ready to download.

Motion

Things appear and disappear through a dither, like a quant-room going poof. Movement is quick and quiet: no bounces, no spins, no confetti. When someone asks their device for reduced motion, Poof shows everything without animation.

previousFAQnextBrand kit
The face of PoofOne fox. Always the same one.

on this page

  • Essence
  • Voice
  • Logo
  • Color
  • Typography
  • The fox
  • Emoji
  • Motion

Brand

Brand kit.

Every official Poof file, ready to use. Preview it here, download one file or take the whole kit.

Download all.zip · 2.7 MB

Use the files as they are, following the Brand book. Please don't use them to suggest that Poof made, sponsors or endorses something it didn't.

Logo

Poof logo for dark backgrounds

Logo, for dark backgrounds

transparent · cream + rust

SVGPNG 1600PNG 800

Poof logo for light backgrounds

Logo, for light backgrounds

transparent · ink + rust

SVGPNG 1600PNG 800

Poof logo, single color version

Logo, one color

SVG · wordmark takes the text color

SVG

Poof logo on a dark tile

Logo on dark tile

PNG · 1200 × 400

PNG

Mark & icons

Poof mark

Mark

transparent · rust

SVGSVG paddedPNG 512PNG 1024PNG 2048

Poof app icon

App icon

PNG · 180 × 180 · white

PNG

Colors

All hex codes, with click to copy, are in the Brand book. For code:

--rust:         #e8661f;
--burnt:        #9c3b14;
--ink:          #1d1f2b;
--stone:        #a7a49b;
--cream:        #fbf7ef;
--frost:        #9db4ff;
--ground-light: #e8e9e4;
--ground-dark:  #16171f;

Social

Poof share image

Share image

PNG · 1200 × 630 · link previews

PNG

Poof cover for X

X cover

PNG · 1500 × 500 and 3000 × 1000

PNG 1500PNG 3000

Poof fox avatar

Avatar, fox

PNG · 400 × 400

PNG

Poof mark avatar

Avatar, mark

PNG · 1000 × 1000

PNG

Telegram

Portal

1280 × 720 · MP4 6 s and JPG

MP4JPG

Welcome

1280 × 720 · MP4 and JPG

MP4JPG

Poof Telegram avatar, ink

Avatar, ink

PNG · 640 × 640

PNG

Poof Telegram avatar, rust

Avatar, rust

PNG · 640 × 640

PNG

Telegram emoji

Ten animated custom emoji, 100 × 100 WEBM, in the format Telegram uses for emoji packs.

MarkWEBM
Coin, inkWEBM
Coin, creamWEBM
Coin, rustWEBM
Coin, stoneWEBM
PoofWEBM
Fox, waveWEBM
Fox, dozeWEBM
Fox, sadWEBM
Fox, gazeWEBM

Fonts

Both brand fonts are free and open source.

  • Geist and Geist Mono: Google Fonts, Geist Mono.
  • Chakra Petch is the source of the wordmark only. You don't need it: the logo files are already drawn.

Questions about the brand: contact@usepoof.chat.

previousBrand book
The KeeperHands you the official files.

on this page

  • Logo
  • Mark & icons
  • Colors
  • Social
  • Telegram
  • Emoji
  • Fonts