How QUIC makes File Yeet transfers so fast

Every time you send a file with File Yeet, your data travels over QUIC — a modern transport protocol originally developed by Google and now standardized by the IETF. If you've used a recent version of Chrome or visited a Google or Cloudflare property lately, you've already used QUIC. You just didn't know it.

Understanding why QUIC matters for file transfer requires a brief look at what came before it.

The TCP problem

TCP — Transmission Control Protocol — is the workhorse of the internet. Almost everything you do online runs over it. It's reliable, ordered, and well-understood. It's also 50 years old, and it shows.

TCP was designed for a wired world where packet loss was rare and connections were stable. Today's internet is mobile, wireless, and lossy. TCP has three properties that hurt us here:

• Head-of-line blocking. TCP delivers data in strict order. If one packet is lost, every subsequent packet waits — even if it already arrived. For a single large file this is tolerable. For multiple concurrent streams it's a disaster.
• Slow connection setup. TCP requires a three-way handshake before any data flows. Add TLS on top and you're at 2–3 round trips just to start talking. On a high-latency link, that's hundreds of milliseconds before a single byte of your file is sent.
• No connection migration. A TCP connection is tied to an IP address. Switch from Wi-Fi to cellular, and the connection dies. Everything in flight has to restart.

What QUIC does differently

QUIC is built on UDP instead of TCP, which means it implements its own reliability — but does so in ways that make sense for modern workloads.

Zero-RTT connection establishment. QUIC combines the transport and TLS handshakes into a single step. For a new connection, you're sending data after one round trip instead of three. For a repeated connection to a known peer, QUIC can reach zero round trips — you start sending immediately.

Multiplexed streams without blocking. QUIC has native multiplexing at the protocol level. Multiple independent byte streams share a single connection, and packet loss on one stream doesn't block the others. For File Yeet, this means batch transfers — sending several files at once — don't compete with each other at the transport layer.

Connection migration. QUIC connections are identified by a connection ID, not an IP/port pair. Your transfer survives network changes. Move from Wi-Fi to ethernet mid-transfer, and File Yeet keeps going without you noticing.

Built-in encryption. QUIC is always encrypted. There's no unencrypted QUIC. The encryption isn't bolted on as an afterthought — it's part of the protocol design, which also means the handshake metadata itself is protected in ways TLS over TCP isn't.

iroh: QUIC for peer-to-peer

File Yeet uses iroh, an open-source Rust library that handles P2P connectivity on top of QUIC. iroh adds the layer above raw QUIC that P2P needs: NAT traversal, peer discovery, hole punching, and relay fallback.

When you initiate a transfer, iroh attempts to establish a direct QUIC connection to the other device using a combination of techniques:

• Direct connection when both devices are on the same network — the fastest possible path.
• Hole punching when devices are behind different NATs — works in the majority of real-world cases.
• Encrypted relay as a last resort when a direct path truly isn't possible — still end-to-end encrypted, the relay sees only ciphertext.

All of this happens automatically. You pick a file and hit send — the connection establishment is invisible.

Real-world numbers

On a local gigabit network, File Yeet saturates the link. We've measured sustained throughput above 900 MB/s between two desktops. The bottleneck is disk I/O, not the protocol.

On a typical home broadband connection, transfers move at the full speed of the uplink — there's no server upload step to create a second bottleneck. If your upload is 100 Mbps, the recipient sees roughly 100 Mbps.

Connection setup for a repeat transfer to a known contact is typically under 100 ms, end-to-end. From the moment you hit send to the moment data starts flowing, you're usually waiting less time than it took to read that sentence.

Why this matters beyond benchmarks

Speed numbers are satisfying, but the deeper point is responsiveness. A protocol that sets up fast and recovers from errors fast feels qualitatively different from one that doesn't. QUIC makes File Yeet feel immediate — like handing something over, not like waiting for an upload bar.

That feeling is the goal. File transfer shouldn't feel like filing a form. It should feel like passing something across a table.