Skip to content

Implementations

Jump to bottom
Lucas Pardue edited this page Oct 25, 2023 · 463 revisions

This wiki tracks known implementations of QUIC. See also our Tools listing. Current interop status; make sure you are looking at or editing the correct tab.

Please add your implementation below. Keep sorted alphabetically. There are three sections, one for "IETF QUIC Transport", one for "HTTP/3C", and one for "QPACK". Entries may appear in multiple sections e.g. where a stack provides both IETF QUIC Transport and HTTP/3.

Note

If you are working on a QUIC implementation, please consider joining the QUIC Developers Slack Channel. Also, if possible, please set up a public server and publish its details below, so others can try and interoperate with your code.

IETF QUIC Transport

The following stacks implement the IETF versions of QUIC Transport. They may include an application layer mapping other than IETF HTTP over QUIC e.g. HTTP/0.9

aioquic

QUIC implementation using Python and asyncio.

  • Language: Python
  • Version: draft-29 through version 1
  • Roles: client, server, library
  • Handshake: TLS 1.3
  • Protocol IDs: 0xff00001d, 0xff00001e, 0xff00001f, 0xff000020, 0x1
  • Public server:
    • quic.aiortc.org:443
    • quic.aiortc.org:4434 (Stateless Retry) applicable.

AppleQUIC

AppleQUIC is a client and server implementation.

  • Language: C, Objective-C, Swift
  • Version: draft-29 and version 1
  • Roles: Client, Server
  • Handshake: TLS 1.3 RFC
  • Protocol IDs: 0xff00001d + 0x00000001
  • Public server: N/A
  • Vulnerability reporting: https://support.apple.com/en-us/HT201220

ats

QUIC implementation in Apache Traffic Server

Chromium

Chromium's QUIC Implementation (draft-29 supported in Chrome 85.0.4171.0 and later).

  • Languages: C, C++
  • Versions: Q043, Q046, Q050, T050, T051, draft-27, draft-29.
  • Roles: library, client, server
  • Handshakes: QUIC Crypto, TLS
  • Protocol IDs: Q043, Q046, Q050, T050, T051, 0xff00001b, 0xff00001d
  • ALPNs: h3-Q043, h3-Q046, h3-Q050, h3-T050, h3-T051, h3-27, h3-29
  • Public Servers:
  • Entry in Interop Matrix: ~gQUIC

NOTE: Not to be confused with Cloudflare quiche.

f5

QUIC implementation in F5 TMOS

  • Language: C
  • Version: draft-29 and 32
  • Roles: Server, Client
  • Handshake: RFC 8446
  • Protocol IDs: 0xff00001d, 0xff000020
  • ALPN: h3-29, h3-32. hq-29 and hq-32 available upon request.
  • Public server: f5quic.com:4433. spin, logging, and retry on f5quic.com:4434.

haproxy

QUIC - HTTP/3 implementation in haproxy

  • Language: C
  • Version: draft-29, v1, v2
  • Roles: server
  • Handshake: TLSv1.3 (RFC8446)
  • Protocol IDs: 0xff00001d, 0x00000001, 0x709a50c4
  • ALPN: h3-29, h3, hq-interop
  • Public server: https://www.haproxy.org/, look out for "Site served using" section after a reload

Haskell quic

  • Language: Haskell
  • Version: draft-29
  • Roles: client, server, library
  • Handshake: TLS 1.3
  • Protocol IDs: 0xff00001d
  • Public server: mew.org:443, mew.org:4434 for stateless retry

kwik

Kwik is a QUIC client (and client library) implementation in Java.

  • Language: Java
  • Version: draft-29 through version 1
  • Roles: client, client library, server
  • Handshake: TLS 1.3
  • Protocol IDs: 0xff00001d, 0xff00001e, 0xff00001f, 0xff000020, 0x1

lsquic

LiteSpeed QUIC and HTTP/3 library. Works on Linux, FreeBSD, MacOS, Android, and Windows. Turn-key open-source web server that uses lsquic is available at openlitespeed.org in both source and package forms. Bindings are available for Crystal and Lisp.

  • Language: C
  • Version: v1, Draft-34, Draft-29, Draft-27, Q043, Q046, and Q050.
  • Roles: Client, Server, Library
  • Handshake: QUIC Crypto, RFC 8446
  • Protocol IDs: 0x00000001, 0xFF000022, 0xFF00001D, 0xFF00001B
  • Public server:
    • http3-test.litespeedtech.com:4433, http3-test.litespeedtech.com:4434 (sends stateless retry packets), and http3-test.litespeedtech.com:4435 (faster downloads due to less logging), and :4437 (siduck-00 🦆) for v1, ID-34, ID-29, and ID-27 as well as Google QUIC versions Q043, Q046, and Q050
      • This server supports HTTP/3 and QPACK and provides some services to test transfer of data each way. GET / for details.
      • Delayed ACKs are supported -- versions -01 and -02.
    • www.litespeedtech.com:443 is our production web server.

MsQuic

Microsoft's general purpose (cross-platform) QUIC implementation. Optimized for high performance. More documentation here.

mvfst

mvfst (pronounced move fast) is an implementation of QUIC by Facebook

Neqo

Mozilla/Firefox QUIC and HTTP3 implementation.

  • Language: Rust
  • Version: draft-27 through version 1 and 2.
  • Roles: library, client, server (server is primarily for client testing and has incomplete or missing support for important features like anti-amplification)
  • Handshake: TLS 1.3
  • Protocol IDs: 0x1, 0x709a50c4; h3
  • Public server: None

ngtcp2

ngtcp2 project is an effort to implement IETF QUIC protocol

  • Language: C
  • Version: v1, draft-29, draft-30, draft-31, and draft-32
  • Roles: client, library, server
  • Handshake: TLSv1.3 (RFC 8446)
  • Protocol IDs: 0x00000001, 0xff00001d, 0xff00001e, 0xff00001f, and 0xff000020
  • Public server: nghttp2.org:4433, nghttp2.org:443
  • Vulnerability reporting: https://nghttp2.org/documentation/security.html

nginx

QUIC and HTTP/3 server implementation in nginx

  • Language: C
  • Version: draft-27 .. draft-32
  • Roles: server
  • Handshake: TLSv1.3 (RFC8446)
  • Protocol IDs: 0xff00001b .. 0xff000020
  • Public server: quic.nginx.org:443 (draft-29)

nginx-cloudflare

Implementation of QUIC for NGINX based on quiche, by Cloudflare.

picoquic

A small(ish) implementation of QUIC in C, to explore the protocol and the API, for example for DNS over QUIC. Relies on PicoTLS for TLS 1.3. MIT license. Tested on Windows, Linux, FreeBSD/IOS.

Pluginized QUIC

The PQUIC implementation, a framework that enables QUIC clients and servers to dynamically exchange protocol plugins that extend the protocol on a per-connection basis.

  • Language: C (and eBPF)
  • Version: draft-29
  • Roles: library, client and server
  • Handshake: TLS 1.3 (using picotls)
  • Protocol IDs: 0xff00001d
  • Public server: test.pquic.org:443 (server logs not yet publicly available).

quant

QUANT (QUIC Userspace Accelerated Network Transfers), a BSD-licensed C11 implementation on top of the zero-copy warpcore userspace UDP/IPv4 stack for the netmap packet I/O framework. (Also works over the standard Sockets API.)

QUANT is a general transport library and does NOT implement H3.

  • Language: C
  • Version: draft-33, draft-34, v1
  • Roles: client, library, server
  • Handshake: TLS1.3
  • Protocol IDs: 0xff000021, 0xff000022, 0x1
  • Public server: quant.eggert.org:4433 (and more, see wiki for description)

quiche

quiche is an implementation of the QUIC transport protocol as specified by the IETF. It provides a low level API for processing QUIC packets and handling connection state, while leaving I/O (including dealing with sockets) to the application. Example client and server are also provided.

NOTE: Not to be confused with Google QUICHE.

  • Language: Rust
  • Version: v1, draft-29
  • Roles: library, client, server
  • Handshake: TLSv1.3 (RFC8446)
  • Protocol IDs: 0x00000001, 0xff00001d
  • Public server: quic.tech:4433 (HTTP/0.9 + 0-RTT) / quic.tech:8443 (HTTP/3 + 0-RTT) / quic.tech:8444 (HTTP/3 + Retry)
  • Vulnerability reporting: https://github.com/cloudflare/quiche/security/policy

quicly

QUIC protocol implementation for H2O server

Quinn

Rust implementation with both a synchronous (sans-I/O) interface and an async interface, using rustls for TLS.

  • Language: Rust
  • Version: draft-29 - draft-31, v1, v2
  • Roles: library, client, server
  • Handshake: TLS 1.3

quic-go

A QUIC implementation in Go.

s2n-quic

XQUIC

XQUIC Library released by Alibaba is a cross-platform implementation of IETF QUIC and HTTP/3 protocol.

HTTP/3

The following implement HTTP/3. The "Transport library" field identifies one (or more) of the above stacks if applicable.

Chromium

See entry in the "IETF QUIC Transport" section.

Flupke

Flupke is a HTTP3 client build on top of Kwik.

  • Language: Java
  • Transport library: Kwik
  • HTTP3 Version: draft-29 through version 1
  • QUIC Verson: draft-29 through version 1
  • Roles: client, client library, server
  • Public server: -

lsquic

LiteSpeed QUIC and HTTP/3 library. Works on Linux, FreeBSD, MacOS, and Windows. Turn-key open-source web server that uses lsquic is available at openlitespeed.org in both source and package forms.

  • Language: C
  • Transport Library: lsquic
  • Version: v1, Draft-34, Draft-29, Draft-27.
  • Roles: Client, Server, Library
  • Protocol IDs: 0x00000001, 0xFF000022, 0xFF00001D, 0xFF00001B
  • Public server: www.litespeedtech.com:443

nghttp3

nghttp3 is an implementation of HTTP/3 mapping over QUIC and QPACK in C. It does not depend on any particular QUIC transport implementation.

  • Language: C
  • Transport library: It does not depend on any particular QUIC transport library.
  • HTTP over QUIC Version: draft-32
  • Roles: library
  • Public server: nghttp2.org:4433

proxygen

proxygen implements HTTP/3 mapping over QUIC and QPACK in C++, with MVFST as the transport.

quiche

See entry in the "IETF QUIC Transport" section.

XQUIC

See entry in the "IETF QUIC Transport" section.

QPACK

ls-qpack

A standalone, portable library (Linux, FreeBSD, Windows, MacOS) written in vanilla C. Bindings are available for Go, Python, and TypeScript.

  • Language: C
  • Version: -21

f5

  • Language: C
  • Version: -03

nghttp3

  • Language: C
  • Version: -18

quiche

  • Language: Rust
  • Version: -21

proxygen

  • Language: C++
  • Version: -10

Chromium

See entry in the "IETF QUIC Transport" section.

XQUIC

  • Language: C
  • Version: -21

Top pages

Clone this wiki locally