Compare HTTP/1.1, HTTP/2 and HTTP/3, TCP against UDP, and URI against URL and URN — with the practical effect of each difference.
HTTP/2 moved head-of-line blocking rather than removing it
Many streams share one TCP connection, so one lost segment still stalls all of them. HTTP/3 changes the transport to fix it.
| Version | Transport | Multiplexing | Head-of-line blocking |
|---|---|---|---|
| HTTP/1.01996 | TCP, one connection per request by default | None | Total — one request per connection |
| HTTP/1.11997 | TCP, connections reused | None — pipelining was specified and is effectively unused | Per connection — a slow response blocks everything behind it |
| HTTP/22015 | TCP, one connection | Yes — many concurrent streams on one connection | Removed at the HTTP layer; still present at the TCP layer |
| HTTP/32022 | QUIC over UDP | Yes, with independent streams | Removed at both layers — a lost packet stalls only its own stream |
One request, one connection, close. Effectively extinct.
You will only meet it in a very old client or a hand-written socket test.
Persistent connections and the Host header, which is what made virtual hosting possible.
Browsers open around six connections per origin to work around the lack of multiplexing. That limit is the reason for domain sharding and sprite sheets, both of which became harmful once HTTP/2 arrived.
Multiplexed streams over one connection, with compressed binary headers.
Many small files stop being expensive, so bundling everything into one file and sharding across domains both become counterproductive. Packet loss still stalls every stream, because TCP delivers in order.
The same semantics over QUIC, which fixes the transport-level blocking TCP could not.
Most visible on lossy mobile networks, where one dropped packet no longer stalls every other response. Connection migration also means a handover from wifi to cellular does not drop the connection.
Network Protocol Explainer runs entirely on your device — nothing is measured and no connection is made.
You’re on the Free plan. Compare plans
HTTP/2 did not remove head-of-line blocking, which is the thing most often got wrong about it. It removed it at the HTTP layer — many streams share one connection — and left it at the TCP layer, where a single lost segment stalls every stream on that connection. HTTP/3 fixes it by abandoning TCP for QUIC over UDP, which is why the transport change is the whole point rather than a detail.
That also explains why domain sharding became counterproductive rather than merely unnecessary. Splitting assets across hostnames forces extra connections and defeats the multiplexing that made the upgrade worth having.
TCP against UDP comes down to one trade: TCP guarantees delivery and ordering at the cost of a round trip before any data and head-of-line blocking after loss; UDP guarantees nothing and costs nothing. DNS, QUIC and real-time media use UDP because a late packet is worth less than no packet.
URI, URL and URN are a vocabulary problem rather than a technical one. Every URL is a URI; a URN names something without saying where it is, which is why an ISBN identifies a book rather than a copy of it. When in doubt, URI is the term that is always correct.
These are reference tables. Nothing is measured, no connection is made, and nothing here reports what protocol a given server supports.
Only at the HTTP layer. Many streams share one TCP connection, so a single lost TCP segment still stalls all of them. HTTP/3 solves it by moving to QUIC over UDP, where streams are independent.
No — under HTTP/2 and HTTP/3 it is actively harmful. Each extra hostname means another connection and defeats the multiplexing you upgraded for. It was a sensible workaround for HTTP/1.1's connection limit and is now the opposite.
Because TCP's in-order delivery is what causes head-of-line blocking, and TCP cannot be changed — too much of the internet inspects it. QUIC rebuilds reliability and congestion control on top of UDP, where it can make streams independent.
Yes. URI is the general term for anything identifying a resource; a URL is a URI that also says how to reach it. A URN names without locating — `urn:isbn:…` identifies a book, not a copy you can fetch.
No. Nothing is measured and no connection is made. Checking what a server negotiates needs a real request.