TRANSPORT SHM SEQLOCK · LATENCY <1 ms · DIRECTION BIDIRECTIONAL
Rerun and Foxglove let you watch. OmniLoop lets you write back: halt on exception, mutate live variables, step the loop, and replay the trace — without restarting the target process.
Passive telemetry fails at robotic speeds: by the time the log lands, the arm has already moved. OmniLoop pairs the read path with a command path into the same shared memory — a control plane, not a viewer.
Your 12-hour run doesn't die at 3am. When a NaN watchpoint trips, the flight recorder automatically dumps the last N frames of memory to an append-only journal. Halt, inspect variables, hot-patch weights, and resume in-place.
A hand-tuned Rust seqlock for telemetry and a length-prefixed ring buffer for commands. Point clouds, LiDAR matrices and symbolic state cross process boundaries with microsecond transport overhead — no sockets in the hot path.
Don't restart. Hot-patch PID gains, confidence thresholds and boolean interlocks inside active simulator ticks through native PyO3 bindings. The loop never notices — except it behaves better.
Append-only .omni journals capture every frame. Scrub back to the exception,
inspect the exact state that tripped it, then fork a fresh worker hot-patched with
that frame's variables.
The Developer Console gives you full bidirectional control over simulator and robot memory. See the exact moment of failure, inspect variables, and patch live memory.
Exceptions or watchpoints halt target execution instantly. Memory states are frozen mid-tick.
Variables and symbolic states are exposed immediately over the zero-copy shared memory plane.
Mutate gains, confidence thresholds, and interlocks directly. Updates apply in under 1ms.
Un-halt the loop. Execution picks up from the exact same instruction using the patched memory.
Live control loop mutation, sub-millisecond trace replay & fork demo video.
The SDK instruments your control loop and publishes state into shared memory. The server rebroadcasts it to the console — and forwards your mutations straight back into the command ring.
TRANSPORT SHM SEQLOCK · LATENCY <1 ms · DIRECTION BIDIRECTIONAL
from omniloop import TrainingLoop
# Bind config attributes live & record to a trace
loop = TrainingLoop.from_dataclass(
cfg.ppo,
tunable=["learning_rate", "entropy_coef"],
bind={"learning_rate": optimizer},
journal="run.omni",
)
for epoch in range(num_epochs):
with loop.tick(): # halt barrier & apply edits
train_epoch()
loop.log(loss=loss_val) # publish telemetry
from omniloop import load_events, JournalPlayer
# Parse mutations, freezes, and watchpoint trips
for event in load_events("run.omni"):
print(f"[{event.timestamp}ms] Tick {event.tick}: {event.kind} -> {event.detail}")
# Replay telemetry & events frame-by-frame
player = JournalPlayer("run.omni")
while record := player.read_next_record():
if record.kind == "telemetry":
apply_state(record.payload)
// omniloop-core/src/ipc.rs
pub struct TelemetrySeqlock {
seq: AtomicU64,
slot: UnsafeCell<[u8; SLOT_BYTES]>,
}
impl TelemetrySeqlock {
/// Lock-free publish: writers never block the loop.
pub fn publish(&self, frame: &[u8]) {
let s = self.seq.fetch_add(1, Ordering::AcqRel);
unsafe { (*self.slot.get())[..frame.len()]
.copy_from_slice(frame); }
self.seq.store(s + 2, Ordering::Release);
}
}
This is a live PID loop running in your browser at 60 Hz. Drag a fader and the mutation lands mid-tick — exactly how OmniLoop patches a real robot's RAM. Halt it. Nothing dies.
Licensed per fleet, like any good industrial component. Change the billing period — the price mutates in place. Obviously.
Integrating with custom ROS 2 nodes, Isaac Sim, MuJoCo or bare-metal actuators? Send your configuration — a robotics engineer answers, not a bot.