the signals and their derived score are provisional and subject to change.
validate manually before sharing.
4d23d859166a2eab86286eb77a836111938abf68none
# tokio-quiche
## OVERVIEW
Async tokio wrapper for `quiche`. Spawns per-connection IO worker tasks driven by an `ApplicationOverQuic` trait. Ships a ready-made `H3Driver` for HTTP/3. Uses `foundations` for structured logging (slog), telemetry, and settings.
## STRUCTURE
```
src/
lib.rs Re-exports, listen(), capture_quiche_logs()
buf_factory.rs BufFactory: wraps quiche::BufFactory; provides MAX_BUF_SIZE constant
result.rs BoxError = Box<dyn Error+Send+Sync>, QuicResult<T# qlog/
qlog data model for QUIC and HTTP/3 per IETF drafts (`draft-ietf-quic-qlog-main-schema`, `draft-ietf-quic-qlog-quic-events`, `draft-ietf-quic-qlog-h3-events`). Pure data types + serde serialization; no IO (deferred to consumers).
## STRUCTURE
```
src/
lib.rs # Core types: Qlog, QlogSeq, Trace, TraceSeq, VantagePoint, Configuration, Error
streamer.rs # QlogStreamer -- streaming JSON-SEQ writer with state machine
reader.rs # QlogSeqReader -- streaming JSON-SEQ reader/iterat# tokio-quiche/src/quic/
## OVERVIEW
Async QUIC connection management. Splits socket into recv-half (one `InboundPacketRouter` task) and send-half (shared by many `IoWorker` tasks). Entrypoints: `connect()`/`connect_with_config()` for clients, `start_listener()` for servers. `raw` submodule bypasses the router for manual packet injection.
## STRUCTURE
```
mod.rs # Entrypoints: connect, connect_with_config, start_listener
raw.rs # wrap_quiche_conn(): bypass r# PROJECT KNOWLEDGE BASE
**Generated:** 2026-02-20
**Commit:** 89d1850f
**Branch:** master
## OVERVIEW
Cloudflare's QUIC and HTTP/3 implementation in Rust. Workspace of 11 crates: core `quiche` protocol library, `tokio-quiche` async integration, CLI tools (`apps`, `h3i`), logging/analysis (`qlog`, `qlog-dancer`, `netlog`), and supporting primitives (`octets`, `buffer-pool`, `datagram-socket`, `task-killswitch`).
## STRUCTURE
```
quiche/ # Core QUIC+H3 library (C FFI, BoringSSL via b# datagram-socket/
UDP socket abstraction layer shared across the quiche workspace. Two main concerns:
`DgramBuffer` (a headroom-aware zero-copy byte buffer for datagrams) and
`DatagramSocket*` traits (uniform async send/recv over `UdpSocket`/`UnixDatagram`
with Linux `recvmmsg`/`sendmmsg` batching).
## STRUCTURE
```
src/
lib.rs Re-exports, is_nonblocking() helper
buffer.rs DgramBuffer — headroom-aware buffer for zero-copy datagram handling
datagram.rs DatagramSocket/Send/Recv # quiche/src/h3/ — HTTP/3 Module
## OVERVIEW
HTTP/3 wire protocol over QUIC. `Connection` manages H3 state (streams, QPACK, SETTINGS, GOAWAY) on top of `quiche::Connection<F>`. Event-driven: caller loops `poll()` → `Event`. Own `Error`/`Result` types, separate from `quiche::Error`.
## STRUCTURE
```
mod.rs (7549 lines) H3 Connection, Config, Error, Event, Header, NameValue, Priority
stream.rs (1565) H3 stream state machine (Type, State enums; frame parsing FSM)
frame.rs (1337) # recovery/ -- Loss Detection & Congestion Control
## OVERVIEW
QUIC loss detection and congestion control per RFC 9002. Two parallel CC
implementations coexist: `congestion/` (legacy Reno/CUBIC) and `gcongestion/`
(next-gen BBR2 ported from google/quiche). `Recovery` enum dispatches between
`LegacyRecovery` and `GRecovery` via `enum_dispatch` over the `RecoveryOps`
trait (40+ methods).
## STRUCTURE
```
mod.rs Recovery enum, RecoveryOps trait, CongestionControlAlgorithm,
# h3i
## OVERVIEW
Low-level HTTP/3 testing client. Sends arbitrary/malformed H3 frames to probe server RFC compliance. Both library (`lib.rs`) and CLI binary (`main.rs`). Used programmatically as test driver in tokio-quiche integration tests.
## STRUCTURE
```
src/
lib.rs # Crate root: quiche re-export, QPACK encoding, stream type constants
main.rs # CLI binary: clap arg parsing, qlog I/O, dispatches to sync/async client
config.rs # Config struct (QUIC transport p# HTTP/3 Driver (`tokio-quiche/src/http3/driver/`)
## OVERVIEW
Async HTTP/3 driver bridging `quiche::h3::Connection` to Tokio tasks via channels. `H3Driver<H: DriverHooks>` is generic over sealed client/server hooks; users interact through `H3Controller` + typed event/command channels.
## STRUCTURE
| File | Role |
|------|------|
| `mod.rs` | `H3Driver`, `H3Controller`, `H3Event`, `H3Command`, `OutboundFrame`/`InboundFrame`, channel types, `ApplicationOverQuic` impl |
| `hooks.rs` | `DriverHooks` trait # qlog-dancer/
## OVERVIEW
Visualization/analysis tool for qlog and Chrome netlog files. Parses logs into a `Datastore`, extracts time-series into `SeriesStore`, renders PNG charts (native) or canvas plots (wasm). Outputs HTML/text reports with tabled summaries.
Dual-target: native CLI binary (`main.rs`) + wasm-bindgen web UI (`web.rs`, `#[cfg(target_arch = "wasm32")]`). `crate-type = ["lib", "cdylib"]` -- cdylib is for wasm.
## STRUCTURE
```
src/
main.rs CLI entry: parse args via AppCon# quiche/ — Core QUIC + HTTP/3 Library
## OVERVIEW
Low-level QUIC transport and HTTP/3 in Rust. App provides IO/timers; this crate handles protocol state. Also exposes C FFI via `staticlib`/`cdylib`.
## STRUCTURE
```
src/
lib.rs (9k lines) Connection struct, Config, connect()/accept() entry points
h3/
mod.rs (7.5k) HTTP/3 connection — own Error/Result types, NOT quiche::Error
qpack/ QPACK header compression
recovery/
mod.rs Re---
name: quiche-draft-release
description: quiche draft GitHub release automation from a release commit hash or existing tag. Use when creating draft releases for the quiche crate from a quiche/Cargo.toml version bump.
---
# quiche Draft Release
Use this skill when the user asks to create a GitHub draft release for the
`quiche` crate and provides, or should provide, either the commit hash that
bumped `quiche/Cargo.toml` or an existing release tag pointing at that commit.
Do not require a pre-existing tanone