HTTP/2 and HTTP/3
HTTP/2 and HTTP/3 are two ways to carry the same HTTP requests and responses more efficiently. HTTP/2 multiplexes streams over TCP, while HTTP/3 maps HTTP onto QUIC so loss on one stream does not stall the others.
itNetworking | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Intro
HTTP/2 and HTTP/3
HTTP defines the meaning of requests and responses. A method such as GET asks for a resource. A status such as 404 reports an outcome. Fields carry metadata. Content carries the representation.
HTTP/2 and HTTP/3 keep those semantics. They change how messages travel between one HTTP client and its immediate peer.
That distinction is the first mental model:
HTTP semantics stay stable
|
+-- HTTP/2: binary HTTP framing over TCP
|
+-- HTTP/3: HTTP framing over QUIC
An application does not become a different API because the connection uses HTTP/3. A proxy can receive HTTP/3 from a user agent and use HTTP/2 to an origin. Each hop negotiates its own protocol version.
Why newer mappings exist
HTTP/1.1 can reuse a connection, but it does not provide a multiplexing layer. Clients often use several TCP connections for concurrent requests. Pipelining only partly addresses concurrency and retains application-layer head-of-line blocking.
HTTP/2 puts each request and response exchange on a stream. Frames from several streams can be interleaved on one connection. A stalled HTTP message does not prevent another stream from making progress at the HTTP layer.
HTTP/2 still runs over TCP. TCP delivers one ordered byte stream. If a TCP segment is lost, later bytes wait until the missing bytes arrive. That transport-level head-of-line blocking can delay every HTTP/2 stream sharing the connection.
HTTP/3 maps HTTP onto QUIC. QUIC provides reliable, ordered delivery within each stream, but it does not impose one total order across all streams. Loss affecting one stream does not stop delivery on another stream whose data has arrived.
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.rfc-editor.org/rfc/rfc9110.html
Supports
- HTTP methods, status codes, fields, content, messages, connections, and intermediary semantics
- Stable HTTP semantics across version-specific mappings
- Safety, idempotency, and replay considerations for requests
- https://www.rfc-editor.org/rfc/rfc9113.html
Supports
- HTTP/2 as binary framing over TCP
- Streams, multiplexing, frame types, flow control, settings, errors, and graceful shutdown
- TLS ALPN negotiation with h2 and deprecation of the h2c upgrade mechanism
- HPACK use and TCP head-of-line blocking limits
- https://www.rfc-editor.org/rfc/rfc7541.html
Supports
- HPACK static and dynamic tables, literal representations, and connection compression state
- Field-list size limits, sensitive-field handling, and compression security considerations
- https://www.rfc-editor.org/rfc/rfc9000.html
Supports
- QUIC as a secure general-purpose transport over UDP
- Independent ordered streams, flow control, congestion control, acknowledgments, and loss recovery
- Connection identifiers, path validation, migration, and address changes
- Zero round-trip data prerequisites and replay risk
- https://www.rfc-editor.org/rfc/rfc9114.html
Supports
- HTTP/3 as a mapping of HTTP semantics over QUIC
- Request streams, control streams, critical unidirectional streams, frames, and settings
- Per-stream progress under loss and remaining connection-level limits
- HTTP/3 endpoint discovery, server push, zero round-trip data, and transition differences from HTTP/2
- https://www.rfc-editor.org/rfc/rfc9204.html
Supports
- QPACK static and dynamic tables
- Dedicated encoder and decoder streams
- Blocked-stream limits, required insert counts, acknowledgments, and cancellation
- Compression-efficiency and blocking-risk tradeoff
- https://www.rfc-editor.org/rfc/rfc7838.html
Supports
- Alternative services as another endpoint for an origin
- Alt-Svc advertisement, authority, lifetime, and security requirements
- https://www.rfc-editor.org/rfc/rfc9308.html
Supports
- QUIC applicability, UDP blocking, fallback, traffic classification, and operational considerations
- Performance dependence on network and application conditions
- Migration, load-balancing, and observability considerations
- https://github.com/sindresorhus/awesome
Supports
- Starting index used to discover networking, testing, and web-performance lists
- https://github.com/denji/awesome-http-benchmark
Supports
- Curation of curl and Hurl as HTTP testing tools
- Curation of h2load as an HTTP/2 benchmarking tool
- Topic relevance to HTTP/2 and HTTP/3 testing and benchmarking
- https://curl.se/docs/http3.html
Supports
- curl HTTP/3 build backends and capability
- HTTP/3-only and fallback modes
- Alt-Svc cache use and HTTP/3 connection testing
- https://hurl.dev/docs/manual.html
Supports
- Hurl request execution and testing
- HTTP/2 and HTTP/3 selection
- Response assertions and protocol-version testing
- https://nghttp2.org/documentation/h2load-howto.html
Supports
- h2load request, client, and concurrent-stream benchmark controls
- ALPN selection, flow-control options, timing-based tests, and HTTP/3 support
- Warning against benchmarking public servers without authorization
