https://github.com/BiagioFesta/wtransport

Async-friendly WebTransport implementation in Rust
https://github.com/BiagioFesta/wtransport

async client http3 network rust server webtransport

Last synced: 3 months ago
JSON representation

Async-friendly WebTransport implementation in Rust

• Host: GitHub
• URL: https://github.com/BiagioFesta/wtransport
• Owner: BiagioFesta
• License: apache-2.0
• Created: 2023-05-11T17:14:44.000Z (over 1 year ago)
• Default Branch: master
• Last Pushed: 2024-04-13T20:54:14.000Z (7 months ago)
• Last Synced: 2024-04-14T10:59:46.129Z (7 months ago)
• Topics: async, client, http3, network, rust, server, webtransport
• Language: Rust
• Homepage:
• Size: 446 KB
• Stars: 309
• Watchers: 7
• Forks: 17
• Open Issues: 16
• Metadata Files:
  • Readme: README.md
  • License: LICENSE-APACHE

Awesome Lists containing this project

README

        


  



[![Documentation](https://docs.rs/wtransport/badge.svg)](https://docs.rs/wtransport/)

[![Crates.io](https://img.shields.io/crates/v/wtransport.svg)](https://crates.io/crates/wtransport)

[![CI](https://github.com/BiagioFesta/wtransport/actions/workflows/ci.yml/badge.svg)](https://github.com/BiagioFesta/wtransport/actions/workflows/ci.yml)

[![Chat](https://img.shields.io/badge/chat-join-blue?logo=discord)](https://discord.gg/KPrrbWe5zg)

# WTransport

[WebTransport](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3/) protocol, pure-*rust*, *async*-friendly.

## Introduction

WebTransport is a new protocol being developed to enable *low-latency*, *bidirectional* communication between clients and servers over the web.

It aims to address the limitations of existing protocols like *HTTP* and *WebSocket* by offering a more *efficient* and *flexible* transport layer.

### Benefits of WebTransport

* :rocket: **Low latency**: WebTransport is designed to minimize latency, making it suitable for real-time applications such as gaming, video streaming, and collaborative editing.

* :arrows_counterclockwise: **Bidirectional communication**: WebTransport allows simultaneous data exchange between the client and server, enabling efficient back-and-forth communication without the need for multiple requests.

* :twisted_rightwards_arrows: **Multiplexing**: With WebTransport, multiple streams can be multiplexed over a single connection, reducing overhead and improving performance.

* :lock: **Security**: WebTransport benefits from the security features provided by the web platform, including transport encryption and same-origin policy.

* :globe_with_meridians: **Native Browser Support**: WebTransport is natively supported in modern web browsers, ensuring seamless integration and enhanced performance for web applications.

 


   Check Library Documentation

 


### Notes

Please be aware that WebTransport is still a *draft* and not yet standardized.

The *WTransport* library, while functional, is not considered completely production-ready.

It should be used with caution and may undergo changes as the WebTransport specification evolves.

## Simple API

 Server 

 Client 

```rust

#[tokio::main]

async fn main() -> Result<()> {

    let config = ServerConfig::builder()

        .with_bind_default(4433)

        .with_identity(&identity)

        .build();

    let connection = Endpoint::server(config)?

        .accept()

        .await     // Awaits connection

        .await?    // Awaits session request

        .accept()  // Accepts request

        .await?;   // Awaits ready session

    let stream = connection.accept_bi().await?;

    // ...

}

```

```rust

#[tokio::main]

async fn main() -> Result<()> {

    let config = ClientConfig::default();

    let connection = Endpoint::client(config)?

        .connect("https://[::1]:4433")

        .await?;

    let stream = connection.open_bi().await?.await?;

    // ...

}

```

## Browser Integration

WebTransport [is supported](https://caniuse.com/mdn-api_webtransport) in modern browsers,

enhancing the capabilities of web applications.

For instance, you can create a native *browser WebTransport* client connecting to a *Rust

server* using the following JavaScript code:

```javascript

// Create a WebTransport instance connecting to the Rust server

let transport = new WebTransport('https://[::1]:4433');

await transport.ready;

// Create a bidirectional stream

let stream = await transport.createBidirectionalStream();

// Send data from the client to the server

await stream.writable.getWriter().write(new TextEncoder().encode("hello"));

// Read data reply from the server

let data = await stream.readable.getReader().read();

console.log(data);

```

Check out the [W3C WebTransport API documentation](https://w3c.github.io/webtransport/) for more details and to

explore the full capabilities of WebTransport in the browser.

## Getting Started

### Clone the Repository

```bash

git clone https://github.com/BiagioFesta/wtransport.git

```

```bash

cd wtransport/

```

### Run `Full` Example

The [`examples/full.rs`](wtransport/examples/full.rs) is a minimal but complete server example that demonstrates the usage of WebTransport.

You can run this example using [*Cargo*](https://rustup.rs/), Rust's package manager, with the following command:

```bash

cargo run --example full

```

This example initiates an *echo* WebTransport server that can receive messages. It also includes an integrated HTTP server.

Open [a supported web browser](https://caniuse.com/mdn-api_webtransport) and navigate to the page http://127.0.0.1:8080.

## Examples

* [Local Examples](wtransport/examples/)

## Other Languages

WTransport has bindings for the following languages:

- Elixir: [wtransport-elixir](https://github.com/bugnano/wtransport-elixir)