HTTP/3
/ aitch-tee-tee-pee THREE /
HTTP/2 made one connection carry many interleaved streams, but it left one stubborn flaw: it still rides on TCP, and TCP delivers all bytes in strict order. Lose one packet, and TCP freezes every stream sharing that connection until the lost packet is resent — even streams that had nothing to do with the loss. HTTP/3 attacks this by abandoning TCP altogether. It runs over QUIC, a newer transport that sits on top of UDP and reinvents reliability and ordering per stream.
Here is the move. QUIC runs over UDP (which is unreliable and unordered) but adds back reliability, congestion control, and ordering itself, inside the application's own software rather than the operating system kernel. Crucially, QUIC tracks each HTTP stream separately: a lost packet only stalls the one stream whose data it carried, while every other stream keeps flowing. QUIC also folds in encryption (the TLS handshake is built into QUIC, so there is no separate TLS round trip) and can finish its setup in fewer round trips, sometimes letting data flow on the very first packet. HTTP/3 is, in one line, HTTP over QUIC.
Why bother with all this? Because the remaining bottleneck was transport-layer head-of-line blocking, and the only way to kill it was to stop using a single ordered TCP byte stream. The trade-offs are honest: QUIC is more complex, lives in user space (so apps update it, not the OS), and uses more CPU than mature TCP; because it is UDP-based, some old firewalls and middleboxes that only expect TCP can interfere with it. But for lossy mobile and Wi-Fi networks — exactly where packet loss is common — independent per-stream delivery is a real, measurable win, which is why major browsers and large sites adopted HTTP/3.
On a flaky phone connection, you load a page with many streams. One UDP packet carrying part of an image is lost. Under HTTP/2-over-TCP, every stream freezes until that packet is resent. Under HTTP/3-over-QUIC, only that one image stalls; the text and other images keep rendering because QUIC delivers each stream independently.
By moving to QUIC over UDP, HTTP/3 makes a lost packet stall only its own stream, not all of them.
HTTP/3 does not magically make the network faster or beat the speed of light — propagation delay is unchanged. Its win is avoiding transport head-of-line blocking and shaving handshake round trips, which matters most on lossy or high-latency links.