Phone
Family
Private social for the people you trust
Private social, on your devices.
Create a private group space for families, close friends, clubs, and small teams: chat, posts, photos, and shared canvases without a platform owning the archive. Content lives on approved devices and syncs over your Tailscale private network.
- Group chat
- Posts
- Photos
- Shared canvases
- Device membership
- Home peer
A space, peer to peer
content lives on devices
Private VPN
Tailscale
secure reachability for approved devices
Laptop
Studio
Phone
Club
Home peer
Always on
No content server in the middle
Why this matters
Social software, sized for your trust.
Built for the people you actually know — somewhere to share messages, posts, photos, and canvases without handing any of it to a platform.
Small by design.
Spaces are made for the people you actually know — families, studios, clubs, teams, close friends — not follower graphs or public reach.
Your data stays with you.
Messages, posts, media, and canvas state live on the devices you've approved — phones, laptops, and an optional always-on home peer. There is no Dune content server.
Private by network design.
Tailscale gives approved devices a WireGuard-based private network. Dune uses that as the secure path between peers — before any application-level encryption.
More than chat.
One private place for conversations, lightweight feeds, photo galleries, and shared canvases — plus the peers, devices, and event log that hold it all together.
How it works
Three steps to a private space of your own.
The setup is intentionally small: create a space and a peer identity, add the devices you trust, then let those devices exchange signed and encrypted updates directly.
Create a space.
A space is a shared home for the people who belong there — a family, studio, club, project, or close set of friends. You create a recoverable identity without creating an account on a Dune server.
Approve the devices.
Each phone, laptop, or always-on home peer authorizes onto your peer identity through a signed invite, and joins the space's private Tailscale network so it can reach the others.
Sync peer to peer.
Every change is a signed event. Messages are encrypted to each recipient device; posts are signed and visible to the space. Devices gossip updates directly — no relay server in between.
How Dune compares
Compare the trust model, not just the feature list.
Familiar messaging and community apps are excellent at delivery, reach, and large networks. Dune is for smaller trusted spaces where the group wants chat, posts, media, and shared work without a platform holding the shared history.
| Dune | Signal | Discord | Messenger | ||
|---|---|---|---|---|---|
| Where does history live? | Approved devices in your space; optional home peer | Local devices; optional encrypted backups | Local devices; optional encrypted backups | Discord's hosted service | Local devices plus Meta secure storage |
| What do you need to trust? | The peers you approve and Tailscale for private reachability | Signal for accounts and message delivery | WhatsApp for accounts, delivery, and backup services | Discord to host and operate the community | Meta for accounts, delivery, and storage services |
| How do people join? | Invite a peer, then approve their devices | Phone number signup and contact discovery | Phone number signup and group invites | Account, invite link, or server discovery | Meta account and social graph |
| What is it best for? | Small trusted spaces with device-owned social content | Private messaging and calls | Everyday messaging and large group chats | Large communities, channels, voice, and events | Personal chats tied to Meta's social network |
| Can developers build on it? | Dune Core SDK for clients, peers, and tests | Open app and server code; Signal operates the network | Business and cloud APIs, not third-party clients | Bots and apps on Discord's hosted platform | Meta platform integrations |
Dune runs on Tailscale's private network — there's no Dune service layer between you and the people you trust. Sources: Signal privacy, Signal backups, Signal source, WhatsApp backups, WhatsApp developer hub, Discord developer platform, Discord audio/video encryption, Messenger Platform, and Messenger encryption.
Use Dune
One protocol. A growing list of clients.
The Dune app is the flagship client today — a Flutter app built directly on Dune Core. Dune Core is the shared SDK and protocol layer behind the app, with more first-party and third-party clients planned.
The Dune app.
Spaces, peers, devices, conversations, posts, media galleries, and shared canvases — every feature lives on your network, not on a server.
- iOS
- Android
- macOS
- Linux
- Windows
- Web
More clients.
Web, headless peer, and command-line clients are next on the build list.
Build your own.
Use Dune Core as the foundation for a third-party client, bot, or peer without depending on Dune app internals.
Dune Core
The Dart SDK and protocol shared by every Dune client: identity, signed events, encrypted storage, and peer networking in one package.
Under the hood
For when you want the protocol-level picture.
Dune Core is the Dart SDK and protocol that powers Dune. Five ideas hold it together: peers, devices, signed events, local projections, and peer-to-peer sync.
Peers are people or agents.
A peer is an Ed25519 identity derived from a
BIP39 recovery phrase — cryptographic, not an account on
a Dune server.
Devices are approved nodes.
Each device has its own Ed25519 signing key,
X25519 encryption key, and Tailscale node ID
— bound 1:1, so a revoked device can't rejoin as a fresh
one.
Events are the source of truth.
Every change is a signed, hash-linked event in that device's chain. The log is the durable record; everything else is rebuilt from it.
Projections make apps fast.
Each device materializes the event log into local encrypted SQLite, so screens render from indexed storage rather than replaying the protocol.
Sync is peer to peer.
Approved devices exchange events directly over the private
Tailscale network with hybrid push-pull. Messages are
encrypted end-to-end with XChaCha20-Poly1305;
media is content-addressed by SHA-256 and
fetched lazily.
The SDK
A resource-oriented Dart API.
Apps stay close to product intent. Initialize storage, connect
the runtime, then talk to Dune.space,
Dune.peers, Dune.devices,
Dune.conversations, Dune.messages,
Dune.posts, and Dune.canvas — no
reaching into tables or wire formats.
The same SDK powers Flutter clients, command-line tools, headless bots, and long-running home peers.
- Signatures
- Ed25519
- Key agreement
- X25519
- Message AEAD
- XChaCha20-Poly1305
- KDF + hash
- HKDF-SHA-256
example · dune_quickstart.dart
// Boot the runtime against host-provided storage.
await Dune.runtime.init(
secretStore: platformSecretStore,
directoryConfig: platformDirectories,
);
await Dune.network.connect();
// Bring a peer identity online.
final peer = await Dune.peers.create(
name: 'Jessica',
deviceName: 'MacBook',
);
// Send to a trusted peer.
await Dune.messages.sendText(
'Hello from Dune',
recipients: [peer.peerKey],
);
final recent = await
Dune.messages.query().latest(limit: 50).get();Package surfaces
| Library | Audience | Purpose |
|---|---|---|
| dune_core.dart | App developers |
Stable resource APIs: Dune.space,
Dune.peers, Dune.devices,
Dune.conversations,
Dune.messages, Dune.posts,
Dune.canvas, Dune.media,
Dune.search.
|
| dune_core_protocol.dart | Protocol tooling | Event models, Dune Canonical JSON v1 helpers, and DTOs for advanced consumers and non-Dart implementations. |
| dune_core_testing.dart | App and SDK tests | Supported peer harnesses and deterministic testing helpers for realistic multi-peer scenarios. |
The point
Social software can be smaller, quieter, and owned by the people in it.
Dune is in a pre-1.0 launch phase. The app-facing API is intended to be usable by real clients today; the protocol, test vectors, and package boundaries are still being hardened before a stable 1.0 contract.