Robotics Data Visualization Tools Survey

Research Question

Which visualization tool is best suited for different use cases in robotics and embodied AI development — RViz, Foxglove Studio, Rerun.io, or LeRobot Dataset Visualizer? What are their technical capabilities, limitations, and ideal user profiles?

1. RViz

Overview

RViz is the canonical 3D visualization tool for the ROS (Robot Operating System) ecosystem. Developed and maintained by Open Robotics as part of the ROS stack, it is deeply integrated with the ROS middleware and has been a staple of robotics development for over a decade. RViz2 is the ROS 2 version with modular frame transformation support.

License: Apache 2.0 (open source)
Repos: ros-visualization/rviz (~870 stars), ros2/rviz
Version: RViz2 (ROS 2), RViz (ROS 1)
Maintained by: Open Robotics / ROS community

Data Format Support

ROS topics only (via DDS middleware)
Sensor types: camera, LiDAR, point cloud, laser scan
State types: joint states, TF tree, occupancy grid, nav path, interactive markers
No native MCAP or rosbag playback (requires ros2 bag play)

Data Type Visualization

3D scene with coordinate frames (TF)
Point clouds, occupancy grids, costmaps
Camera image feeds (raw or compressed)
Robot model (URDF/XACRO)
Path planning overlays
Interactive markers for teleoperation

Deployment and Integration

Desktop-only (Linux / macOS via ROS)
Real-time data streaming via ROS topics
No web or Jupyter support
Requires a running ROS master or ROS 2 DDS network

Customization and Extensibility

Plugin system: core extensibility mechanism — derive from rviz_common::Display, Panel, Tool, or ViewController
Register plugins via pluginlib and a plugin_description.xml manifest
Frame transformation library is pluggable (ROS 2): swap in custom TF backends
Large ecosystem of community plugins (nav2, MoveIt, PCL, custom sensor displays)
Requires C++ knowledge; plugin API is stable but verbose

Community and Ecosystem

Integral part of the ROS ecosystem — ubiquitous in ROS tutorials, textbooks, and lab workflows
Extensive plugin ecosystem accumulated over 15+ years
ROS community support via ROS Discourse, ROS Answers, and GitHub Issues
Actively maintained alongside ROS 2 development

Pricing and Licensing

Free and open source (Apache 2.0)
No paid tiers or cloud features

Limitations

Real-time only — no native offline playback (must use ros2 bag play)
Tightly coupled to ROS middleware — cannot be used without a running ROS environment
Desktop-only — no browser or remote access
C++ plugin API adds barrier for Python-first researchers
UI is functional but dated compared to modern web-based tools

Primary Use Case

Live debugging of ROS-based robot software during development.

2. Foxglove Studio

Overview

Foxglove Studio (now “Foxglove”) started as an open-source robotics visualization IDE and evolved into a full observability platform. Version 2.0 (March 2024) merged the Studio desktop client and the Data Platform cloud service into a single unified product. It is commercially developed by Foxglove, Inc.

License: Core open (Foxglove Studio GitHub archived); platform is commercial SaaS
Repo: foxglove/studio (archived open-source core)
Version: Foxglove 2.0+ (2024)
Maintained by: Foxglove, Inc.

Data Format Support

Native: MCAP, ROS 1 bag, ROS 2 bag (db3)
Custom: Protobuf, JSON Schema, FlatBuffers, TypeScript
Live: ROS 1, ROS 2, WebSocket (Foxglove SDK in C++/Python/Rust)
Most format-flexible tool in this comparison

Data Type Visualization

3D scene: point clouds, meshes, URDF, transforms
Multi-camera image feeds with bounding box overlays
Time-series plots (3× faster than previous version as of 2025)
State transitions panel (11× faster)
Log viewer, diagnostics panel
Custom message inspector
20+ built-in panels total

Deployment and Integration

Web app (browser) + desktop app (Electron)
Cloud data platform: upload, share, and stream recordings remotely
Team collaboration: shared layouts, remote playback URLs
Foxglove SDK (MIT) for C++/Python/Rust live streaming or MCAP logging

Customization and Extensibility

Extensions API: TypeScript-based, framework-agnostic (React or DOM primitives)
Create custom panels with @foxglove/extension SDK via create-foxglove-extension scaffolding
Custom message scripts: manipulate or filter topics with inline transforms
Custom data decoders: extend format support beyond built-ins
Extensions marketplace (public + private org deployments for Pro/Enterprise)
Private extensions auto-deployed across an organization (Pro/Enterprise tier)

Community and Ecosystem

Growing adoption in industry robotics teams (notably used by Autoware, Tier IV, Husarion)
Active extensions marketplace
Regular blog posts, video tutorials, and official documentation
Commercial support available

Pricing and Licensing

Free tier: limited data upload, basic features
Pro: team sharing, private extensions, more storage
Enterprise: SSO, SLA, private cloud deployment options
Core viewer (Foxglove Studio) was open source (now archived); SDK is MIT

Limitations

Full feature set requires paid plan
Cloud data pipeline means data leaves your infrastructure (unless self-hosted enterprise)
Extensions must be written in TypeScript — no Python extension API
Open-source repo archived; product direction controlled by a single company

Primary Use Case

Multi-format robotics data review, team collaboration, and fleet observability.

3. Rerun.io

Overview

Rerun is an open-source SDK and viewer for multimodal time-series data, built from the ground up for Physical AI, embodied AI, and computer vision workflows. Unlike RViz and Foxglove (which center on ROS), Rerun is framework-agnostic and positions itself as a data logging tool for researchers and engineers. The viewer can run natively, in the browser via WebAssembly, or embedded in Jupyter notebooks.

License: Apache 2.0 (open source)
Repo: rerun-io/rerun (~10,000+ stars, fastest-growing in this comparison)
Version: 0.27+ (2025)
Maintained by: Rerun.io (VC-backed startup)

Data Format Support

Native .rrd format (Rerun Recording)
MCAP (with ROS 2 reflection-based support added in 0.26)
Arrow IPC (internal wire format)
No native ROS bag support without MCAP conversion

Data Type Visualization

2D and 3D spatial scenes
Images and video streams
Bounding boxes (2D/3D), segmentation masks
Tensors and array data
Time-series plots
Text/log streams
Graph structures (experimental)
Coordinate frame hierarchies (experimental in 0.27)

Deployment and Integration

Native desktop app (Windows/macOS/Linux)
Browser (WebAssembly) — embed live visualizations in web apps
Jupyter notebook integration — visualize inline during experiment runs
gRPC-based streaming or file-based recording
Python, Rust, C++ logging SDKs

Customization and Extensibility

Custom visualizers: register custom archetypes and shaders, plug into existing 2D/3D/Map views without writing a full view class (Python API in progress)
UI extensions: currently Rust-only — embed re_viewer inside a custom eframe app and add panels with egui
ECS (Entity-Component-System) data model enables flexible custom component types
Blueprints API (Python): programmatically define view layouts and panel configurations
Active development toward broader Python UI extension API

Community and Ecosystem

~10,000+ GitHub stars — highest by far among these four tools
Featured at NeurIPS, ICLR, and in embodied AI research papers
Integrated with LeRobot, Open X-Embodiment, and other robotics dataset pipelines
Rerun used by Turing Motors (autonomous driving), robotics research labs
Active Discord community and responsive maintainers

Pricing and Licensing

Fully open source (Apache 2.0)
No paid tiers currently
Hosted by VC-backed company — long-term commercial model TBD

Limitations

UI extension / custom visualizer API is Rust-only for full control
No native ROS bag support (requires MCAP conversion)
Younger project — some APIs still marked experimental
.rrd is a proprietary format (though open spec)
Less feature-complete than Foxglove for fleet/cloud workflows

Primary Use Case

Embodied AI and ML research, programmatic data logging from Python/Rust/C++ experiments, Jupyter-based analysis.

4. LeRobot Dataset Visualizer (HuggingFace)

Overview

The LeRobot Dataset Visualizer is a purpose-built web application for inspecting and curating robotics demonstration datasets in the LeRobot format. Maintained by HuggingFace as part of the LeRobot project, it is hosted as a HuggingFace Space and focuses on dataset quality assurance before imitation learning training — not on live robot debugging.

License: Apache 2.0 (open source)
Repo: huggingface/lerobot-dataset-visualizer
Hosted at: HuggingFace Space (lerobot/visualize_dataset)
Maintained by: HuggingFace

Data Format Support

LeRobot dataset format only (v2.0+, v3.0)
Parquet files for sensor/action data
MP4 video episodes
JSON metadata
Not compatible with ROS bag, MCAP, or arbitrary formats

Data Type Visualization

Synchronized video playback + sensor/action signal graphs
Time-aligned multi-camera feeds
3D URDF robot pose viewer (SO-100, SO-101, OpenArm bimanual) — frame-by-frame joint pose visualization with end-effector trail rendering
Episode-level metadata inspection (length, action statistics)

Deployment and Integration

Web-only (browser, HuggingFace Space)
No desktop app or local installation required
Integrated with HuggingFace Hub dataset hosting
Loads datasets via Parquet + JSON from HuggingFace Hub APIs
Pagination, chunking, and lazy-loading for large datasets

Customization and Extensibility

Limited extensibility — no plugin or extension system
Open source (React/Next.js/Tailwind CSS) — can be forked and self-hosted
URDF robot support currently limited to specific robots (SO-100/101, OpenArm)
Community contributions can add new robot URDF support via PRs

Community and Ecosystem

Maintained by HuggingFace as part of the LeRobot ecosystem
Growing adoption as LeRobot dataset format becomes standard for community robotics datasets
Direct integration with HuggingFace Hub — datasets published there are immediately visualizable
LeRobot dataset format gaining adoption for imitation learning benchmarks

Pricing and Licensing

Free (hosted on HuggingFace Spaces)
Apache 2.0

Data Quality Features

Filtering panel identifies problematic episodes: low movement, jerky motion, outlier episode length
Exports flagged episode IDs as a ready-to-run LeRobot CLI filter command
Designed to prepare clean datasets before lerobot train

Limitations

LeRobot format only — no support for arbitrary datasets
Web-only — no local file system access or offline use without self-hosting
No live data support — offline dataset inspection only
Limited robot URDF library (only officially supported robots)
No extensible plugin/SDK interface

Primary Use Case

Curating LeRobot demonstration datasets for imitation learning — inspect episodes, flag bad demonstrations, export filter commands.

Comparative Summary

ROS Dependency

Tool	ROS Dependency
RViz	Required — cannot run without ROS middleware
Foxglove	Optional — supports ROS but also works with MCAP/custom formats
Rerun	Not required — framework-agnostic; supports ROS2 MCAP (since v0.26)
LeRobot VIZ	None — web app, HuggingFace format only

Live vs. Offline

Tool	Mode
RViz	Live only
Foxglove	Both
Rerun	Both
LeRobot VIZ	Offline only

Language / API

Tool	APIs
RViz	ROS topics (C++/Python via ROS)
Foxglove	TypeScript extensions; Foxglove SDK (C++/Python/Rust)
Rerun	Python, Rust, C++ logging SDKs
LeRobot VIZ	Web UI only (no programmatic API)

Extensibility

Tool	Extensibility
RViz	Mature C++ plugin system (Display, Panel, Tool, ViewController)
Foxglove	TypeScript extensions marketplace; custom decoders and message scripts
Rerun	Custom visualizers (Rust); Blueprints API (Python); ECS data model
LeRobot VIZ	Fork and self-host only; no plugin system

Open Source

Tool	License
RViz	Apache 2.0
Foxglove	Core archived; SDK is MIT; platform is commercial
Rerun	Apache 2.0
LeRobot VIZ	Apache 2.0

Community

Tool	GitHub Stars	Notes
Rerun	~10,000+	Fastest-growing; strong ML/AI community
RViz	~870	Ubiquitous in ROS ecosystem
Foxglove	~73 (archived)	Adoption measured through platform usage, not stars
LeRobot VIZ	—	Part of LeRobot ecosystem

Use Case Recommendations

Building a ROS/ROS2 robot (live debugging) → RViz — native TF, sensor data, and navigation visualization with zero overhead

Multi-format data review or team collaboration → Foxglove Studio — best multi-format support (MCAP/ROS/Protobuf), cloud sharing, 20+ panels

Embodied AI / VLA research (Python-first, no ROS) → Rerun.io — log from Python/Rust/C++ directly, works in Jupyter, no ROS dependency

LeRobot imitation learning dataset preparation → LeRobot Dataset Visualizer — built for this specific workflow; episode QA and filtering

Production fleet monitoring → Foxglove (cloud platform with data management pipeline)

Mixed AI + ROS workflow → Rerun + Foxglove — Rerun for programmatic logging, Foxglove for MCAP review and team sharing

Usage Examples

RViz — Launch with a custom config and replay a bag

# ROS 2: replay a recorded bag and open RViz with a saved config
ros2 bag play my_robot_run.db3 &
rviz2 -d config/robot_debug.rviz

# ROS 2: launch RViz as part of a launch file (common pattern)
# launch/visualize.launch.py
from launch import LaunchDescription
from launch_ros.actions import Node
 
def generate_launch_description():
    return LaunchDescription([
        Node(
            package='rviz2',
            executable='rviz2',
            arguments=['-d', 'config/robot_debug.rviz'],
        )
    ])

# Publish a point cloud to an RViz topic from Python (rclpy)
import rclpy
from sensor_msgs.msg import PointCloud2
import sensor_msgs_py.point_cloud2 as pc2
 
rclpy.init()
node = rclpy.create_node('pc_publisher')
pub = node.create_publisher(PointCloud2, '/lidar/points', 10)
 
points = [(x, y, 0.0) for x in range(-5, 5) for y in range(-5, 5)]
msg = pc2.create_cloud_xyz32(header, points)
pub.publish(msg)

Foxglove Studio — Live streaming via Foxglove SDK (Python)

# Stream live data into Foxglove from a Python process (no ROS needed)
from foxglove_websocket import run_cancellable
from foxglove_websocket.server import FoxgloveServer, FoxgloveServerListener
import asyncio, time, json
 
async def main():
    async with FoxgloveServer("0.0.0.0", 8765, "my robot") as server:
        chan_id = await server.add_channel({
            "topic": "/robot/state",
            "encoding": "json",
            "schemaName": "RobotState",
            "schema": json.dumps({"type": "object", "properties": {
                "x": {"type": "number"}, "y": {"type": "number"}
            }}),
        })
        while True:
            await server.send_message(chan_id, time.time_ns(), json.dumps({"x": 1.0, "y": 2.0}).encode())
            await asyncio.sleep(0.1)
 
run_cancellable(main())
# Open Foxglove Studio → connect to ws://localhost:8765

# Play an MCAP file directly in Foxglove (drag-and-drop or CLI)
# Install Foxglove desktop app, then:
foxglove open my_recording.mcap
 
# Or convert a ROS 2 bag to MCAP first:
pip install rosbags
rosbags-convert my_bag/ --dst my_recording.mcap

Rerun.io — Log robot data from Python

import rerun as rr
import numpy as np
 
rr.init("robot_run", spawn=True)  # opens viewer automatically
 
# Log a camera image
rr.log("camera/rgb", rr.Image(np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)))
 
# Log a 3D point cloud
points = np.random.rand(1000, 3).astype(np.float32)
rr.log("lidar/points", rr.Points3D(points))
 
# Log a time series signal
for t in range(100):
    rr.set_time_sequence("step", t)
    rr.log("robot/joint_angle", rr.Scalar(np.sin(t * 0.1)))

# Save to .rrd file for later review (no live viewer needed)
rr.init("robot_run")
rr.save("run_2026-04-05.rrd")
 
# ... log data ...
 
# View later:
# rerun run_2026-04-05.rrd

# Jupyter notebook — inline visualization
import rerun as rr
rr.init("notebook_demo")
rr.notebook_show()  # renders viewer inline in the cell output
 
rr.log("camera/rgb", rr.Image(frame))

LeRobot Dataset Visualizer — Inspect a HuggingFace dataset

# Option 1: Use the hosted HuggingFace Space directly
# Navigate to: https://huggingface.co/spaces/lerobot/visualize_dataset
# Enter dataset name, e.g.: lerobot/pusht
# Browse episodes, scrub video, inspect action/observation signals

# Option 2: Run the visualizer locally (self-hosted)
git clone https://github.com/huggingface/lerobot-dataset-visualizer
cd lerobot-dataset-visualizer
npm install
npm run dev
# Opens at http://localhost:3000

# Option 3: Use LeRobot CLI to visualize a local dataset
python -m lerobot.scripts.visualize_dataset \
    --repo-id lerobot/pusht \
    --episode-index 0
 
# After flagging bad episodes in the web UI, apply the filter:
python -m lerobot.scripts.push_dataset_to_hub \
    --raw-dir data/my_dataset \
    --episodes 0 1 2 5 7   # exported from the visualizer UI

bot_vault

Explorer

Robotics Data Visualization Tools Survey

Robotics Data Visualization Tools Survey

Research Question

1. RViz

Overview

Data Format Support

Data Type Visualization

Deployment and Integration

Customization and Extensibility

Community and Ecosystem

Pricing and Licensing

Limitations

Primary Use Case

2. Foxglove Studio

Overview

Data Format Support

Data Type Visualization

Deployment and Integration

Customization and Extensibility

Community and Ecosystem

Pricing and Licensing

Limitations

Primary Use Case

3. Rerun.io

Overview

Data Format Support

Data Type Visualization

Deployment and Integration

Customization and Extensibility

Community and Ecosystem

Pricing and Licensing

Limitations

Primary Use Case

4. LeRobot Dataset Visualizer (HuggingFace)

Overview

Data Format Support

Data Type Visualization

Deployment and Integration

Customization and Extensibility

Community and Ecosystem

Pricing and Licensing

Data Quality Features

Limitations

Primary Use Case

Comparative Summary

ROS Dependency

Live vs. Offline

Language / API

Extensibility

Open Source

Community

Use Case Recommendations

Usage Examples

RViz — Launch with a custom config and replay a bag

Foxglove Studio — Live streaming via Foxglove SDK (Python)

Rerun.io — Log robot data from Python

LeRobot Dataset Visualizer — Inspect a HuggingFace dataset

Sources

Graph View

Table of Contents

Backlinks