> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cerulion.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Cerulion
> Deterministic, microsecond-scale IPC for robotics. The performance of bare shared memory with the ergonomics of a modern framework.
Built for roboticists
Robot middleware that just works.
**No serialization on the local hot path. No QoS micromanagement. No surprises. Just typed messages over shared memory at the latency of a function call.**
Try the Quickstart
## What Cerulion is
Cerulion is a Rust middleware for robotics and real-time systems. You compose
your application as a **graph** of **nodes** that pass messages over zero-copy
shared memory, and you build, wire, and run the whole thing through one CLI:
`cerulion`.
It gives you the latency of raw shared memory with the ergonomics of a typed,
macro-driven node API, plus a simulated clock that makes runs deterministic and
replayable. It's the foundation of a modern robotics stack — built to be the
faster, more deterministic successor to ROS 2.
Cerulion is in **closed alpha** — early access for teams who want a faster,
more deterministic robotics stack ahead of the public release. Everything
documented here — the CLI, node macro, and graph/schema formats — is real and
verified against the current build. Access is curated today;
[request an invite](/cerulion/installation) to start building.
## Why teams use it
Nodes exchange messages over iceoryx2 shared memory. Reads and writes go
straight to the payload, with no serialization on the local hot path.
Execution is driven by a simulated clock stepped in 1 ms increments, so the
same graph and inputs produce the same ordering. That makes runs easy to
debug and replay.
Decide when each node fires (periodic, data-triggered, synchronized, or
external) with per-node tick deadlines that warn loudly when missed.
Define a node as a Rust struct with `#[cerulion_node]`. Field attributes
declare ports; the macro rewrites `self.` access into zero-copy
shared-memory reads and writes for you.
## Start here
Set up the Rust toolchain, get the `cerulion` CLI, and verify it works.
Build and run a complete two-node graph, then watch its messages with
`topic echo`.
Learn the mental model: workspaces, nodes, graphs, topics, and schemas.