cloudflare/quichePublic

🥧 Savoury implementation of the QUIC transport protocol and HTTP/3

AI summary: Implementation of the QUIC transport protocol and HTTP/3 written in Rust by Cloudflare.

Stars
12.9K
+12 today
Forks
1.2K
Watchers
166
Open issues
201
Open PRs
204
Contributors
~158
Commits
2.6K
Branches
154
Views (30d)
3

RustBSD-2-ClauseCreated Sep 29, 2018Last push 2d agoLatest release 0.30.1+15 stars this week+72 this month

Quick answers

What is quiche?
Implementation of the QUIC transport protocol and HTTP/3 written in Rust by Cloudflare.
What does quiche do?
Quiche is a low-level library that implements the QUIC transport protocol and the HTTP/3 specification as defined by the IETF. It is designed to provide a robust, performant API for processing QUIC packets and managing complex connection states. The library focuses strictly on the protocol logic, leaving the application responsible for providing actual network I/O and an event loop. This design allows quiche to be highly portable and easily integrated into existing network servers or custom client applications. It currently powers Cloudflare's massive-scale edge network HTTP/3 support.
Who is quiche for?
Quiche is intended for systems programmers and network engineers building high-performance servers or custom networking tools. It requires deep knowledge of network protocols and asynchronous I/O event loops.
How popular is quiche on GitHub?
cloudflare/quiche has 12,876 stars and 1,198 forks on GitHub, and gained 15 stars in the last 7 days.
What license does quiche use?
cloudflare/quiche is released under the BSD-2-Clause license.

Star history

since Jan 20, 2019
05K10KJan 2019Aug 2021Mar 2024Nov 2026
12.9K stars as of Nov 18, 2026. Before Sep 19, 2026, reconstructed from public GitHub event archives (checked against the repository's real star total); since then measured daily.

Update history

1 recorded
  • Nov 18, 2026New release 0.30.1 (previously 0.30.0).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 1 commit2025-12-03: 0 commits2025-12-04: 2 commits2025-12-05: 4 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 1 commit2025-12-11: 2 commits2025-12-12: 3 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 1 commit2025-12-16: 1 commit2025-12-17: 2 commits2025-12-18: 3 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 1 commit2026-01-07: 0 commits2026-01-08: 4 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 2 commits2026-01-14: 0 commits2026-01-15: 4 commits2026-01-16: 6 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 9 commits2026-01-21: 0 commits2026-01-22: 2 commits2026-01-23: 1 commit2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 3 commits2026-01-27: 2 commits2026-01-28: 0 commits2026-01-29: 3 commits2026-01-30: 3 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 1 commit2026-02-03: 4 commits2026-02-04: 2 commits2026-02-05: 1 commit2026-02-06: 2 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 2 commits2026-02-10: 5 commits2026-02-11: 5 commits2026-02-12: 0 commits2026-02-13: 1 commit2026-02-14: 0 commits2026-02-15: 1 commit2026-02-16: 2 commits2026-02-17: 3 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 1 commit2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 2 commits2026-02-24: 0 commits2026-02-25: 2 commits2026-02-26: 4 commits2026-02-27: 3 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 2 commits2026-03-05: 3 commits2026-03-06: 2 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 1 commit2026-03-10: 3 commits2026-03-11: 0 commits2026-03-12: 2 commits2026-03-13: 4 commits2026-03-14: 0 commits2026-03-15: 0 commits2026-03-16: 2 commits2026-03-17: 2 commits2026-03-18: 1 commit2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 0 commits2026-03-25: 0 commits2026-03-26: 3 commits2026-03-27: 7 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 1 commit2026-03-31: 7 commits2026-04-01: 0 commits2026-04-02: 2 commits2026-04-03: 0 commits2026-04-04: 0 commits2026-04-05: 0 commits2026-04-06: 0 commits2026-04-07: 2 commits2026-04-08: 0 commits2026-04-09: 0 commits2026-04-10: 0 commits2026-04-11: 0 commits2026-04-12: 0 commits2026-04-13: 0 commits2026-04-14: 4 commits2026-04-15: 0 commits2026-04-16: 1 commit2026-04-17: 0 commits2026-04-18: 0 commits2026-04-19: 0 commits2026-04-20: 1 commit2026-04-21: 0 commits2026-04-22: 0 commits2026-04-23: 3 commits2026-04-24: 4 commits2026-04-25: 0 commits2026-04-26: 0 commits2026-04-27: 3 commits2026-04-28: 1 commit2026-04-29: 1 commit2026-04-30: 0 commits2026-05-01: 1 commit2026-05-02: 0 commits2026-05-03: 0 commits2026-05-04: 0 commits2026-05-05: 3 commits2026-05-06: 3 commits2026-05-07: 0 commits2026-05-08: 0 commits2026-05-09: 0 commits2026-05-10: 0 commits2026-05-11: 3 commits2026-05-12: 4 commits2026-05-13: 5 commits2026-05-14: 6 commits2026-05-15: 0 commits2026-05-16: 0 commits2026-05-17: 0 commits2026-05-18: 3 commits2026-05-19: 1 commit2026-05-20: 3 commits2026-05-21: 0 commits2026-05-22: 0 commits2026-05-23: 0 commits2026-05-24: 0 commits2026-05-25: 0 commits2026-05-26: 0 commits2026-05-27: 3 commits2026-05-28: 0 commits2026-05-29: 0 commits2026-05-30: 0 commits2026-05-31: 0 commits2026-06-01: 0 commits2026-06-02: 0 commits2026-06-03: 0 commits2026-06-04: 2 commits2026-06-05: 1 commit2026-06-06: 0 commits2026-06-07: 0 commits2026-06-08: 0 commits2026-06-09: 0 commits2026-06-10: 1 commit2026-06-11: 0 commits2026-06-12: 0 commits2026-06-13: 0 commits2026-06-14: 0 commits2026-06-15: 0 commits2026-06-16: 0 commits2026-06-17: 1 commit2026-06-18: 2 commits2026-06-19: 1 commit2026-06-20: 0 commits2026-06-21: 0 commits2026-06-22: 0 commits2026-06-23: 1 commit2026-06-24: 2 commits2026-06-25: 0 commits2026-06-26: 0 commits2026-06-27: 0 commits2026-06-28: 0 commits2026-06-29: 0 commits2026-06-30: 0 commits2026-07-01: 0 commits2026-07-02: 0 commits2026-07-03: 0 commits2026-07-04: 0 commits2026-07-05: 0 commits2026-07-06: 0 commits2026-07-07: 0 commits2026-07-08: 0 commits2026-07-09: 3 commits2026-07-10: 0 commits2026-07-11: 0 commits2026-07-12: 0 commits2026-07-13: 0 commits2026-07-14: 4 commits2026-07-15: 0 commits2026-07-16: 3 commits2026-07-17: 0 commits2026-07-18: 0 commits2026-07-19: 0 commits2026-07-20: 0 commits2026-07-21: 0 commits2026-07-22: 3 commits2026-07-23: 0 commits2026-07-24: 1 commit2026-07-25: 0 commits2026-07-26: 0 commits2026-07-27: 2 commits2026-07-28: 1 commit2026-07-29: 1 commit2026-07-30: 1 commit2026-07-31: 0 commits2026-08-01: 0 commits2026-08-02: 0 commits2026-08-03: 0 commits2026-08-04: 0 commits2026-08-05: 0 commits2026-08-06: 0 commits2026-08-07: 0 commits2026-08-08: 0 commits2026-08-09: 0 commits2026-08-10: 0 commits2026-08-11: 0 commits2026-08-12: 0 commits2026-08-13: 1 commit2026-08-14: 0 commits2026-08-15: 0 commits2026-08-16: 0 commits2026-08-17: 0 commits2026-08-18: 0 commits2026-08-19: 0 commits2026-08-20: 0 commits2026-08-21: 0 commits2026-08-22: 0 commits2026-08-23: 0 commits2026-08-24: 0 commits2026-08-25: 0 commits2026-08-26: 0 commits2026-08-27: 0 commits2026-08-28: 0 commits2026-08-29: 0 commits2026-08-30: 0 commits2026-08-31: 0 commits2026-09-01: 0 commits2026-09-02: 0 commits2026-09-03: 0 commits2026-09-04: 2 commits2026-09-05: 0 commits2026-09-06: 0 commits2026-09-07: 1 commit2026-09-08: 2 commits2026-09-09: 0 commits2026-09-10: 2 commits2026-09-11: 2 commits2026-09-12: 0 commits2026-09-13: 0 commits2026-09-14: 1 commit2026-09-15: 0 commits2026-09-16: 1 commit2026-09-17: 10 commits2026-09-18: 1 commit2026-09-19: 0 commits2026-09-20: 0 commits2026-09-21: 1 commit2026-09-22: 0 commits2026-09-23: 0 commits2026-09-24: 1 commit2026-09-25: 1 commit2026-09-26: 0 commits2026-09-27: 0 commits2026-09-28: 1 commit2026-09-29: 2 commits2026-09-30: 0 commits2026-10-01: 3 commits2026-10-02: 6 commits2026-10-03: 0 commits2026-10-04: 0 commits2026-10-05: 3 commits2026-10-06: 2 commits2026-10-07: 0 commits2026-10-08: 4 commits2026-10-09: 0 commits2026-10-10: 0 commits2026-10-11: 0 commits2026-10-12: 9 commits2026-10-13: 1 commit2026-10-14: 6 commits2026-10-15: 0 commits2026-10-16: 0 commits2026-10-17: 0 commits2026-10-18: 0 commits2026-10-19: 0 commits2026-10-20: 0 commits2026-10-21: 0 commits2026-10-22: 0 commits2026-10-23: 0 commits2026-10-24: 1 commit2026-10-25: 0 commits2026-10-26: 1 commit2026-10-27: 3 commits2026-10-28: 2 commits2026-10-29: 3 commits2026-10-30: 0 commits2026-10-31: 0 commits2026-11-01: 0 commits2026-11-02: 0 commits2026-11-03: 2 commits2026-11-04: 1 commit2026-11-05: 0 commits2026-11-06: 3 commits2026-11-07: 0 commits2026-11-08: 0 commits2026-11-09: 0 commits2026-11-10: 5 commits2026-11-11: 0 commits2026-11-12: 1 commit2026-11-13: 1 commit2026-11-14: 1 commit2026-11-15: 0 commits2026-11-16: 0 commits2026-11-17: 0 commits2026-11-18: 0 commits2026-11-19: 0 commits2026-11-20: 0 commits2026-11-21: 0 commits
315 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    12,876 stars

  • Battle-tested

    8 years of history

  • Community-driven

    ~158 contributors

  • Well documented

    High community health score

  • Permissive license

    BSD-2-Clause

  • Continuous integration

    Automated checks passing

  • Repeat trending

    12 trending appearances

What quiche does

Quiche is a low-level library that implements the QUIC transport protocol and the HTTP/3 specification as defined by the IETF. It is designed to provide a robust, performant API for processing QUIC packets and managing complex connection states. The library focuses strictly on the protocol logic, leaving the application responsible for providing actual network I/O and an event loop. This design allows quiche to be highly portable and easily integrated into existing network servers or custom client applications. It currently powers Cloudflare's massive-scale edge network HTTP/3 support.

Quiche is intended for systems programmers and network engineers building high-performance servers or custom networking tools. It requires deep knowledge of network protocols and asynchronous I/O event loops.

  • QUIC protocol implementation: Fully implements the IETF QUIC transport protocol for low-latency communication.
  • HTTP/3 support: Provides native support for the HTTP/3 application layer protocol over QUIC.
  • Network I/O agnostic: Decouples protocol state management from underlying socket handling and event loops.
  • Memory safe core: Written entirely in Rust to guarantee memory safety and prevent common vulnerabilities.
  • C API bindings: Exports a C API to allow seamless integration into applications written in C or C++.

Where teams use it

Add HTTP/3 to web servers

Integrate the library into existing web server infrastructure to support modern, low-latency HTTP/3 connections.

Build custom QUIC clients

Develop specialized network clients that require the multiplexing and connection migration features of QUIC.

Process QUIC packets securely

Utilize the memory-safe Rust core to parse and validate untrusted QUIC packets at the network edge.

Implement zero-RTT handshakes

Leverage QUIC's 0-RTT capabilities to establish secure connections with minimal latency overhead.

README

master branch

quiche

crates.io docs.rs license build

quiche is an implementation of the QUIC transport protocol and HTTP/3 as specified by the IETF. It provides a low level API for processing QUIC packets and handling connection state. The application is responsible for providing I/O (e.g. sockets handling) as well as an event loop with support for timers.

For more information on how quiche came about and some insights into its design you can read a post on Cloudflare's blog that goes into some more detail.

Who uses quiche?

Cloudflare

quiche powers Cloudflare edge network's HTTP/3 support. The cloudflare-quic.com website can be used for testing and experimentation.

Android

Android's DNS resolver uses quiche to implement DNS over HTTP/3.

curl

quiche can be integrated into curl to provide support for HTTP/3.

Getting Started

Command-line apps

Before diving into the quiche API, here are a few examples on how to use the quiche tools provided as part of the quiche-apps crate. These are not suitable for production environments; see disclaimers and notes.

After cloning the project according to the command mentioned in the building section, the client can be run as follows:

 $ cargo run --bin quiche-client -- https://cloudflare-quic.com/

while the server can be run as follows:

 $ cargo run --bin quiche-server -- --cert apps/src/bin/cert.crt --key apps/src/bin/cert.key

(note that the certificate provided is self-signed and should not be used in production)

Use the --help command-line flag to get a more detailed description of each tool's options.

Configuring connections

The first step in establishing a QUIC connection using quiche is creating a Config object:

let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION)?;
config.set_application_protos(&[b"example-proto"]);

// Additional configuration specific to application and use case...

The Config object controls important aspects of the QUIC connection such as QUIC version, ALPN IDs, flow control, congestion control, idle timeout and other properties or features.

QUIC is a general-purpose transport protocol and there are several configuration properties where there is no reasonable default value. For example, the permitted number of concurrent streams of any particular type is dependent on the application running over QUIC, and other use-case specific concerns.

quiche defaults several properties to zero, applications most likely need to set these to something else to satisfy their needs using the following:

Config also holds TLS configuration. This can be changed by mutators on the an existing object, or by constructing a TLS context manually and creating a configuration using with_boring_ssl_ctx_builder().

A configuration object can be shared among multiple connections.

Connection setup

On the client-side the connect() utility function can be used to create a new connection, while accept() is for servers:

// Client connection.
let conn = quiche::connect(Some(&server_name), &scid, local, peer, &mut config)?;

// Server connection.
let conn = quiche::accept(&scid, None, local, peer, &mut config)?;

Handling incoming packets

Using the connection's recv() method the application can process incoming packets that belong to that connection from the network:

let to = socket.local_addr().unwrap();

loop {
    let (read, from) = socket.recv_from(&mut buf).unwrap();

    let recv_info = quiche::RecvInfo { from, to };

    let read = match conn.recv(&mut buf[..read], recv_info) {
        Ok(v) => v,

        Err(e) => {
            // An error occurred, handle it.
            break;
        },
    };
}

Generating outgoing packets

Outgoing packet are generated using the connection's send() method instead:

loop {
    let (write, send_info) = match conn.send(&mut out) {
        Ok(v) => v,

        Err(quiche::Error::Done) => {
            // Done writing.
            break;
        },

        Err(e) => {
            // An error occurred, handle it.
            break;
        },
    };

    socket.send_to(&out[..write], &send_info.to).unwrap();
}

When packets are sent, the application is responsible for maintaining a timer to react to time-based connection events. The timer expiration can be obtained using the connection's timeout() method.

let timeout = conn.timeout();

The application is responsible for providing a timer implementation, which can be specific to the operating system or networking framework used. When a timer expires, the connection's on_timeout() method should be called, after which additional packets might need to be sent on the network:

// Timeout expired, handle it.
conn.on_timeout();

// Send more packets as needed after timeout.
loop {
    let (write, send_info) = match conn.send(&mut out) {
        Ok(v) => v,

        Err(quiche::Error::Done) => {
            // Done writing.
            break;
        },

        Err(e) => {
            // An error occurred, handle it.
            break;
        },
    };

    socket.send_to(&out[..write], &send_info.to).unwrap();
}
Pacing

It is recommended that applications pace sending of outgoing packets to avoid creating packet bursts that could cause short-term congestion and losses in the network.

quiche exposes pacing hints for outgoing packets through the [at] field of the [SendInfo] structure that is returned by the send() method. This field represents the time when a specific packet should be sent into the network.

Applications can use these hints by artificially delaying the sending of packets through platform-specific mechanisms (such as the SO_TXTIME socket option on Linux), or custom methods (for example by using user-space timers).

Sending and receiving stream data

After some back and forth, the connection will complete its handshake and will be ready for sending or receiving application data.

Data can be sent on a stream by using the stream_send() method:

if conn.is_established() {
    // Handshake completed, send some data on stream 0.
    conn.stream_send(0, b"hello", true)?;
}

The application can check whether there are any readable streams by using the connection's readable() method, which returns an iterator over all the streams that have outstanding data to read.

The stream_recv() method can then be used to retrieve the application data from the readable stream:

if conn.is_established() {
    // Iterate over readable streams.
    for stream_id in conn.readable() {
        // Stream is readable, read until there's no more data.
        while let Ok((read, fin)) = conn.stream_recv(stream_id, &mut buf) {
            println!("Got {} bytes on stream {}", read, stream_id);
        }
    }
}

HTTP/3

The quiche HTTP/3 module provides a high level API for sending and receiving HTTP requests and responses on top of the QUIC transport protocol.

Have a look at the [quiche/examples/] directory for more complete examples on how to use the quiche API, including examples on how to use quiche in C/C++ applications (see below for more information).

Calling quiche from C/C++

quiche exposes a thin C API on top of the Rust API that can be used to more easily integrate quiche into C/C++ applications (as well as in other languages that allow calling C APIs via some form of FFI). The C API follows the same design of the Rust one, modulo the constraints imposed by the C language itself.

When running cargo build, a static library called libquiche.a will be built automatically alongside the Rust one. This is fully stand-alone and can be linked directly into C/C++ applications.

Note that in order to enable the FFI API, the ffi feature must be enabled (it is disabled by default), by passing --features ffi to cargo.

Building

quiche requires Rust 1.88 or later to build. The latest stable Rust release can be installed using rustup.

Once the Rust build environment is setup, the quiche source code can be fetched using git:

 $ git clone https://github.com/cloudflare/quiche

and then built using cargo:

 $ cargo build --examples

cargo can also be used to run the testsuite:

 $ cargo test

Note that BoringSSL, which is used to implement QUIC's cryptographic handshake based on TLS, needs to be built and linked to quiche. This is done automatically by the boring-sys crate when building with cargo, but requires the cmake command to be available during the build process.

On Windows NASM is also required. The official BoringSSL documentation has more details.

In alternative you can use your own custom build of BoringSSL by configuring the BoringSSL directory with the BORING_BSSL_PATH environment variable:

 $ BORING_BSSL_PATH="/path/to/boringssl" cargo build --examples

Building for Android

Building quiche for Android (NDK version 19 or higher, 21 recommended), can be done using cargo-ndk (v2.0 or later).

First the Android NDK needs to be installed, either using Android Studio or directly, and the ANDROID_NDK_HOME environment variable needs to be set to the NDK installation path, e.g.:

 $ export ANDROID_NDK_HOME=/usr/local/share/android-ndk

Then the Rust toolchain for the Android architectures needed can be installed as follows:

 $ rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android

Note that the minimum API level is 21 for all target architectures.

cargo-ndk (v2.0 or later) also needs to be installed:

 $ cargo install cargo-ndk

Finally the quiche library can be built using the following procedure. Note that the -t <architecture> and -p <NDK version> options are mandatory.

 $ cargo ndk -t arm64-v8a -p 21 -- build --features ffi

See build_android_ndk19.sh for more information.

Building for iOS

To build quiche for iOS, you need the following:

  • Install Xcode command-line tools. You can install them with Xcode or with the following command:
 $ xcode-select --install
  • Install the Rust toolchain for iOS architectures:
 $ rustup target add aarch64-apple-ios x86_64-apple-ios
  • Install cargo-lipo:
 $ cargo install cargo-lipo

To build libquiche, run the following command:

 $ cargo lipo --features ffi

or

 $ cargo lipo --features ffi --release

iOS build is tested in Xcode 10.1 and Xcode 11.2.

Building Docker images

In order to build the Docker images, simply run the following command:

 $ make docker-build

You can find the quiche Docker images on the following Docker Hub repositories:

The latest tag will be updated whenever quiche master branch updates.

cloudflare/quiche

Provides a server and client installed in /usr/local/bin.

cloudflare/quiche-qns

Provides the script to test quiche within the quic-interop-runner.

Disclaimers and Notes

⚠️ This repository includes a number of client and server example applications that are provided to demonstrate simple usage of the quiche library API. They are not intended to be used in production environments; no performance, security or reliability guarantees are provided.

Copyright

Copyright (C) 2018-2019, Cloudflare, Inc.

See COPYING for the license.

View on GitHub

Recent activity

commits and pull requests

Recent open issues

view all

Releases and announcements

52 total
  1. 🏁 0.30.10.30.1Nov 10, 2026

    **Highlights**: - Added [`Config::set_max_outstanding_sent_packets()`](https://docs.rs/quiche/0.30.1/quiche/struct.Config.html#method.set_max_outstanding_sent_packets) to configure the maximum number of outstanding sent packets, above which the connection is closed. The default is 22,000 packets. - Added the `congestion_window_unchecked` congestion control algorithm, behind the non-default `congestion_window_unchecked_available` feature, for deployments that limit transmission outside of quiche. Its fixed congestion window can be set with [`Config::set_unchecked_congestion_window()`](https://docs.rs/quiche/0.30.1/quiche/struct.Config.html#method.set_unchecked_congestion_window). - Added [`h3::WireErrorCode::DatagramError`](https://docs.rs/quiche/0.30.1/quiche/h3/enum.WireErrorCode.html#variant.DatagramError) for the `H3_DATAGRAM_ERROR` code defined by RFC 9297. - Fixed several issues in stream FIN, reset and `STOP_SENDING` handling that could hide stream completion, resets or `StreamStopped` errors from the application, or retain stream state until the connection closed. This includes `h3::Connection::poll()` returning `Event::Data` instead of `Event::Reset` when a stream was

  2. 📏 0.30.00.30.0Sep 17, 2026

    **Breaking Changes**: - [`PathEvent`](https://docs.rs/quiche/0.30.0/quiche/enum.PathEvent.html) is now `#[non_exhaustive]` and adds [`PmtuUpdated`](https://docs.rs/quiche/0.30.0/quiche/enum.PathEvent.html#variant.PmtuUpdated). Rust applications that exhaustively match path events must add a wildcard arm. C applications should handle `QUICHE_PATH_EVENT_PMTU_UPDATED` when PMTU discovery is enabled. - The supported `boring` range is now `>=4.19,<6`, so fresh dependency resolution uses 5.x by default while consumers pinned to 4.19 remain supported. Static C applications linking `libquiche.a` must use a C++ linker driver or otherwise link the C++ runtime. Boring 5 enables post-quantum groups by default, which can split the ClientHello across multiple Initial packets. Applications that need smaller or deterministic ClientHellos can use [`Config::set_curves_list()`](https://docs.rs/quiche/0.30.0/quiche/struct.Config.html#method.set_curves_list) or `quiche_config_set_curves_list()`. **Highlights**: - Added [`Connection::stream_readable_len()`](https://docs.rs/quiche/0.30.0/quiche/struct.Connection.html#method.stream_readable_len) to report the contiguous bytes currently readable

  3. ⚔️ 0.29.30.29.3Jul 14, 2026

    **⚠️ Security**: - Fixed unbounded `PathEvent` queue growth when an authenticated peer sends valid packets from rapidly changing source ports. Path events are now bounded by the configured path capacity. - Hardened HTTP/3 frame parsing against memory exhaustion by enforcing payload limits as soon as frame lengths are known, allocating frame buffers incrementally, and skipping unknown frame payloads without buffering them. - Fixed HTTP/3 field-section size enforcement to include the 32-byte per-field overhead required by RFC 9114, preventing the configured limit from being bypassed with many small fields. **Highlights**: - [`h3::Config::new()`](https://docs.rs/quiche/0.29.3/quiche/h3/struct.Config.html#method.new) now advertises and enforces a default `SETTINGS_MAX_FIELD_SECTION_SIZE` of 32 KiB. Applications that accept larger field sections must configure a higher limit with [`h3::Config::set_max_field_section_size()`](https://docs.rs/quiche/0.29.3/quiche/h3/struct.Config.html#method.set_max_field_section_size). - Added [`h3::Config::set_max_priority_update_size()`](https://docs.rs/quiche/0.29.3/quiche/h3/struct.Config.html#method.set_max_priority_update_size) to config

  4. 🛡️ 0.29.20.29.2Jun 19, 2026

    **⚠️ Security**: - Fixed a use-after-free in `quiche_connection_id_iter_next()`, which is part of quiche's C FFI API. The iterator previously returned a pointer to a cloned connection ID whose backing storage was dropped before the caller could read it. It now returns pointers to connection IDs owned by the iterator. - Fixed a use-after-free in `quiche_conn_retired_scid_next()`, which is also part of the C FFI API. The function previously returned a pointer to a retired source connection ID whose backing storage was dropped before the caller could read it. It has been replaced by `quiche_conn_retired_scid_iter()`, which drains retired source connection IDs into an iterator before exposing them to callers. The C FFI API is disabled by default via the `ffi` feature. The normal Rust API is not affected by these issues. **Breaking changes**: - The C API function `quiche_conn_retired_scid_next()` was removed and replaced with `quiche_conn_retired_scid_iter()` to avoid returning pointers to temporary memory. Applications using `quiche_conn_retired_scid_next()` should call `quiche_conn_retired_scid_iter(conn)`, iterate with `quiche_connection_id_iter_next()`, and release the

  5. 🩹 0.29.10.29.1Jun 18, 2026

    **Highlights**: - Added [`Connection::stream_closed()`](https://docs.rs/quiche/0.29.1/quiche/struct.Connection.html#method.stream_closed) to query whether a stream is fully closed. - Fixed bandwidth arithmetic overflow in recovery and pacing calculations at high bandwidth or over long time periods. - Fixed PTO retransmission bookkeeping so consecutive PTOs do not duplicate pending lost frames, while preserving overflow protection. - Increased the PTO backoff cap to allow longer exponential backoff before hitting the cap. - Fixed HTTP/3 stream cleanup when the local send side finishes before the receive side, avoiding stream state leaks. - Late `PRIORITY_UPDATE` frames for closed streams are now ignored instead of recreating HTTP/3 stream state. - Other bug fixes and performance improvements. Full changelog at [0.29.0...0.29.1](https://github.com/cloudflare/quiche/compare/0.29.0...0.29.1)

Code frequency

additions and deletions
+4.6K-4.6KWeek of 2025-11-23: +0 linesWeek of 2025-11-23: -0 linesWeek of 2025-11-30: +601 linesWeek of 2025-11-30: -84 linesWeek of 2025-12-07: +108 linesWeek of 2025-12-07: -167 linesWeek of 2025-12-14: +515 linesWeek of 2025-12-14: -246 linesWeek of 2025-12-21: +0 linesWeek of 2025-12-21: -0 linesWeek of 2025-12-28: +0 linesWeek of 2025-12-28: -0 linesWeek of 2026-01-04: +800 linesWeek of 2026-01-04: -4,584 linesWeek of 2026-01-11: +1,300 linesWeek of 2026-01-11: -104 linesWeek of 2026-01-18: +367 linesWeek of 2026-01-18: -78 linesWeek of 2026-01-25: +2,145 linesWeek of 2026-01-25: -1,126 linesWeek of 2026-02-01: +1,973 linesWeek of 2026-02-01: -554 linesWeek of 2026-02-08: +774 linesWeek of 2026-02-08: -256 linesWeek of 2026-02-15: +871 linesWeek of 2026-02-15: -62 linesWeek of 2026-02-22: +1,199 linesWeek of 2026-02-22: -150 linesWeek of 2026-03-01: +456 linesWeek of 2026-03-01: -334 linesWeek of 2026-03-08: +2,851 linesWeek of 2026-03-08: -2,248 linesWeek of 2026-03-15: +590 linesWeek of 2026-03-15: -67 linesWeek of 2026-03-22: +2,154 linesWeek of 2026-03-22: -902 linesWeek of 2026-03-29: +392 linesWeek of 2026-03-29: -106 linesWeek of 2026-04-05: +327 linesWeek of 2026-04-05: -18 linesWeek of 2026-04-12: +132 linesWeek of 2026-04-12: -33 linesWeek of 2026-04-19: +1,560 linesWeek of 2026-04-19: -224 linesWeek of 2026-04-26: +1,016 linesWeek of 2026-04-26: -28 linesWeek of 2026-05-03: +364 linesWeek of 2026-05-03: -1,096 linesWeek of 2026-05-10: +697 linesWeek of 2026-05-10: -135 linesWeek of 2026-05-17: +298 linesWeek of 2026-05-17: -76 linesWeek of 2026-05-24: +328 linesWeek of 2026-05-24: -19 linesWeek of 2026-05-31: +976 linesWeek of 2026-05-31: -754 linesWeek of 2026-06-07: +0 linesWeek of 2026-06-07: -10 linesWeek of 2026-06-14: +1,007 linesWeek of 2026-06-14: -113 linesWeek of 2026-06-21: +344 linesWeek of 2026-06-21: -374 linesWeek of 2026-06-28: +0 linesWeek of 2026-06-28: -0 linesWeek of 2026-07-05: +7 linesWeek of 2026-07-05: -16 linesWeek of 2026-07-12: +99 linesWeek of 2026-07-12: -81 linesWeek of 2026-07-19: +2,660 linesWeek of 2026-07-19: -526 linesWeek of 2026-07-26: +849 linesWeek of 2026-07-26: -98 linesWeek of 2026-08-02: +0 linesWeek of 2026-08-02: -0 linesWeek of 2026-08-09: +3 linesWeek of 2026-08-09: -0 linesWeek of 2026-08-16: +0 linesWeek of 2026-08-16: -0 linesWeek of 2026-08-23: +0 linesWeek of 2026-08-23: -0 linesWeek of 2026-08-30: +451 linesWeek of 2026-08-30: -541 linesWeek of 2026-09-06: +675 linesWeek of 2026-09-06: -86 linesWeek of 2026-09-13: +1,264 linesWeek of 2026-09-13: -480 linesWeek of 2026-09-20: +121 linesWeek of 2026-09-20: -3 linesWeek of 2026-09-27: +1,697 linesWeek of 2026-09-27: -261 linesWeek of 2026-10-04: +1,606 linesWeek of 2026-10-04: -233 linesWeek of 2026-10-11: +3,335 linesWeek of 2026-10-11: -1,137 linesWeek of 2026-10-18: +33 linesWeek of 2026-10-18: -4 linesWeek of 2026-10-25: +785 linesWeek of 2026-10-25: -205 linesWeek of 2026-11-01: +2,765 linesWeek of 2026-11-01: -323 linesWeek of 2026-11-08: +409 linesWeek of 2026-11-08: -137 linesWeek of 2026-11-15: +0 linesWeek of 2026-11-15: -0 linesNov 23, 2025Nov 15, 2026
+40.9K lines added, -18.1K removed over the last year.

Commits per week

last 52 weeks
180Week of 2025-11-23: 0 commitsWeek of 2025-11-30: 7 commitsWeek of 2025-12-07: 6 commitsWeek of 2025-12-14: 7 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 5 commitsWeek of 2026-01-11: 12 commitsWeek of 2026-01-18: 12 commitsWeek of 2026-01-25: 11 commitsWeek of 2026-02-01: 10 commitsWeek of 2026-02-08: 13 commitsWeek of 2026-02-15: 7 commitsWeek of 2026-02-22: 11 commitsWeek of 2026-03-01: 7 commitsWeek of 2026-03-08: 10 commitsWeek of 2026-03-15: 5 commitsWeek of 2026-03-22: 10 commitsWeek of 2026-03-29: 10 commitsWeek of 2026-04-05: 2 commitsWeek of 2026-04-12: 5 commitsWeek of 2026-04-19: 8 commitsWeek of 2026-04-26: 6 commitsWeek of 2026-05-03: 6 commitsWeek of 2026-05-10: 18 commitsWeek of 2026-05-17: 7 commitsWeek of 2026-05-24: 3 commitsWeek of 2026-05-31: 3 commitsWeek of 2026-06-07: 1 commitsWeek of 2026-06-14: 4 commitsWeek of 2026-06-21: 3 commitsWeek of 2026-06-28: 0 commitsWeek of 2026-07-05: 3 commitsWeek of 2026-07-12: 7 commitsWeek of 2026-07-19: 4 commitsWeek of 2026-07-26: 5 commitsWeek of 2026-08-02: 0 commitsWeek of 2026-08-09: 1 commitsWeek of 2026-08-16: 0 commitsWeek of 2026-08-23: 0 commitsWeek of 2026-08-30: 2 commitsWeek of 2026-09-06: 7 commitsWeek of 2026-09-13: 13 commitsWeek of 2026-09-20: 3 commitsWeek of 2026-09-27: 12 commitsWeek of 2026-10-04: 9 commitsWeek of 2026-10-11: 16 commitsWeek of 2026-10-18: 1 commitsWeek of 2026-10-25: 9 commitsWeek of 2026-11-01: 6 commitsWeek of 2026-11-08: 8 commitsWeek of 2026-11-15: 0 commitsNov 23, 2025Nov 15, 2026
315 commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 1 commitsSun 1:00 — 2 commitsSun 2:00 — 3 commitsSun 3:00 — 1 commitsSun 4:00 — 2 commitsSun 5:00 — 1 commitsSun 6:00 — 0 commitsSun 7:00 — 0 commitsSun 8:00 — 0 commitsSun 9:00 — 0 commitsSun 10:00 — 14 commitsSun 11:00 — 17 commitsSun 12:00 — 16 commitsSun 13:00 — 15 commitsSun 14:00 — 11 commitsSun 15:00 — 1 commitsSun 16:00 — 11 commitsSun 17:00 — 13 commitsSun 18:00 — 11 commitsSun 19:00 — 5 commitsSun 20:00 — 8 commitsSun 21:00 — 3 commitsSun 22:00 — 8 commitsSun 23:00 — 7 commitsMon 0:00 — 8 commitsMon 1:00 — 6 commitsMon 2:00 — 7 commitsMon 3:00 — 4 commitsMon 4:00 — 7 commitsMon 5:00 — 5 commitsMon 6:00 — 4 commitsMon 7:00 — 3 commitsMon 8:00 — 11 commitsMon 9:00 — 10 commitsMon 10:00 — 27 commitsMon 11:00 — 25 commitsMon 12:00 — 35 commitsMon 13:00 — 40 commitsMon 14:00 — 37 commitsMon 15:00 — 42 commitsMon 16:00 — 34 commitsMon 17:00 — 38 commitsMon 18:00 — 19 commitsMon 19:00 — 9 commitsMon 20:00 — 16 commitsMon 21:00 — 13 commitsMon 22:00 — 10 commitsMon 23:00 — 12 commitsTue 0:00 — 9 commitsTue 1:00 — 10 commitsTue 2:00 — 7 commitsTue 3:00 — 4 commitsTue 4:00 — 2 commitsTue 5:00 — 5 commitsTue 6:00 — 2 commitsTue 7:00 — 3 commitsTue 8:00 — 11 commitsTue 9:00 — 12 commitsTue 10:00 — 32 commitsTue 11:00 — 36 commitsTue 12:00 — 55 commitsTue 13:00 — 45 commitsTue 14:00 — 32 commitsTue 15:00 — 43 commitsTue 16:00 — 27 commitsTue 17:00 — 38 commitsTue 18:00 — 16 commitsTue 19:00 — 19 commitsTue 20:00 — 23 commitsTue 21:00 — 9 commitsTue 22:00 — 13 commitsTue 23:00 — 15 commitsWed 0:00 — 7 commitsWed 1:00 — 8 commitsWed 2:00 — 6 commitsWed 3:00 — 6 commitsWed 4:00 — 3 commitsWed 5:00 — 8 commitsWed 6:00 — 3 commitsWed 7:00 — 1 commitsWed 8:00 — 5 commitsWed 9:00 — 33 commitsWed 10:00 — 31 commitsWed 11:00 — 25 commitsWed 12:00 — 29 commitsWed 13:00 — 36 commitsWed 14:00 — 37 commitsWed 15:00 — 42 commitsWed 16:00 — 33 commitsWed 17:00 — 39 commitsWed 18:00 — 17 commitsWed 19:00 — 12 commitsWed 20:00 — 15 commitsWed 21:00 — 10 commitsWed 22:00 — 13 commitsWed 23:00 — 10 commitsThu 0:00 — 9 commitsThu 1:00 — 10 commitsThu 2:00 — 4 commitsThu 3:00 — 1 commitsThu 4:00 — 1 commitsThu 5:00 — 7 commitsThu 6:00 — 2 commitsThu 7:00 — 1 commitsThu 8:00 — 6 commitsThu 9:00 — 11 commitsThu 10:00 — 24 commitsThu 11:00 — 41 commitsThu 12:00 — 37 commitsThu 13:00 — 39 commitsThu 14:00 — 39 commitsThu 15:00 — 55 commitsThu 16:00 — 40 commitsThu 17:00 — 31 commitsThu 18:00 — 22 commitsThu 19:00 — 15 commitsThu 20:00 — 17 commitsThu 21:00 — 13 commitsThu 22:00 — 8 commitsThu 23:00 — 16 commitsFri 0:00 — 16 commitsFri 1:00 — 13 commitsFri 2:00 — 6 commitsFri 3:00 — 3 commitsFri 4:00 — 1 commitsFri 5:00 — 2 commitsFri 6:00 — 4 commitsFri 7:00 — 5 commitsFri 8:00 — 9 commitsFri 9:00 — 16 commitsFri 10:00 — 32 commitsFri 11:00 — 35 commitsFri 12:00 — 37 commitsFri 13:00 — 66 commitsFri 14:00 — 44 commitsFri 15:00 — 47 commitsFri 16:00 — 35 commitsFri 17:00 — 23 commitsFri 18:00 — 19 commitsFri 19:00 — 25 commitsFri 20:00 — 10 commitsFri 21:00 — 7 commitsFri 22:00 — 8 commitsFri 23:00 — 9 commitsSat 0:00 — 10 commitsSat 1:00 — 8 commitsSat 2:00 — 3 commitsSat 3:00 — 2 commitsSat 4:00 — 2 commitsSat 5:00 — 1 commitsSat 6:00 — 0 commitsSat 7:00 — 0 commitsSat 8:00 — 1 commitsSat 9:00 — 3 commitsSat 10:00 — 4 commitsSat 11:00 — 8 commitsSat 12:00 — 15 commitsSat 13:00 — 11 commitsSat 14:00 — 8 commitsSat 15:00 — 20 commitsSat 16:00 — 27 commitsSat 17:00 — 23 commitsSat 18:00 — 10 commitsSat 19:00 — 15 commitsSat 20:00 — 22 commitsSat 21:00 — 7 commitsSat 22:00 — 5 commitsSat 23:00 — 5 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Sep 29, 2026weekly#14+521
Sep 28, 2026weekly#14+521
Sep 27, 2026weekly#13+736
Sep 26, 2026weekly#13+769
Sep 25, 2026weekly#13+741
Sep 24, 2026weekly#11+707
Sep 23, 2026weekly#10+661
Sep 22, 2026daily#6+242
Sep 22, 2026weekly#13+345
Sep 21, 2026daily#6+242
Sep 20, 2026daily#8+5
Sep 19, 2026daily#8+5
  • morluto/rea

    Reverse engineer anything with agents, from app behavior down to native binaries.

    471.6K stars · TypeScript

  • ultraworkers/claw-code

    An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

    194.8K stars · Rust

  • farion1231/cc-switch

    A cross-platform desktop All-in-One assistant for Claude Code, Codex, OpenCode,DeepSeek Harness and more. Only official website: ccswitch.io

    156K stars · Rust

  • openai/codex

    Lightweight coding agent that runs in your terminal

    136K stars · Rust

  • rust-lang/rust

    Empowering everyone to build reliable and efficient software.

    122.3K stars · Rust

  • pbakaus/impeccable

    The design vocabulary for your coding agent. Steer with polish and bolder, review with critique and audit, catch AI slop before it ships.

    114.1K stars · Rust