QUIC
QUIC is a UDP-based transport with built-in streams, TLS 1.3, and congestion control that removes TCP head-of-line blocking and speeds handshakes.
Definition
QUIC is a general-purpose transport protocol built on UDP that provides reliable, ordered streams without the global ordering of TCP. Each stream has its own flow control and reliability, so loss on one does not block others. TLS 1.3 is integrated into the handshake, letting a new connection establish with fewer round trips and a resumed one with zero. Its congestion control runs in user space, so it can be updated without changing the operating system.
Context and scope
The transport beneath HTTP/3, increasingly used for gRPC alternatives and for any application that wants transport flexibility and faster connection setup.
Common misconceptions
- QUIC is only for HTTP — it is a transport usable by any application; HTTP/3 is one mapping onto it
- UDP means unreliable — QUIC builds reliability on top of UDP; the datagrams are just the substrate
- Connection migration is free — it works, but middleboxes that pin connections or block UDP can break it
Anti-patterns
- Deploying QUIC without ensuring UDP is allowed end to end
- Treating the QUIC version as stable forever when the protocol and its implementations evolve
- Ignoring the CPU cost of user-space crypto in high-throughput servers
Related concepts
Authoritative source
What it is
QUIC is a transport protocol implemented over UDP. It offers reliable, ordered delivery per stream, flow control and congestion control, and encryption as part of the handshake. Because ordering is per stream rather than per connection, a lost packet blocks only its stream. Because the handshake combines transport and TLS 1.3, a fresh connection uses fewer round trips and a resumed one can send data immediately. Connection identity is a connection id, not an IP and port pair, which enables migration.
Why it matters
TCP carries the baggage of a single byte stream, an in-kernel implementation, and a handshake separate from TLS. QUIC addresses all three in one design: per-stream ordering removes cross-stream head-of-line blocking, user-space implementation lets it evolve quickly, and the integrated handshake cuts latency. It also resists ossification by middleboxes, because it is encrypted and can therefore evolve features that TCP cannot add.
How to use it well
Ensure UDP is permitted end to end, since many networks and middleboxes still block or rate-limit it, and keep a TCP fallback. Budget for the CPU cost of user-space crypto at high throughput and test how your load balancers handle connection ids and migration. Pin the protocol and library versions deliberately, because both evolve, and validate on realistic lossy networks where QUIC gains the most over TCP.