A private mesh network you actually own.

Your devices find each other and talk directly — encrypted end to end. On the same LAN they discover each other by themselves, over mDNS/DNS-SD. No account, no port forwarding, no static IPs, and no servers you don't run.

Download the app Install from the terminal

MIT v0.2.30 · alpha zeroconf · mDNS/DNS-SD macOS · Linux · Windows · Pi

your LAN · 192.168.1.0/24 ● mdns — on by default

kestrel

● direct · this device

den-tower

● direct · 2 ms

pi-closet

● headless daemon

nas-01

◆ just announced itself

_myownmesh._tcp.local.
TXT room=a1b2c3d4…
SRV :53412 → sdp, unicast

4 peers · all direct servers touched: 0

Same network ID, and they're talking.

LAN peer via DNS-SD, no server · remote peer via relay

$ myownmesh serve mdns: advertising _myownmesh._tcp.local. · room a1b2c3d4… signaling: online — listening in room a1b2c3d4… peer 6f2e… found on the LAN → connecting peer 6f2e… ACTIVE direct · 3 ms (mdns) peer 9c81… ACTIVE relay · 38 ms (nostr)

go public over wss:// — one command

$ myownmesh install caddy myownmesh.com ✓ Caddy installed. ✓ Wrote reverse-proxy block to /etc/caddy/Caddyfile ✓ Reloaded Caddy. Done. Peers can now reach you at wss://myownmesh.com

Three ways peers find each othernew in 0.2.26

Every network now runs mDNS/DNS-SD beside its relay — pure Rust, no Avahi, no Bonjour — so the fastest path is often no server at all.

Same room? No server.

On a shared LAN peers register a DNS-SD service, spot each other, and dial direct. Clock-free — a device fresh out of the box, before NTP, still gets found.

"signaling": { "mdns": true } // the default

Different networks? A room handle.

Peers meet in a room at a signaling relay — the project's, or yours with one command. It brokers the handshake and never sees your traffic.

myownmesh install caddy your-domain

No internet? No problem.

Set the strategy to "none", leave mDNS on, and co-located devices form a fully air-gapped mesh — zero remote infrastructure, same encryption.

"strategy": "none" · "mdns": true

Get it

The desktop app bundles the daemon, so a bare myownmesh just opens it. Or grab a build straight off the downloads page:

macOS.dmg Windows.msi · .exe Linux.deb · .AppImage Raspberry Piarm64

Prefer the terminal? One line installs the daemon and the app:

# macOS / Linux
curl -fsSL https://myownmesh.net/install.sh | sh

# Windows (PowerShell)
irm https://myownmesh.net/install.ps1 | iex

# From source — needs cargo (https://rustup.rs)
git clone https://github.com/mrjeeves/MyOwnMesh
cd MyOwnMesh
cargo install --path crates/myownmesh

What you build with it

case 1

One app across every device you own

Phone, laptop, workstation, a Pi in the closet — same network ID, all sharing work and state directly. No account, no broker. The devices are the service.

case 2

P2P inside your own Rust app

Add myownmesh-core, define your message types, and your app's devices talk to each other in ~15 lines. No GUI, no Tauri — a narrow library surface.

case 3

A headless fleet of Pis

One static binary, linux-aarch64 included. Drive the whole fleet from a single desktop GUI over each daemon's local control socket.

Run the whole thing yourself

A fresh install connects on the project's reference servers, so it just works. But none of it is infrastructure you're stuck with — every piece is the same binary, ready to host. Flip it on and the fleet finds it.

your box, hosting the mesh's plumbing

$ myownmesh ctl services status signaling ● running :4848 3 peers turn ● running :3478 STUN + TURN (STUN folds in) relay ● running 2 networks

⌁

Be your own discovery

The signaling role is a rendezvous relay your peers use in place of the default. myownmesh install caddy your-domain wraps it in auto-renewing TLS for wss://.

⌁

Be your own NAT traversal

Turn on TURN and you've got STUN + TURN on one port for the peers that can't go direct. Enable both and it just runs the one — nothing to wire up.

⌁

Anywhere — same mesh

On a LAN, riding a tailnet, or out on a public domain: peers connect the same encrypted way, direct or relayed. Same security wherever you put it.

⌁

The fleet self-discovers it

Hosts advertise the roles they offer, so peers find your relay and STUN/TURN on their own — no URLs to hand out. Run a network on infrastructure only you own.

The step-by-step self-hosting guide →

How it works

The LAN finds your peers first

Peers advertise _myownmesh._tcp.local. and browse for their room right on the local network — DNS-SD, pure Rust, no Avahi. Beyond the LAN, a room handle on your relay (or ours) makes the introductions. Both run at once; duplicates get deduped.

WebRTC carries the bytes

Peers hand off to a DTLS-secured data channel — direct when NAT allows, STUN/TURN-assisted when it doesn't. The relay never sees your traffic.

ed25519 proves it's them

A signed nonce exchange plus a short confirmation code authenticates each peer; approved peers persist in a roster. The signatures establish trust — not the relay.

It heals itself, fast

A seven-tier ladder takes the cheapest recovery for each failure. Close the lid and reopen — it spots the resume, redials, and you're back among your peers in seconds.

Embed in your Rust app

Pull the crates as git dependencies pinned to a release tag — your app's devices are meshed in about fifteen lines.

[dependencies]
myownmesh-core      = { git = "https://github.com/mrjeeves/MyOwnMesh", tag = "v0.2.30" }
myownmesh-signaling = { git = "https://github.com/mrjeeves/MyOwnMesh", tag = "v0.2.30" }
tokio = { version = "1", features = ["full"] }

let mesh = Mesh::open(MeshConfig::load().unwrap_or_default()).await?;

let net = mesh.join(NetworkConfig::from_network_id("home", "my-cool-mesh")).await?;

let _signaling = myownmesh_core::engine::attach_signaling(&net.state());  // Nostr + mDNS

let mut events = mesh.events();
while let Ok(event) = events.recv().await {
    println!("{event:?}");          // peers join, messages arrive
}

Typed Channel<T>, generic Rpc, the approval workflow, and clean shutdown are in the quickstart.