cloudflare/quiche

★ 11,461RustAudience · developerComplexity · 5/5Setup · hard

Mindmap

mindmap
  root((quiche))
    What it does
      QUIC protocol logic
      HTTP/3 support
      Stream management
      Packet processing
    Design
      Low-level API
      No socket management
      App controls IO
    Real-world Use
      Cloudflare edge network
      Android DNS resolver
      curl integration
    Tech Stack
      Rust crate
      QUIC protocol
      HTTP/3 protocol

mindmap root((quiche)) What it does QUIC protocol logic HTTP/3 support Stream management Packet processing Design Low-level API No socket management App controls IO Real-world Use Cloudflare edge network Android DNS resolver curl integration Tech Stack Rust crate QUIC protocol HTTP/3 protocol

Click or tap to explore — scroll the page freely

Things people build with this

USE CASE 1

Build a custom HTTP/3 server or client in Rust with direct control over connection setup, stream handling, and packet pacing.

USE CASE 2

Add QUIC transport support to an existing network application that needs faster, more reliable connections than TCP provides.

USE CASE 3

Integrate HTTP/3 into a Rust-based proxy or edge component, as Cloudflare itself does in production.

Tech stack

Rust

Getting it running

Difficulty · hard Time to first run · 1h+

Low-level building block requiring manual socket and event-loop management, not a plug-and-play HTTP client.

In plain English

Quiche is a Rust library from Cloudflare that implements two internet protocols: QUIC and HTTP/3. QUIC is a relatively new transport protocol designed as a faster alternative to TCP, particularly for web traffic. HTTP/3 is the version of the HTTP protocol built on top of QUIC. Together, they form the foundation of how a growing portion of modern web traffic moves across the internet. This library operates at a low level. It handles the logic of the QUIC protocol itself, things like connection setup, packet processing, stream management, and connection state, but it does not manage sockets or event loops directly. The application using quiche is responsible for reading packets from the network, passing them into the library, and sending out whatever the library produces. This design gives developers control over how the networking I/O is done, at the cost of more setup work compared to a higher-level HTTP client library. The README describes the API in terms of a connect/accept pattern for establishing connections, then send and recv methods for moving packets back and forth. Data within a connection is organized into streams, which can be opened, written to, and read from independently. The library also exposes hints about when to send packets, to help applications avoid sending large bursts of data all at once. Quiche is used in production by Cloudflare's own edge network to handle HTTP/3 traffic. The README also notes that Android's DNS resolver uses quiche for DNS over HTTP/3, and that it can be integrated into the curl command-line tool. These are real-world deployments, not just examples. The library is written in Rust and published as a crate. It is not intended as a plug-and-play HTTP client, it is a building block for developers who need fine-grained control over QUIC connections or are building network infrastructure. The README includes working code examples showing how to configure connections, process incoming packets, and read from streams.

Copy-paste prompts

Prompt 1

I'm building a Rust network application and want to add QUIC support using quiche. Show me how to set up a basic QUIC client that connects to a server and exchanges data over a stream.

Prompt 2

Walk me through implementing a minimal HTTP/3 server using the quiche crate, covering connection setup, handling incoming requests, and sending responses.

Prompt 3

I want to integrate quiche into a C application using the C bindings. Show me the connection lifecycle from receiving the first packet to reading data from a stream.

Prompt 4

How does quiche handle stream backpressure and send pacing hints? Show me how an application should use those hints to avoid bursting packets.

Open on GitHub → Explain another repo

← cloudflare on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.