HTTP/3 runs over QUIC instead of TCP. What is QUIC, why was it built on UDP, and where does TLS fit into it?

## What QUIC actually is QUIC (RFC 9000) is a transport protocol. It sits where TCP sits in the stack and provides the same guarantees applications rely on — reliability, ordering within a stream, flow control, congestion control — plus two things TCP does not have: many **independent streams** within one connection, and **mandatory, integrated encryption**. HTTP/3 (RFC 9114) is the mapping of HTTP semantics onto QUIC: each request/response pair takes a bidirectional QUIC stream, and a few unidirectional streams carry control and header-compression state. The HTTP semantics themselves — methods, status codes, header fields — are unchanged from HTTP/1.1 and HTTP/2. ## Why UDP Three independent reasons, all about deployability: **1. Middlebox ossification.** The internet is full of NATs, firewalls and "optimizers" that inspect and rewrite TCP. A new IP protocol number is dropped by a large fraction of paths, and even new TCP options are often stripped. UDP is one of the two protocols that reliably passes, so it is the only realistic substrate for a new transport. **2. User-space deployment.** TCP lives in the kernel. Changing TCP means shipping OS updates to every client and server, which takes a decade. QUIC is a library linked into the application, so Chrome, Firefox, or your server can change congestion control or loss recovery in a normal release cycle. This is why QUIC evolves quickly. **3. Protection against future ossification.** QUIC encrypts almost everything, including most transport-level header fields (packet numbers, frame types, acknowledgements). Middleboxes cannot parse or "help", so they cannot come to depend on details that would then be frozen forever. Only a small invariant part of the header — a few flag bits and the destination connection ID — is visible. UDP is *not* used for its unreliability. QUIC re-implements acknowledgements, retransmission, and congestion control itself, in user space, on top of UDP datagrams. ## Where TLS fits In the TCP world, TLS is a layer above the transport: you complete a TCP handshake (1 RTT), then a TLS 1.3 handshake (1 more RTT), then send your request. QUIC fuses them (RFC 9001): the TLS 1.3 handshake messages are carried inside QUIC's own CRYPTO frames, and the keys TLS derives are used to protect QUIC packets. There is no such thing as unencrypted QUIC. Consequences: - **A new connection is 1 RTT** to first application data, versus roughly 2–3 for TCP + TLS 1.3 (and more with TLS 1.2). - **A resumed connection can be 0 RTT**: with a pre-shared key from a previous session, the client attaches application data to its very first flight. That data is replayable, so it must be restricted to safe, idempotent requests. - **ALPN in the handshake** selects `h3`, exactly as it selects `h2` over TLS-on-TCP. ## What you get above the handshake The headline transport property is **independent streams**. In TCP everything is one ordered byte stream, so a lost segment blocks delivery of everything behind it, including bytes that belong to unrelated requests. QUIC tracks loss per packet and delivers each stream's data as soon as *that stream's* bytes are complete, so an unrelated stream is unaffected. Additional properties worth naming: **connection IDs** that survive an IP address change, per-stream and connection-level flow control, and pluggable congestion control. ## Practical costs QUIC is not free. Its user-space stack burns noticeably more CPU per byte than kernel TCP with hardware offload — early deployments reported several times the cost, narrowed since by optimized UDP paths (GSO/GRO, `sendmmsg`), better stacks, and offload work. Some networks rate-limit or block UDP, so clients discover HTTP/3 opportunistically and fall back to HTTP/2 over TCP. Operational tooling is different too: connection state lives in the application, so per-connection debugging needs the stack's own logging (qlog) rather than kernel socket tools. ## The summary sentence QUIC is TCP's job re-done in user space over UDP, with TLS 1.3 built in, so that transport features can ship at application speed and so that loss on one stream stops blocking the others.