The crates.

The game-backend framework: tokio + axum, modules with hooks, accounts and sessions, a WebSocket hub, storage (saves) and chat, MySQL / PostgreSQL / SQLite, migrations, OpenAPI + AsyncAPI. A library you build your own server binary with.

net_backend_server = { version = "0.1.0" }   # features: mysql (default), postgres, sqlite, storage, chat, steam, smtp

The shared message types: plain Rust + serde, no networking, no async runtime, no engine. The server and Rust clients import the same types, so both sides agree on every request, answer and push, and on the exact JSON they become. The JSON on the wire is the real contract; this crate is the convenience for Rust and the single source of truth.

net_backend_protocol = { version = "0.1.0" }
# With the optional client integration:
# net_backend_protocol = { version = "0.1.0", features = ["bevy_net_backend"] }

The Rust client, built on the protocol, for Rust apps that do not use Bevy: other engines, tools, bots, command-line programs and admin tools.

• Every HTTP route, typed. client.call(&request) takes any request of the protocol, or a game's own route described the same way, and answers its typed response. Errors carry the server's stable error code.
• The session, handled. Register, log in (email + password or a Steam ticket), log out or log out everywhere. The access token is refreshed before it expires, one refresh at a time for every caller; a call answered 401 is retried once after a refresh; every new token pair is handed to your app so it can store it.
• Async or blocking. One async core on tokio, plus a blocking interface for game loops and simple programs: send now, pick up the answer later with try_take(), from any thread. Nothing ever blocks a game frame.
• A WebSocket that reconnects by the rules (feature ws): typed requests and answers, typed server pushes, heartbeats, automatic reconnects with backoff that never retry after a "do not come back" close code.
• SSH and SFTP to the server machine (features ssh, sftp) for admin tools: commands and file transfer to its OpenSSH, strict host-key checks, Terrapin protection.
• Small. TLS with rustls + ring, no OpenSSL; HTTP and the WebSocket use the same crates as the server, so an app that also runs the server adds no new crate for them.

net_backend_client = { version = "0.1.0" }
# or with the WebSocket:
net_backend_client = { version = "0.1.0", features = ["ws"] }
# an admin tool with SSH and SFTP:
net_backend_client = { version = "0.1.0", features = ["ws", "sftp"] }

use net_backend_client::protocol::auth::{GetAccount, LoginRequest};
use net_backend_client::protocol::storage::{GetObject, PutObject, WriteObject};
use net_backend_client::{Client, Error};

let client = Client::new("https://api.example.com")?;
client.login(LoginRequest::new("player@example.com", "a long password")).await?;

let me = client.call(&GetAccount::new()).await?;
client.call(&WriteObject::new("saves", "slot-1", PutObject::new(serde_json::json!({"level": 3})))).await?;
let save = client.call(&GetObject::new("saves", "slot-1")).await?;
println!("{:?} is on level {}", me.display_name, save.value["level"]);

use net_backend_client::blocking::Client;
use net_backend_client::protocol::auth::{GetAccount, LoginRequest};

let client = Client::new("https://api.example.com")?;
client.login(LoginRequest::new("player@example.com", "a long password"))?; // blocks (start-up)

let mut me = client.send(GetAccount::new()); // never blocks
loop {
    // ... one frame of the game ...
    if let Some(answer) = me.try_take() {
        println!("hello {:?}", answer?.display_name);
        break;
    }
}

The protocol's types are re-exported as net_backend_client::protocol, so the versions always match. The crate's tests run the real net_backend_server in the same process, plus an in-process mock SSH server. Compatible with net_backend_server 0.1.x (protocol version 1), Rust 1.95+.

Connects a Bevy game to its own backend, with the same features as Bevy plugins: HTTP (default) with your serde types and file uploads, WebSocket (feature ws) with reconnect and heartbeat built in, and SSH and SFTP (features ssh, sftp) for admin and developer tools. A system fires a request and gets a RequestId back at once; a few frames later exactly one typed answer arrives as a Bevy message.

Source and manual: github.com/warmar94/bevy_net_backend.