OMNILOOP DOC OL-2026 · REV 4
TICK 000000
Get started

TRANSPORT SHM SEQLOCK · LATENCY <1 ms · DIRECTION BIDIRECTIONAL

Debug the robot while it runs.

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.

Works with: Isaac Lab · SB3 · ROS 2 · MuJoCo · TensorBoard · Rerun
EMERGENCY STOP PRESS TO HALT THIS PAGE
STATE IS KEPT, NOT KILLED
▌SYSTEM HALTED — EVERY LOOP ON THIS PAGE IS FROZEN MID-TICK. STATE INTACT. TWIST (CLICK) TO RESUME. ▌

Observability is
half a tool.

THE ROBOT STORY

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.

THE TRAINING RUN STORY

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.

READ PATH — WHAT VIEWERS GIVE YOU
  • Plot telemetry after the fact
  • Inspect frames, poses, point clouds
  • Spot the anomaly…
  • …then kill the process, edit, rebuild, re-run, hope it reproduces
WRITE PATH — WHAT OMNILOOP ADDS
  • Halt the loop mid-tick on any exception
  • Mutate gains, thresholds and flags in live RAM
  • Step frame-by-frame, then resume in place
  • Record the trace, scrub it, fork a worker at any frame
OL-SHM

Zero-copy shared memory

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.

OL-MUT

Live state mutation

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.

OL-TTR

Trace replay & fork

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.

Step inside
the running loop.

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.

OmniLoop Developer Console Dashboard
01

FREEZE

Exceptions or watchpoints halt target execution instantly. Memory states are frozen mid-tick.

02

INSPECT

Variables and symbolic states are exposed immediately over the zero-copy shared memory plane.

03

PATCH

Mutate gains, confidence thresholds, and interlocks directly. Updates apply in under 1ms.

04

RESUME

Un-halt the loop. Execution picks up from the exact same instruction using the patched memory.

DEMO VIDEO PLACEHOLDER (PHASE 6)

Live control loop mutation, sub-millisecond trace replay & fork demo video.

One loop,
two directions.

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

TARGET PROCESS @track_loop · PyO3 velocity_x = 0.84 p_gain = 2.50 halted = False SHARED MEMORY omniloop-core · Rust telemetry seqlock command ring CONSOLE FastAPI /ws · React halt · step · resume mutate(p_gain, 3.1) scrub frame 1042 state 60 Hz commands <1 ms
FIG. 1 — BIDIRECTIONAL DATA PLANE. TELEMETRY OUT, MUTATION IN, SAME MEMORY.
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);
    }
}

Don't take the
datasheet's word.

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.

STATE MUTATOR — WRITES TO “LIVE RAM”
1.50 rad/s
2.50
thread state
safety door
// mutations appear here
VIRTUAL ACTUATOR — 2-LINK ARM RUNNING

Ordering
information.

Licensed per fleet, like any good industrial component. Change the billing period — the price mutates in place. Obviously.

MONTHLY ANNUAL −20%
OL-OSS Free / OSS
  • Full SDK, server, dashboard & integrations
  • Local `.omni` recording & replay
  • Single-machine, single-user operation
  • Community-led support
$0 /mo
Start free
OL-ENT Enterprise
  • Unlimited storage & retention
  • Fleet dashboards & production monitoring
  • Org-wide watchpoint policies
  • SSO/SAML · Audit logs · SLA
RFQ custom
Contact sales
OL-ONPREM On-Prem
  • Self-hosted cloud layer
  • Air-gapped environments (defense, auto)
  • All Enterprise features on your infrastructure
  • Dedicated support & SLA
RFQ annual license
Contact sales

Commission
your cell.

Integrating with custom ROS 2 nodes, Isaac Sim, MuJoCo or bare-metal actuators? Send your configuration — a robotics engineer answers, not a bot.