# Rerun

> Log, query and visualise multimodal robotics data, then stream it into training

- Category: Data & Labeling / Data Wrangling
- Language: Rust
- Licence: MIT OR Apache-2.0
- Repository: https://github.com/rerun-io/rerun
- Website: https://rerun.io/
- Canonical page: https://ai-tldr.dev/tools/rerun/

## In short

Rerun is a data layer for physical AI: you log multimodal, multi-rate data from your code, and a viewer renders all of it in sync while the same data stays queryable. It sits in the Data Wrangling category of the Data & Labeling tools and is open-source, written in Rust and licensed MIT OR Apache-2.0.

## Overview

Rerun is a data layer for physical AI: you log multimodal, multi-rate data from your code, and a viewer renders all of it in sync while the same data stays queryable. It ingests images, point clouds, transforms, time series, tensors, joint states and video from robot logs, egocentric and UMI rigs, simulation and web video, reading formats including MCAP, its own rrd recordings and LeRobot datasets.

The viewer is the part people meet first — scrub through an episode, compare sensors side by side, watch a CV pipeline run live — but the storage underneath is the point. Rerun is built in Rust on column-chunk storage designed for multi-rate physical data, so the same recording can be queried with dataframes or SQL and streamed straight into training without an export step or a second stale copy of the dataset.

SDKs exist for Python, Rust and C++, and the viewer also runs in a browser. The Python package bundles the viewer binary; C++ and Rust users install the `rerun` CLI separately. The project is dual-licensed under MIT and Apache 2.0.

## What it does

- Log multi-rate multimodal data — images, point clouds, transforms, time series, tensors, joint states, video — from one API
- Built-in viewer that renders every stream in sync and in realtime, locally or in the browser
- Query the same recordings with dataframes or SQL, and stream dataset mixes directly into training
- Reads robot logs, human-data rigs, simulation and web video; MCAP, rrd and LeRobot formats
- SDKs for Python, Rust and C++, over column-chunk storage written in Rust
- Stream over the network to a remote viewer, or save recordings to `.rrd` files on disk

## Getting started

The Python path is the fastest — the SDK ships the viewer with it. All commands and code below come from the project README.

1. Install the Python SDK

   This also installs the `rerun` viewer binary, so `rerun --help` works afterwards.

```bash
pip install rerun-sdk
```

2. Log your first recording

   Initialise a recording, spawn the viewer, put your data on a timeline and log it against an entity path.

```python
import rerun as rr  # pip install rerun-sdk

rr.init("rerun_example_app")

rr.spawn()  # Spawn a child process with a viewer and connect
# rr.save("recording.rrd")  # Stream all logs to disk
# rr.connect_grpc()  # Connect to a remote viewer

# Associate subsequent data with 42 on the "frame" timeline
rr.set_time("frame", sequence=42)

# Log colored 3D points to the entity at `path/to/points`
rr.log("path/to/points", rr.Points3D(positions, colors=colors))
```

3. Or use the Rust or C++ SDK

   Rust and C++ do not bundle the viewer, so install the CLI alongside the SDK.

```bash
cargo add rerun
cargo install rerun-cli --locked --features nasm
```

4. Check the viewer binary is on your path

   The `rerun` binary is what loads `.rrd` files and receives log data streamed over the network.

```bash
rerun --help
```

5. Get data back out

   The dataframe and SQL query APIs turn a recording into rows you can analyse or feed to a training job — see the how-to on querying and transforming.

```text
https://rerun.io/docs/howto/query-and-transform/get-data-out
```

## When to use it

- Reach for it to debug a robotics or computer-vision pipeline by watching every sensor stream in sync
- Reach for it when episodes from robots, rigs, simulation and video have to live in one queryable substrate
- Reach for it to inspect intermediate and derived data from a CV pipeline, not just the final output
- Reach for it when you want to stream dataset mixes into training without export jobs or stale copies
