Crate orbit_rs 

orbit-rs — fleet-aware shared-memory rings

See the repository VISION.md for the broader design direction.

What this crate is

Fleet-shared, network-aware ring storage — the same-host tier between APCu (per-worker) and Redis (cross-host).

local var       — register-fast,    no sharing
APCu            — process-fast,     per-worker
Orbit           — fleet-shared,     same-host    ← here
Redis           — cluster-shared,   cross-host
PostgreSQL      — durable,          cross-time

What this crate is NOT

• Not bound to any application framework. The crate exposes runtime primitives; framework-specific wiring belongs in adapter crates above it.
• Not a service. Orbit has its own fleet handle, but no application lifecycle.
• Not a database or message broker. The crate exposes rings and small substrates such as OrbitCache; product-facing services live in adapters above it.

Three Musketeers

Hepimiz birimiz, birimiz hepimiz. — Dumas

All for one, one for all.

Every process in the fleet is an equal member. There is no master, no worker — only peers. Whatever role distinction matters to the embedder is the embedder’s concern; not Orbit’s.

Status — first light (V0)

V0 ships the ring API surface plus POSIX shared-memory backing on Unix. Higher-level data shapes should build on rings/cache directly instead of adding one-off shared cells here.

Re-exports

pub use cache::CACHE_PAYLOAD_MAX;

pub use cache::OrbitCache;

pub use cache::OrbitCacheEntry;

pub use cache::OrbitCacheRead;

pub use contest::guard::CONTEST_FRAME_KIND_CLAIM;

pub use contest::guard::CONTEST_FRAME_KIND_RELEASE;

pub use contest::guard::CONTEST_PAYLOAD_MAX;

pub use contest::guard::CONTEST_RING_KIND;

pub use contest::guard::Claim;

pub use contest::guard::Contest;

pub use contest::guard::ContestOwner;

pub use contest::guard::ContestRecord;

pub use contest::guard::ContestSubject;

pub use contest::guard::ContestType;

pub use contest::guard::Guard;

pub use contest::guard::Holder;

pub use error::Error;

pub use error::Result;

pub use event::EVENT_PAYLOAD_MAX;

pub use event::EVENT_RING_KIND;

pub use event::OrbitEvent;

pub use event::OrbitEventBus;

pub use event::OrbitEventCursor;

pub use event::OrbitEventPoll;

pub use fleet::DEFAULT_RING_CAPACITY;

pub use fleet::FLEET_HEARTBEAT_RING_KIND;

pub use fleet::Fleet;

pub use fleet::FleetHeartbeat;

pub use fleet::FleetHeartbeatRecord;

pub use fleet::FleetHeartbeatSnapshot;

pub use fleet::NodeId;

pub use orbital::Orbital;

pub use ring::cursor::RingCursor;

pub use ring::cursor::RingFrameSource;

pub use ring::cursor::RingLoss;

pub use ring::cursor::RingPoll;

pub use ring::cursor::poll_ring;

pub use ring::Frame;

pub use ring::Ring;

pub use tick::OrbitEpoch;

pub use typed::OrbitTyped;

Modules

cache

OrbitCache — fleet-shared binary K,V cache over the Orbit ring.

contest

Small coordination primitives built on Orbit rings.

error

Error type for orbit-rs. Deliberately small — this layer has few independent failure modes.

event

OrbitEventBus — append-only event stream over one Orbit ring.

fleet

Fleet — the per-process handle that represents membership in a fleet of peers.

id

Re-export of the standalone netid64 primitive.

orbital

Orbital<T> — typed wrapper over the ring buffer substrate.

ring

Ring buffers — orbit-rs’s runtime substrate.

ring_shm

Compatibility module for the pre-ring::shm layout.

shm

POSIX shared-memory helpers — V1 substrate for cross-process rings.

tick

Tick and epoch helpers for Orbit frame versions.

typed

OrbitTyped — marker trait that gives a Rust type a stable wire kind.

Structs

NetId64

Runtime-bound 64-bit identifier with [KIND:8][NODE:16][COUNTER:40] layout.

ParseNetId64Error

Parse error for NetId64::from_str.