Baike.dev
All toolsOnline toolsAI codingTrendingOpen sourceNewsSubmit
Log in
< Back to tools
B

bevy_quinnet

> 编程语言
Open source

A Client/Server game networking plugin using QUIC, for the Bevy game engine.

367 stars0 likes2 views
WebsiteGitHub

About

A Client/Server game networking plugin using QUIC, for the Bevy game engine.

QUIC as a game networking protocol

QUIC seems really attractive as a game networking protocol because most of the hard-work is done by the protocol specification and the implementation (here Quinn). No need to reinvent the wheel once again on error-prones subjects such as a UDP reliability wrapper, encryption & authentication mechanisms or congestion-control.

Most of the features proposed by the big networking libs are supported by default through QUIC. As an example, here is the list of features presented in GameNetworkingSockets:

  • Connection-oriented API (like TCP) -> by default
  • ... but message-oriented (like UDP), not stream-oriented -> by default (*)
  • Supports both reliable and unreliable message types -> by default
  • Messages can be larger than underlying MTU. The protocol performs fragmentation, reassembly, and retransmission for reliable messages -> by default (frag & reassembly is not done by the protocol for unreliable packets)
  • A reliability layer [...]. It is based on the "ack vector" model from DCCP (RFC 4340, section 11.4) and Google QUIC and discussed in the context of games by Glenn Fiedler [...] -> by default.
  • Encryption. [...] The details for shared key derivation and per-packet IV are based on the design used by Google's QUIC protocol -> by default
  • Tools for simulating packet latency/loss, and detailed stats measurement -> Not by default
  • Head-of-line blocking control and bandwidth sharing of multiple message streams on the same connection. -> by default
  • IPv6 support -> by default
  • Peer-to-peer networking (NAT traversal with ICE + signaling + symmetric connect mode) -> Not by default
  • Cross platform -> by default, where UDP is available

-> Roughly 9 points out of 11 by default.

(*) Almost, when sharing a QUIC stream, reliable messages need to be framed.

Features

Quinnet can be used as a transport layer. It currently features:

  • A Client plugin which can:
    • Connect/disconnect to/from one or more server
    • Send & receive unreliable and ordered/unordered reliable messages
  • A Server plugin which can:
    • Accept client connections & disconnect them
    • Send & receive unreliable and ordered/unordered reliable messages
  • Both client & server accept custom protocol structs/enums defined by the user as the message format, as well as raw bytes.
  • Communications are encrypted, and the client can authenticate the server.

Although Quinn and parts of Quinnet are asynchronous, the APIs exposed by Quinnet for the client and server are synchronous. This makes the surface API easy to work with and adapted to a Bevy usage. The implementation uses tokio channels internally to communicate with the networking async tasks.

Quickstart

Message helpers such as send_message and try_receive_message require the bincode-messages feature:

toml
bevy_quinnet = { version = "0.21", features = ["bincode-messages"] }

Receiving payloads uses the default recv_channels feature (receive_payload, etc.).

Client

  • Add the QuinnetClientPlugin to the bevy app:
rust
 App::new()
        // ...
        .add_plugins(QuinnetClientPlugin::default())
        // ...
        .run();
  • You can then use the QuinnetClient resource to connect, send & receive messages:
rust
fn start_connection(mut client: ResMut) {
    client
        .open_connection(ClientConnectionConfiguration {
            addr_config: ClientAddrConfiguration::from_ips(
                SERVER_HOST,
                SERVER_PORT,
                LOCAL_BIND_IP,
                0,
            ),
            cert_mode: CertificateVerificationMode::SkipVerification,
            defaultables: Default::default(),
        })
        .unwrap();

    // Once connected, you will receive a ConnectionEvent
  • To process server messages, you can use a bevy system such as the one below. The function receive_message is generic, here ServerMessage is a user provided enum deriving Serialize and Deserialize.
rust
fn handle_server_messages(
    mut client: ResMut,
    /*...*/
) {
    while let Some(message) = client.connection_mut().try_receive_message() {
        match message {
            // Match on your own message types ...
            ServerMessage::ClientConnected { client_id, username} => {/*...*/}
            ServerMessage::ClientDisconnected { client_id } => {/*...*/}
            ServerMessage::ChatMessage { client_id, message } => {/*...*/}
        }
    }
}

Server

  • Add the QuinnetServerPlugin to the bevy app:
rust
 App::new()
        /*...*/
        .add_plugins(QuinnetServerPlugin::default())
        /*...*/
        .run();
  • You can then use the QuinnetServer resource to start the listening server:
rust
fn start_listening(mut server: ResMut) {
    server
        .start_endpoint(ServerEndpointConfiguration {
            addr_config: EndpointAddrConfiguration::from_ip(Ipv6Addr::UNSPECIFIED, 6000),
            cert_mode: CertificateRetrievalMode::GenerateSelfSigned {
                server_hostname: Ipv6Addr::LOCALHOST.to_string(),
            },
            defaultables: Default::default(),
        })
        .unwrap();
}
  • To process client messages & send messages, you can use a bevy system such as the one below. The function receive_message is generic, here ClientMessage is a user provided enum deriving Serialize and Deserialize.
…

You can also use endpoint.broadcast_message, which will send a message to all connected clients. "Connected" here means connected to the server plugin, which happens before your own app handshakes/verifications if you have any. Use send_group_message if you want to control the recipients.

Channels

There are currently 3 types of channels available when you send a message:

  • OrderedReliable: ensure that messages sent are delivered, and are processed by the receiving end in the same order as they were sent (exemple usage: chat messages)
  • UnorderedReliable: ensure that messages sent are delivered, in any order (exemple usage: an animation trigger)
  • Unreliable: no guarantees on the delivery or the order of processing by the receiving end (exemple usage: an entity position sent every ticks)

When you open a connection/endpoint, some channels are created directly according to the given SendChannelsConfiguration.

rust
// Default channels configuration contains only 1 channel of the OrderedReliable type,
// akin to a TCP connection.
let channels_config = SendChannelsConfiguration::default();
// Creates 2 OrderedReliable channels, and 1 unreliable channel,
// with channel ids being respectively 0, 1 and 2.
let channels_config = SendChannelsConfiguration::from_configs(vec![
    ChannelConfig::default_ordered_reliable(),
    ChannelConfig::default_ordered_reliable(),
    ChannelConfig::default_unreliable(),
]);

Each channel is identified by its own ChannelId. Among those, there is a default channel which will be used when you don't specify the channel. At startup, the first opened channel becomes the default channel.

rust
let connection = client.connection();
// No channel specified, default channel is used
connection.send_message(message);
// Specifying the channel id
connection.send_message_on(channel_id, message);
// Changing the default channel
connection.set_default_channel(channel_id);

In some cases, you may want to create more than one channel instance of the same type. As an example, using multiple OrderedReliable channels to avoid some Head of line blocking issues. Although channels can be defined through a SendChannelsConfiguration, they can also currently be opened & closed at any time. You may have up to 256 differents channels opened simultaneously.

rust
// If you want to create more channels
let chat_channel = client.connection().open_channel(ChannelConfig::default()).unwrap();
client.connection().send_message_on(chat_channel, chat_message);

On the server, channels are created and closed at the endpoint level and exist for all current & future clients.

rust
let chat_channel = server.endpoint().open_channel(ChannelConfig::default()).unwrap();
server.endpoint().send_message_on(client_id, chat_channel, chat_message);

Certificates and server authentication

Bevy Quinnet (through Quinn & QUIC) uses TLS 1.3 for authentication, the server needs to provide the client with a certificate confirming its identity, and the client must be configured to trust the certificates it receives from the server.

Here are the current options available to the server and client plugins for the server authentication:

  • Client :
    • Skip certificate verification (messages are still encrypted, but the server is not authentified)
    • Accept certificates issued by a Certificate Authority (implemented in Quinn, using rustls)
    • Trust on first use certificates (implemented in Quinnet, using rustls)
  • Server:
    • Generate and issue a self-signed certificate
    • Issue an already existing certificate (CA or self-signed)

On the client (cert_mode field of ClientConnectionConfiguration):

rust
// To accept any certificate
cert_mode: CertificateVerificationMode::SkipVerification,
// To only accept certificates issued by a Certificate Authority
cert_mode: CertificateVerificationMode::SignedByCertificateAuthority,
// To use the default configuration of the Trust on first use authentication scheme
cert_mode: CertificateVerificationMode::TrustOnFirstUse(TrustOnFirstUseConfig {
    // Provide your own fingerprint store variable/file,
    // or configure the actions to apply for each possible certificate verification status.
    ..Default::default()
}),

On the server (cert_mode field of ServerEndpointConfiguration):

…

See more about certificates in the certificates readme

Examples

Examples live in the workspace under examples/ and require cloning this repository (they are not included in the crates.io package).

Chat example

This demo comes with a headless server, a terminal client, and a shared protocol in examples/chat/.

Start the server with

cargo run -p bevy-quinnet-chat --bin chat-server

and as many clients as needed with

cargo run -p bevy-quinnet-chat --bin chat-client

Type quit to disconnect with a client.

Breakout versus example

This demo is a modification of the classic Bevy breakout example to turn it into a 2 players versus game.

It hosts a local server from inside a client, instead of a dedicated headless server as in the chat demo. Sources are in examples/breakout/.

It also makes uses of Channels. The server broadcasts the paddle position every tick via the PaddleMoved message on an Unreliable channel, while the BrickDestroyed, BallCollided and the game setup and start are using OrderedReliable channels.

Start two clients with:

cargo run -p bevy-quinnet-breakout

"Host" on one and "Join" on the other.

breakout_versus_demo_short.mp4

Replicon integration

Bevy Quinnet can be used as a transport in bevy_replicon with the provided bevy_replicon_quinnet.

Compatible Bevy versions

bevy_quinnet bevy
0.21

Issues· 0 open

View all issuesOpen on GitHub

No open issues yet, or sync has not completed.

> Tags

Rustbevybevy-plugingame-developmentnetworking

No comments yet. Be the first to share.

> Details

PublishedAug 1, 2026
UpdatedSep 17, 2026
Category编程语言
PricingOpen source

> Related tools

T
TypeScript
JavaScript 的超集,为前端与全栈提供静态类型
P
Python
通用编程语言,广泛用于 Web、数据与 AI
G
Go
Google 推出的简洁高效系统语言