This article has been nominated to be checked for its neutrality. (April 2016) (Learn how and when to remove this template message)
QUIC (pronounced quick) is an experimental transport layer network protocol designed by Jim Roskind at Google, initially implemented in 2012, and announced publicly in 2013 as experimentation broadened. QUIC supports a set of multiplexed connections between two endpoints over User Datagram Protocol (UDP), and was designed to provide security protection equivalent to TLS/SSL, along with reduced connection and transport latency, and bandwidth estimation in each direction to avoid congestion. QUIC's main goal is to improve perceived performance of connection-oriented web applications that are currently using TCP. It also moves control of the congestion avoidance algorithms into the application space at both endpoints, rather than the kernel space, which it is claimed will allow these algorithms to improve more rapidly.
In June 2015, an Internet Draft of a specification for QUIC was submitted to the IETF for standardization. A QUIC working group was established in 2016. The QUIC working group foresees multipath support and optional forward error correction (FEC) as the next step. The working group also focuses on network management issues that QUIC may introduce, aiming to produce an applicability and manageability statement in parallel to the actual protocol work. Internet statistics in 2018 suggest that QUIC is supported by approximately 0.8 percent of web servers.
This section may be unbalanced towards certain viewpoints. (August 2016)
This section needs additional citations for verification. (August 2016) (Learn how and when to remove this template message)
QUIC, Quick UDP Internet Connections, aims to be nearly equivalent to an independent TCP connection, but with much reduced latency (goal: 0-RTT connectivity overhead) and better SPDY-like stream-multiplexing support. If QUIC features prove effective, those features could migrate into a later version of TCP and TLS (which have a notably longer deployment cycle).
One of the motivations for developing QUIC was that in TCP the delay of a single packet induces head-of-line blocking for an entire set of SPDY streams; QUIC's improved multiplexing support means that only streams carried in that single packet would pause.
A good way to decrease connection latency for an efficiently routed connection is to make fewer round-trips. Much of the work on QUIC is concentrated on reducing the number of round-trips required when establishing a new connection, including the handshake step, encryption setup, and initial data requests. QUIC clients would, for example, include the session negotiation information in the initial packet. This compression is enhanced by QUIC servers, which publish a static configuration record that is concisely referred to. The client also stores a synchronization cookie it received from the server, enabling subsequent connections to incur zero overhead latency (in the best case).[additional citation(s) needed]
The protocol handles packet loss well; QUIC aligns cryptographic block boundaries with packet boundaries, so the impact of packet loss is even lower. While TCP uses congestion windows to avoid congestion (see: TCP congestion avoidance algorithm), which are unforgiving to multiplexed connections, QUIC has a set of modern techniques under review. Among the techniques being tested are packet pacing (with ongoing bandwidth estimation) and proactive speculative retransmission (sending duplicate copies of the most important packets, such as the ones containing error correction or initial encryption negotiation).
QUIC, with its higher level application protocol elements which multiplexes streams (similarly to SPDY), can reduce or compress redundant data transmissions (such as headers). As with SPDY, QUIC benefits greatly from this compression, and is generally able to make numerous HTTP(S) requests within a single initial congestion window.
Concerns about UDP connectivity (re: fears that too many users were behind middle-boxes which blocked UDP traffic) were mitigated by Chromium connectivity experiments performed before QUIC design and implementation efforts began. For the small percentages of users that have UDP blocked, QUIC automatically falls back to TCP based connectivity. Additionally, when there is a perceived risk of UDP being blocked, high performance implementations, such as Chromium's network stack, race a TCP based connection with a QUIC (UDP) connection, ensuring no latency loss at the application level.
Client (browser) support
The QUIC code was experimentally developed in Google Chrome starting in 2012, and was announced as part of Chromium version 29 (released on August 20, 2013) of Chrome. It is currently enabled by default in Chromium, and active sessions can be seen at chrome://net-internals/#quic. In the Chrome browser, experimental QUIC support can be enabled in chrome://flags. There is also a browser extension to indicate which pages are served by QUIC.
Similarly, it has been introduced in Opera 16, it can be turned on at opera://flags/#enable-quic and opera://flags/#enable-quic-https, and active sessions can be seen at opera://net-internals/#quic.
As of 2017 there are three actively maintained implementations. Google servers support QUIC and Google has published a prototype server. A Go implementation called quic-go is also available, and powers experimental QUIC support in the Caddy server. On July 11, 2017, LiteSpeed Technologies officially began supporting QUIC in their load balancer (WebADC) and LiteSpeed Web Server products. As of December 2017, 97.5% of websites using QUIC are running LiteSpeed Web Server.
In addition, there are several stale community projects: libquic was created by extracting the Chromium implementation of QUIC and modifying it to minimize dependency requirements, and goquic provides Go bindings of libquic. Finally, quic-reverse-proxy is a Docker image that acts as a reverse proxy server, translating QUIC requests into plain HTTP that can be understood by the origin server.
The following implementations of QUIC are available in source form:
- Chromium. Language: C++. This is the source code of the Chrome web browser and the reference QUIC implementation. It contains standalone QUIC client and server programs that can be used for testing.
- quic-go. Language: Go. This library provides QUIC support in Caddy web server. Client functionality is also available.
- LSQUIC Client Library. Language: C. This is the QUIC implementation used in LiteSpeed Web Server, minus server-specific bits.
- Quicr and Quinn. Language: Rust.
- Structured Stream Transport
- Constrained Application Protocol (CoAP) - a UDP-based protocol utilizing REST model
- Datagram Transport Layer Security (DTLS)
- Datagram Congestion Control Protocol (DCCP)
- Reliable User Datagram Protocol (RUDP)
- Real-Time Media Flow Protocol (RTMFP)
- Micro Transport Protocol (µTP)
- Multipurpose Transaction Protocol (MTP/IP) – an alternative to QUIC from Data Expedition, Inc.
- Stream Control Transmission Protocol (SCTP UDP Encapsulation; RFC 6951)
- UDP-based Data Transfer Protocol (UDT) – a UDP-based transport protocol
- Fast and Secure Protocol
- Nathan Willis. "Connecting on the QUIC". Linux Weekly News. Retrieved 2013-07-16.
- "QUIC: Design Document and Specification Rationale". Jim Roskind, Chromium Contributor.
- "First Chromium Code Landing: CL 11125002: Add QuicFramer and friends". Retrieved 2012-10-16.
- "Experimenting with QUIC". Chromium Official Blog. Retrieved 2013-07-16.
- "QUIC, Google wants to make the web faster". François Beaufort, Chromium Evangelist.
- "QUIC: next generation multiplexed transport over UDP". YouTube. Retrieved 2014-04-04.
- Lardinois, Frederic. "Google Wants To Speed Up The Web With Its QUIC Protocol". TechCrunch. Retrieved 2016-10-25.
- "Google Will Propose QUIC As IETF Standard". InfoQ. Retrieved 2016-10-25.
- "I-D Action: draft-tsvwg-quic-protocol-00.txt". i-d-announce (Mailing list). 17 Jun 2015.
- "QUIC - IETF Working Group". datatracker.ietf.org. Retrieved 2016-10-25.
- Cui, Yong (2017). "Innovating Transport with QUIC: Design Approaches and Research Challenges". IEEE Internet Computing. 21 (2): 72–76.
- Web Technology Surveys, "Usage of Site Elements for Websites", Retrieved 15-MAY-2018
- Behr, Michael; Swett, Ian. "Introducing QUIC support for HTTPS load balancing". Google Cloud Platform Blog. Google. Retrieved 16 June 2018.
- "QUIC: IETF-88 TSV Area Presentation" (PDF). Jim Roskind, Google. Retrieved 2013-11-07.
- QUIC support in Caddy, Retrieved 13 July 2016.
- LiteSpeed Technologies QUIC Blog Post, Retrieved July 11, 2017.
- "Distribution of web servers among websites that use QUIC".
- QUIC: Design Document and Specification Rationale
- Browsable source code
- QUIC FAQ for Geeks
- Linux Weekly News: Connecting on the QUIC
- QUIC: IETF-88 TSV Area Presentation 2013-11-07
- QUIC: next generation multiplexed transport over UDP
- HTTP over UDP: an Experimental Investigation of QUIC
- Multipath QUIC