Lightyear

A library for writing server-authoritative multiplayer games with Bevy. Compatible with wasm via WebTransport.

https://github.com/cBournhonesque/lightyear/assets/8112632/7b57d48a-d8b0-4cdd-a16f-f991a394c852

Demo using one server with 2 clients. The entity is predicted (slightly ahead of server) on the controlling client and interpolated (slightly behind server) on the other client. The server only sends updates to clients 10 times per second but the clients still see smooth updates.

Getting started

You can first check out the examples.

To quickly get started, you can follow this tutorial, which re-creates the simple_box example.

You can also find more information in this WIP book.

Repository layout

Workspace crate sources live under crates/, grouped by role. Directory names drop the lightyear_ prefix, but Cargo package names keep it.

• crates/io: low-level IO links and backends such as aeronet, link, udp, crossbeam, websocket, and webtransport
• crates/connection: connection abstractions and adapters such as connection, raw_connection, netcode, and steam
• crates/core: the top-level lightyear crate plus shared core, sync, utils, and frame interpolation crates
• crates/inputs: input crates such as inputs, inputs_native, input_bei, and inputs_leafwing
• crates/replication: replication, prediction, and interpolation crates
• crates/transport: serialization, transport, and message crates
• crates/integration: Bevy ecosystem integrations such as Avian
• crates/platform, crates/deterministic, crates/tools, and crates/tests: platform support, deterministic replication, tooling, and test support

Related projects

• lightyear-template: opiniated template for a bevy + lightyear starter project

Games

• Lumina
• cycles.io for bevy jam 5: https://cbournhonesque.itch.io/cyclesio

Features

• Transport-agnostic: Lightyear is compatible with a number of IO backends, including:
  • UDP sockets
  • WebTransport (using QUIC): available on both native and wasm!
  • WebSocket: available on both native and wasm!
  • Steam: use the SteamWorks SDK to send messages over the Steam network
• Serialization
  • Lightyear uses bincode as a default serializer, but you can provide your own serialization function
• Message passing
  • Lightyear supports sending packets with different guarantees of ordering and reliability through the use of channels.
  • Packet fragmentation (for messages larger than ~1200 bytes) is supported
• Input handling
  • Lightyear has special handling for player inputs (mouse presses, keyboards). They are buffered every tick on the Client, and lightyear makes sure that the client input for tick N will be processed on tick N on the server. Inputs are protected against packet-loss: each packet will contain the client inputs for the last few frames.
  • With the leafwing feature, there is a special integration with the leafwing-input-manager crate, where your leafwing inputs are networked for you!
  • Also supports the bevy-enhanced-input crate!
• Deterministic replication
  • Lightyear supports deterministic replication when only inputs are replicated. The simulation needs to be deterministic. The deterministic replication is compatible with both lockstep and prediction/rollback.
• World Replication
  • Entities that have the Replicate bundle will be automatically replicated to clients.
• Advanced replication
  • Client-side prediction: with just a one-line change, you can enable client-prediction with rollback on the client, so that your inputs can feel responsive
  • Snapshot interpolation: with just a one-line change, you can enable Snapshot interpolation so that entities are smoothly interpolated even if replicated infrequently.
  • Client-authoritative replication: you can also replicate entities from the client to the server. The authority over the entity is transferable between the client and the server.

Supported bevy version

Lightyear	Bevy
0.28	0.19
0.26-0.27	0.18
0.25	0.17
0.20-0.24	0.16
0.18-0.19	0.15
0.16-0.17	0.14
0.10-0.15	0.13
0.1-0.9	0.12