Home

Fortress Rollback

Deterministic Rollback Netcode Built on Correctness

Fortress Rollback is a correctness-first Rust library for peer-to-peer rollback networking in deterministic multiplayer games. Built as a hardened fork of GGRS (Good Game Rollback System), it prioritizes safety, formal verification, and production reliability.

---

Key Features

• Zero-Panic Guarantee — 100% safe Rust with no panics in production code. All operations return proper Result types—your game server won't crash from unexpected states. Learn about error handling
• Rollback Netcode — Peer-to-peer architecture with input prediction and rollback. Hides latency by predicting inputs and seamlessly correcting when actual inputs arrive. Read the architecture
• Formally Verified — Critical paths verified with TLA+ model checking, Z3 SMT proofs, and Kani for Rust. Protocol correctness proven, not just tested. View specifications
• Deterministic by Design — Same inputs = same outputs, guaranteed. Deterministic data structures, hashing, and RNG throughout. No hidden non-determinism. Determinism model

---

Quick Start

Get up and running with Fortress Rollback in minutes.

Cargo.toml

[dependencies]
fortress-rollback = "0.8"
serde = { version = "1.0", features = ["derive"] }

Basic Session

use fortress_rollback::{
    Config, FortressRequest, PlayerHandle, PlayerType,
    SessionBuilder, UdpNonBlockingSocket,
};
use serde::{Deserialize, Serialize};
use std::net::SocketAddr;

// Define your input and state types
#[derive(Copy, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
struct MyInput { buttons: u8 }

#[derive(Clone, Serialize, Deserialize)]
struct MyGameState { frame: i32, /* your state */ }

// Configure Fortress Rollback
struct MyConfig;
impl Config for MyConfig {
    type Input = MyInput;
    type State = MyGameState;
    type Address = SocketAddr;
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a UDP socket and session
    let socket = UdpNonBlockingSocket::bind_to_port(7000)?;
    let remote: SocketAddr = "127.0.0.1:7001".parse()?;

    let mut session = SessionBuilder::<MyConfig>::new()
        .with_num_players(2)?
        .add_player(PlayerType::Local, PlayerHandle::new(0))?
        .add_player(PlayerType::Remote(remote), PlayerHandle::new(1))?
        .start_p2p_session(socket)?;

    // Your game loop handles FortressRequests...
    Ok(())
}

---

Where to Go Next

• User Guide — Complete walkthrough of sessions, inputs, state management, and network events. Start learning
• API Documentation — Full API reference with types, traits, and function signatures. docs.rs
• Architecture — Deep dive into internal architecture, data flow, and protocol design. Explore
• Contributing — Guidelines for contributors, including our zero-panic policy and testing requirements. Contribute

---

Fork of GGRS

Fortress Rollback is a hardened fork of GGRS (Good Game Rollback System). It maintains API compatibility where possible while adding formal verification, eliminating panics, and fixing determinism bugs.

Key improvements over GGRS:

• All panic! and assert! converted to recoverable errors
• Deterministic BTreeMap/BTreeSet instead of HashMap/HashSet
• ~1600 tests with ~92% code coverage
• TLA+, Z3, and Kani formal verification

Full comparison