Backed by Y Combinator

The solution to your ROS headaches.

Robot middleware at microsecond latency. Zero-copy, deterministic, ROS2-compatible. Built in Rust.

~/robot-ws
# Install the middleware on Linux, one line
$ curl -fsSL cerulion.com/install.sh | sh
✓ Installing cerulion for linux-x86_64
✓ iceoryx2 runtime ready # shared-memory transport
✓ ROS2 message types loaded # e.g. sensor_msgs/Image
→ cerulion graph run perception
Used at
Y CombinatorMITPennOxfordMassRoboticsNVIDIA Inception
01 — Cerulion Middleware

Robot plumbing, re‑engineered from scratch.

Cerulion goes after the part that hurts most in production: the single-machine, real-time graph. A zero-copy Rust framework on iceoryx2 shared memory — microsecond IPC and deterministic, replayable execution by default.

Round-trip latency · p50
10,807×faster than standard ROS2 at LiDAR scale
Cerulion
2.4µs
ROS2
26.2ms

16 MB round-trip, p50. Internal benchmark.

Compatibility · adopt incrementally
Native ROS2 message types. No rewrite to start.

Zero-copy from the first message — your existing types, no wrappers.

  • sensor_msgs
  • geometry_msgs
  • nav_msgs
  • tf2_msgs
// reuse the types you already ship
use sensor_msgs::Image;
use geometry_msgs::Twist;
Transport · zero-copy shared memory
Written once. Read in place.
small messages
flat
~3.0µs · payload-independent
camera · lidar
in‑place
near hardware speed

Zero-copy works on non-POD types too — not just plain structs.

Stack · no hidden layers
Less boilerplate. No glue code.

Plain Rust and C++, your libraries, no shims.

Your nodesRUST · C++
Cerulion APITYPED
iceoryx2SHARED MEMORY
Determinism · replay = live
Reproduce exactly. Debug once.
cerulion trace inspect ./traces
schedulerdeterministic DAG
orderderived from graph
diff vs live0 differences
replay is bit‑for‑bit identical
QoS · deadlines & triggers
Timing violations are loud, not silent.
timer
tick
tick
tick
sync
multi-input
multi-input
cmd
deadline miss

Independent in/out deadline counters fire a structured warning the moment one slips.

Isolation · no penalty
Process isolation, faster than intra-process.

Every node in its own process — a crash stays contained. Messages still clear in microseconds, below intra-process copying.

Read the docs →
Talk to us

See it on your robot.

Book a demo and we'll walk through how Cerulion fits your stack: zero-copy shared memory, deterministic replay, and ROS2 compatibility. Bring a workload and we'll run the benchmarks live.

✓ Built in Rust
✓ ROS2 compatible
Or email founders@cerulion.com