42 stable releases

1.37.0 Apr 20, 2024
1.34.0 Mar 13, 2024
1.32.0 Dec 8, 2023
1.31.0 Nov 6, 2023
0.0.0 Feb 16, 2022

#27 in Network programming

Download history 913/week @ 2024-01-22 445/week @ 2024-01-29 607/week @ 2024-02-05 1496/week @ 2024-02-12 1058/week @ 2024-02-19 1339/week @ 2024-02-26 1253/week @ 2024-03-04 569/week @ 2024-03-11 1532/week @ 2024-03-18 1146/week @ 2024-03-25 973/week @ 2024-04-01 966/week @ 2024-04-08 1204/week @ 2024-04-15 951/week @ 2024-04-22 1131/week @ 2024-04-29 1552/week @ 2024-05-06

5,000 downloads per month
Used in 10 crates (6 directly)


104K SLoC


s2n-quic is a Rust implementation of the IETF QUIC protocol, featuring:

See the API documentation and examples to get started with s2n-quic.

Crates.io docs.rs Apache 2.0 Licensed Build Status Dependencies MSRV


s2n-quic is available on crates.io and can be added to a project like so:

s2n-quic = "1"

NOTE: On unix-like systems, s2n-tls will be used as the default TLS provider. On linux systems, aws-lc-rs will be used for cryptographic operations. A C compiler and CMake may be required on these systems for installation.


The following implements a basic echo server and client. The client connects to the server and pipes its stdin on a stream. The server listens for new streams and pipes any data it receives back to the client. The client will then pipe all stream data to stdout.


// src/bin/server.rs
use s2n_quic::Server;
use std::{error::Error, path::Path};

async fn main() -> Result<(), Box<dyn Error>> {
    let mut server = Server::builder()
        .with_tls((Path::new("cert.pem"), Path::new("key.pem")))?

    while let Some(mut connection) = server.accept().await {
        // spawn a new task for the connection
        tokio::spawn(async move {
            while let Ok(Some(mut stream)) = connection.accept_bidirectional_stream().await {
                // spawn a new task for the stream
                tokio::spawn(async move {
                    // echo any data back to the stream
                    while let Ok(Some(data)) = stream.receive().await {
                        stream.send(data).await.expect("stream should be open");



// src/bin/client.rs
use s2n_quic::{client::Connect, Client};
use std::{error::Error, path::Path, net::SocketAddr};

async fn main() -> Result<(), Box<dyn Error>> {
    let client = Client::builder()

    let addr: SocketAddr = "".parse()?;
    let connect = Connect::new(addr).with_server_name("localhost");
    let mut connection = client.connect(connect).await?;

    // ensure the connection doesn't time out with inactivity

    // open a new stream and split the receiving and sending sides
    let stream = connection.open_bidirectional_stream().await?;
    let (mut receive_stream, mut send_stream) = stream.split();

    // spawn a task that copies responses from the server to stdout
    tokio::spawn(async move {
        let mut stdout = tokio::io::stdout();
        let _ = tokio::io::copy(&mut receive_stream, &mut stdout).await;

    // copy data from stdin and send it to the server
    let mut stdin = tokio::io::stdin();
    tokio::io::copy(&mut stdin, &mut send_stream).await?;


Minimum Supported Rust Version (MSRV)

s2n-quic will maintain a rolling MSRV (minimum supported rust version) policy of at least 6 months. The current s2n-quic version is not guaranteed to build on Rust versions earlier than the MSRV.

The current MSRV is 1.71.0.

Security issue notifications

If you discover a potential security issue in s2n-quic we ask that you notify AWS Security via our vulnerability reporting page. Please do not create a public github issue.

If you package or distribute s2n-quic, or use s2n-quic as part of a large multi-user service, you may be eligible for pre-notification of future s2n-quic releases. Please contact s2n-pre-notification@amazon.com.


This project is licensed under the Apache-2.0 License.


~492K SLoC