From Wikipedia, the free encyclopedia
Jump to: navigation, search

QUIC (Quick UDP Internet Connections, pronounced quick) is an experimental transport layer[1] network protocol designed by Jim Roskind[2] at Google, initially implemented in 2012,[3] and announced as experimentation broadened[4] in 2013.[5][6] 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.[1] It also provides a venue for rapid iteration of congestion avoidance algorithms, placing control into application space at both endpoints, rather than (the relatively slow to evolve) kernel space.


As improving TCP is a long-term goal for Google, QUIC 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 one stream would pause.

Round-trip times, roughly defined by the speed of light, are bounded, and as a result the only way to decrease connection latency 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).[1]

The protocol handles packet loss well; besides packet-level forward error correction,[7] 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.[7] 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 middleboxes which blocked UDP traffic) were mitigated by Chromium connectivity experiments[7] performed before QUIC design[2] 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[edit]

The QUIC code was experimentally developed in Google Chrome starting in 2012,[3] 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. 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.

Server support[edit]

Google servers support QUIC. Google has also published a prototype server.

Devsisters made libQUIC and GoQUIC.

libQUIC is sources and dependencies extracted from Chromium's QUIC Implementation with a few modifications and patches to minimize dependencies needed to build QUIC library.

GoQUIC is the first language binding of libQUIC for Go Programming Language.

Also, quic-reverse-proxy which is a docker image, works as a reverse proxy server between QUIC and HTTP. It makes a general http server to QUIC server.

Source code[edit]

The code is released under a BSD-style license that can be found in the LICENSE file.

Full chromium-side code is available browsable,[8] and in Git.[9]

See also[edit]


  1. ^ a b c Nathan Willis. "Connecting on the QUIC". Linux Weekly News. Retrieved 2013-07-16. 
  2. ^ a b "QUIC: Design Document and Specification Rationale". Jim Roskind, Chromium Contributor. 
  3. ^ a b "First Chromium Code Landing: CL 11125002: Add QuicFramer and friends.". Retrieved 2012-10-16. 
  4. ^ "Experimenting with QUIC". Chromium Official Blog. Retrieved 2013-07-16. 
  5. ^ "QUIC, Google wants to make the web faster". François Beaufort, Chromium Evangelist. 
  6. ^ "QUIC: next generation multiplexed transport over UDP". YouTube. Retrieved 2014-04-04. 
  7. ^ a b c "QUIC: IETF-88 TSV Area Presentation" (PDF). Jim Roskind, Google. Retrieved 2013-11-07. 
  8. ^ Browsable source code
  9. ^ Git

External links[edit]