Skip the Cloud, Connect the Devices: Iroh 1.0 Revives the P2P Dream

Almost everything you send touches someone’s server first. A one-line message, a single photo — it all detours through a big tech cloud before reaching the person sitting across from you. A project that wants to cut out that middleman just hit a milestone: Iroh, a P2P networking stack written in Rust, shipped its 1.0 release.

Let me be straight up front. This topic generated almost no community buzz — no roaring Hacker News thread, no Reddit pile-on the day it dropped. So instead of summarizing public reaction, this piece digs into what the technology is actually trying to solve, and where it stops short.

Why P2P Has Always Been So Hard

Direct device-to-device connection isn’t a new idea. BitTorrent did it. So did the old peer-to-peer messengers. The problem has never been the concept — it’s that the real internet isn’t built to cooperate.

Most devices live behind a home router, behind a carrier’s NAT. They have no fixed address that the outside world can reach directly. So getting two devices to find each other, punch through their firewalls, and open a direct channel is far trickier than it sounds. This process — hole punching — is the real wall every P2P project slams into.

That’s why so many services gave up and retreated to a central server. Route all traffic through the cloud and connections become reliable, but you inherit the cost and the dependency that come with it. Iroh takes another run at exactly this problem.

The Core Pitch: Dial Any Device

Iroh’s slogan boils down to one phrase: dial any device. If you know the other device’s public key, Iroh will try to reach it directly — whether it’s sitting behind Wi-Fi or riding on a cellular connection.

Here’s how it works. First it attempts a direct connection over every path it can find. If hole punching succeeds, the two devices genuinely talk to each other, peer to peer. Only when direct connection truly fails does traffic fall back to a relay server. The key design choice is that direct is the default and relay is the last resort — not the other way around. And if the network changes mid-session, Iroh re-establishes the path on its own. Move from Wi-Fi to cellular, and the connection holds.

For transport it uses QUIC — the protocol Google built that now underpins HTTP/3. It establishes connections faster than TCP, encrypts by default, and runs multiple independent streams inside a single connection. That design pays off precisely in the flaky conditions P2P lives in.

What That 1.0 Actually Means

In open source, 1.0 isn’t just a version number. It’s closer to a promise: we won’t break the API on you anymore.

Plenty of developers have probably eyed Iroh and held back. A 0.x release can rewrite its entire interface in the next update. 1.0 clears away that uncertainty — a signal that you can wire this into a real product without dreading the next release.

But it’s worth staying clear-eyed. 1.0 does not mean “done.” The fundamental headaches of P2P — the sheer variety of NAT setups, the fickleness of mobile networks, and the cost of relaying when direct connection fails — don’t vanish because a number ticked up.

The Inconvenient Truth About Relay Servers

The most honest thing to say about Iroh is this: the relay server doesn’t go away.

“Fully P2P, fully decentralized” sounds great, but in practice direct connection doesn’t succeed 100% of the time. Some carrier environments block hole punching outright, and when they do, a relay server has to carry the traffic. Which leaves the open questions: who runs that server, and who pays for it.

The saving grace is that you can run the relay yourself. Not being chained to one company’s cloud is a real, meaningful difference from the centralized model. But the accurate framing isn’t “there’s no server” — it’s “we shrink server dependence as much as possible, and even that server is one you control.” Blur that distinction and expectations will land in the wrong place.

So Where Do You Actually Use It

To keep this from sounding abstract, picture the targets: device-to-device file sync, local-first apps, collaborative editors, decentralized messaging. Anywhere you want devices to stay in sync without piling every byte of state into a central server.

That it’s written in Rust matters too. For systems software chasing both memory safety and performance, Rust has become the default pick. And a networking stack — code that has to stay running and stable for hours on end — is exactly the kind of workload Rust suits.

The Takeaway

Iroh 1.0 takes an old dream — that devices could connect directly without a cloud in between — and grounds it in fairly pragmatic engineering. Direct connection first, relay as backup: that practical compromise is the whole point. The refusal to oversell, the posture of “cut the dependency as far as it’ll go,” is what makes it trustworthy.

So ask yourself: does your service’s data really need to pass through someone’s server? Or would your devices be better off just talking to each other? That question feels worth asking seriously again.