Robotics Data Visualization Tools

Sources: Research synthesis, 2026-04-05; Session notes, 2026-04-12 Raw: Robotics Viz Tools Survey; Rerun Concepts Guide Updated: 2026-08-12

Overview

Four tools dominate robotics and embodied AI data visualization in 2025: RViz (ROS-native live debugging), Foxglove Studio (multi-format collaboration platform), Rerun.io (Python-first embodied AI research), and the LeRobot Dataset Visualizer (imitation learning dataset curation). They occupy distinct niches — choosing the wrong one creates friction; choosing the right one is nearly invisible.

RViz

The canonical 3D visualization tool for the ROS ecosystem. Tightly coupled to ROS middleware (requires a running ROS master or DDS network). Desktop-only, Linux/macOS.

Strengths: native TF tree, URDF robot model, nav/planning overlays, interactive markers for teleoperation. Mature C++ plugin ecosystem accumulated over 15+ years. Zero setup overhead in a ROS project.

Weaknesses: real-time only (no native offline playback without ros2 bag play); cannot run without ROS; dated UI; C++ plugin API is a barrier for Python-first researchers.

Use when: building or debugging a ROS/ROS2 robot system in real-time.

Foxglove Studio

Started as open-source robotics visualization IDE; evolved into a commercial observability platform (v2.0, 2024). Core open-source repo is now archived; platform is commercial SaaS.

Strengths: broadest format support — MCAP, ROS1/2 bags, Protobuf, JSON Schema, FlatBuffers, WebSocket; 20+ built-in panels; cloud data platform with team sharing; TypeScript extension marketplace.

Weaknesses: full features require paid plan; data leaves your infrastructure (unless enterprise self-hosted); TypeScript-only extension API; single-company product direction risk.

Use when: multi-format data review, fleet observability, or team collaboration on recorded robot data.

Rerun.io

Open-source (Apache 2.0), framework-agnostic SDK and viewer for multimodal time-series data. ~10,000+ GitHub stars — fastest-growing tool in this space. Built specifically for Physical AI and embodied AI workflows.

Strengths: framework-agnostic (no ROS required); Python/Rust/C++ logging SDKs; native desktop + browser (WebAssembly) + Jupyter notebook inline rendering; ECS data model for flexible custom component types; Blueprints API for programmatic view layouts; MCAP support added in v0.26.

Weaknesses: UI extensions require Rust for full control; no native ROS bag support (requires MCAP conversion); newer project with some experimental APIs; .rrd is a proprietary format.

Use when: Python-first embodied AI / VLA research, Jupyter-based experiment analysis, no ROS dependency.

Core Data Model: ECS Architecture

Rerun uses an ECS-inspired data model with three levels:

Entity: a named path container, e.g. "robot/arm/gripper". No explicit creation needed — Rerun auto-creates parent paths.
Component: actual data attached to an entity (position, color, image pixels). Each component has a typed schema.
Archetype: a convenience wrapper that packs related components. rr.Points3D(positions) automatically creates Position3D + Color + Radius components.

rr.log("camera/image", rr.Image(img))           # Archetype → components
rr.log("robot/joints", rr.Points3D(positions))  # one call, multiple components

Entity Path hierarchy: paths use / as separator, forming a tree. Transforms and Annotation Contexts inherit downward along the path tree. Blueprints can select a path and all its descendants together.

Timelines

Rerun supports multiple simultaneous timelines per recording:

log_tick (auto): call sequence number
log_time (auto): wall clock time
Custom timelines: rr.set_time("frame_idx", sequence=42) or rr.set_time("sensor_time", timestamp=ts_ns)
Static data: rr.log(..., static=True) — not bound to any timeline; always visible (use for coordinate frame definitions, scene meshes)

Recording Model and Multi-Process Recording

A Recording is a .rrd file or a stream. Two key IDs:

application_id: determines which Blueprint (view layout) is applied
recording_id: if multiple processes share the same recording_id, their data merges into a single logical recording in the Viewer — enables distributed recording across nodes

recording_id = "shared-run-001"
# Process A (sensor node)
rr.init("robot_app", recording_id=recording_id)
# Process B (inference node, separate machine)
rr.init("robot_app", recording_id=recording_id)
# Viewer automatically merges both streams

Blueprint API

Blueprints define the Viewer layout independently from the data:

import rerun.blueprint as rrb
 
blueprint = rrb.Blueprint(
    rrb.Horizontal(
        rrb.Spatial3DView(origin="world"),
        rrb.Vertical(
            rrb.Spatial2DView(origin="camera/image"),
            rrb.TimeSeriesView(origin="robot/joints"),
        )
    )
)
rr.send_blueprint(blueprint)

View types: Spatial3DView, Spatial2DView, TimeSeriesView, BarChartView, TextLogView, MapView.

Chunk and Apache Arrow Internals

Rerun’s storage layer (v0.18+) uses Chunks — Apache Arrow column-oriented tables — as the core unit. Each Chunk contains:

Column type	Content
Control column	Globally unique Row ID
Time/index columns	Timeline values (`log_tick`, `log_time`, custom)
Component columns	Typed data arrays (`Points3D:positions`, `Points3D:colors`)

Apache Arrow enables zero-copy data passing from SDK → data store → visualizer → GPU, shared across Python/C++/Rust with the same memory layout. Column orientation means high-frequency small signals (tall columns) and low-frequency large tensors (wide columns like point clouds) can coexist in one recording.

Two Logging Paths

rr.log() — row-oriented, for real-time recording:

for i, pts in enumerate(frames):
    rr.set_time("frame", sequence=i)
    rr.log("lidar/points", rr.Points3D(pts))
    # SDK batches rows → Arrow array → Chunk → send

Automatically adds log_time and log_tick. The internal micro-batcher flushes on size threshold or timer.

rr.send_columns() — column-oriented, ~100x faster for batch/offline data:

times = np.arange(0, 64)
scalars = np.sin(times / 10.0)
 
rr.send_columns(
    "scalars",
    indexes=[rr.TimeColumn("step", sequence=times)],
    columns=rr.Scalars.columns(scalars=scalars),
)

Bypasses the micro-batcher; directly produces large Chunks. Does not auto-add log_time/log_tick — only timelines you explicitly specify are included. Benchmark (v0.18): 2.25M scalar data points — ingestion ~100× faster, memory overhead ~35× lower.

For variable-length batches (e.g., point clouds with different point counts per frame):

rr.send_columns(
    "points",
    indexes=[rr.TimeColumn("time", duration=times)],
    columns=[
        *rr.Points3D.columns(positions=positions).partition(lengths=[2, 4, 4, 3, 4]),
    ],
)
# partition(lengths=...) tells Rerun how many points belong to each timestep

Chunk compaction — merge small Chunks into larger ones post-recording:

rerun rrd compact --max-rows 4096 --max-bytes=1048576 my_recording.rrd

LeRobot Dataset Visualizer

Purpose-built web application for inspecting LeRobot-format demonstration datasets before imitation learning training. Hosted on HuggingFace Spaces (free).

Strengths: zero installation (browser-based); integrated with HuggingFace Hub; 3D URDF robot pose viewer with end-effector trail; episode filtering panel (flags low-movement, jerky, or outlier-length episodes); exports flagged episode IDs as a ready-to-run LeRobot CLI filter command.

Weaknesses: LeRobot format only — cannot import ROS bags, MCAP, or arbitrary formats; web-only (no offline or local file access without self-hosting); no live data support; limited robot URDF library.

Use when: curating LeRobot demonstration datasets for imitation learning.

Comparison Summary

	ROS Dependency	Live	Offline	API	Open Source
RViz	Required	✓	✗	C++ plugins	Apache 2.0
Foxglove	Optional	✓	✓	TypeScript	Core archived
Rerun	Not required	✓	✓	Python/Rust/C++	Apache 2.0
LeRobot VIZ	None	✗	✓	None	Apache 2.0

Recommended Combinations

ROS robot development: RViz for live debugging.

Multi-format data review + team collaboration: Foxglove Studio.

Embodied AI / VLA research (Python-first): Rerun for programmatic logging + Foxglove for MCAP review with team.

LeRobot imitation learning pipeline: LeRobot Dataset Visualizer for episode QA before training.

Production fleet monitoring: Foxglove cloud platform.

Quartz 5

Explorer

visualization-tools