In-depth review: Rerun
Rerun is a specialized open-source SDK and visualizer purpose-built for logging and exploring computer vision and robotics data over time. Unlike general-purpose logging or dashboarding tools, Rerun is designed from the ground up to handle the multimodal, spatial, and temporal complexity that defines modern embodied AI systems. Its core value proposition is straightforward: with minimal code, engineers and researchers can capture internal state—camera frames, 3D point clouds, transforms, scalars, text logs—and then interactively scrub through that data in a dedicated viewer. This makes it a practical debugging and validation tool for anyone building perception pipelines, sensor fusion stacks, or spatial AI models.
Where Rerun stands out is in its combination of logging ergonomics and visualization fidelity. The SDK, available in C++, Python, and Rust, lets users log heterogeneous data types to a single timeline with just a few lines of code. The visualizer then renders that data with temporal controls, allowing frame-by-frame inspection, side-by-side comparisons, and playback at variable speeds. This tight loop between logging and viewing is critical for debugging nonlinear failures in robotics or vision systems—where a bug might manifest only under specific sensor conditions or after long runtimes. Rerun’s Rust-based architecture ensures the viewer remains responsive even when handling large logs, a practical advantage over slower alternatives.
The tool fits best into workflows that already involve iterative development of spatial AI systems. For a computer vision engineer debugging a 3D reconstruction pipeline, Rerun can log intermediate depth maps, camera poses, and reconstructed meshes, then let the engineer scrub through the sequence to pinpoint where geometry drifts. For a robotics engineer validating sensor fusion, Rerun can ingest LiDAR scans, IMU data, and odometry estimates, overlaying them in a shared 3D view to check alignment. Researchers preparing paper walkthroughs can log experimental data and export interactive visualizations that convey temporal dynamics more effectively than static figures. The Aria Dataset Explorer integration shows how Rerun can serve as a front-end for large public datasets, but its primary strength is in ad-hoc, custom logging.
Who benefits most? Teams building custom perception or robotics stacks—especially those dealing with multi-sensor setups or state estimation—will find Rerun immediately useful. It reduces the friction of setting up visual debugging, which often requires stitching together separate tools for different data types. Solo researchers and small teams can adopt it quickly due to its open-source nature and straightforward API. Larger organizations may leverage the managed infrastructure tier for centralized ingestion and streaming, though this introduces operational overhead and cost considerations not present in the self-hosted version.
Limitations matter. Rerun is laser-focused on spatial and embodied AI domains; it is not a general-purpose log aggregator or a model training monitor. It lacks built-in analytics, alerting, or dashboarding for business metrics. The visualizer is a thick client, not a web dashboard, which limits remote collaboration unless combined with streaming infrastructure. Furthermore, Rerun requires integration into an existing codebase—it is a logging library, not a plug-in. Teams must add logging calls to their code, which can be a barrier for legacy systems or closed-source components. There is also no native support for real-time streaming from embedded devices; data is typically logged to files and viewed post-hoc.
For a practical buyer or operator, the decision to adopt Rerun hinges on whether your debugging pain is specifically about understanding temporal, multimodal spatial data. If you are struggling to correlate camera images with LiDAR points and robot poses across a time series, Rerun offers a purpose-built solution that likely outperforms cobbling together separate viewers. If your needs are broader—covering system logs, application performance, or business KPIs—a more general observability platform may be appropriate. Rerun is best evaluated by running its quickstart guide with your own data; the value becomes immediately apparent when you see your first logged sequence play back in the viewer. The open-source core ensures low risk for experimentation, and the community Discord provides responsive support for integration issues. Ultimately, Rerun fills a genuine gap in the developer toolchain for spatial AI, and its focus and performance make it a serious contender for teams willing to invest a few hours in integration.
Who it's built for
Computer vision engineers
Why it fits
Rerun's SDK allows logging frames, detections, and 3D reconstructions with minimal code, making it easy to debug perception pipelines.
Best value
Quickly identify failure modes in vision pipelines by visualizing temporal data side-by-side.
Caution
Requires integration into existing codebase; no built-in model training or analytics.
Robotics engineers
Why it fits
Rerun supports multimodal logging (sensor data, robot state, transforms) crucial for sensor fusion and state estimation debugging.
Best value
Visualize complex temporal sequences to validate system behavior and detect anomalies.
Caution
Limited to spatial/embodied AI domains; not suited for non-spatial data workflows.
AI researchers
Why it fits
Rerun enables creating interactive visual walkthroughs of algorithms and exploring datasets like Aria Dataset for publications.
Best value
Communicate research results effectively with temporal visualizations that reviewers can explore.
Caution
No built-in support for statistical analysis or model comparison.
Data scientists
Why it fits
Rerun allows exploring multimodal log data over time to understand model behavior and system performance.
Best value
Gain insights into data distributions and system dynamics without writing custom visualization code.
Caution
Primarily focused on spatial data; may not fit traditional tabular or text-heavy datasets.
Key features
SDK for Logging CV and Robotics Data
Core logging API in C++, Python, and Rust for capturing images, point clouds, transforms, and scalars with minimal code changes.
Benefit
Reduces boilerplate, enabling developers to instrument existing codebases quickly.
Limitation
Requires manual integration; no automatic instrumentation of third-party libraries.
Visualizer for Temporal Exploration
Scrubbing through logged data over time, inspecting individual frames, and comparing sequences side-by-side.
Benefit
Accelerates debugging by providing intuitive temporal context for system behavior.
Limitation
Performance may degrade with extremely long recordings or high-frequency data without managed infrastructure.
Multimodal Log Handling
Supports heterogeneous data types (images, 3D meshes, text logs) in a single timeline.
Benefit
Essential for complex sensor fusion workflows where different data modalities must be correlated temporally.
Limitation
All data must be logged through Rerun SDK; cannot ingest pre-existing logs without conversion.
Managed Infrastructure for Scale
Cloud-based ingestion, storage, and streaming for large-scale datasets.
Benefit
Enables handling datasets that exceed local memory, with built-in streaming to the visualizer.
Limitation
Requires understanding of data pipeline tradeoffs (e.g., network bandwidth, storage costs).
Cross-Language Support (C++, Python, Rust)
Broad language support ensures integration into diverse codebases.
Benefit
Teams can adopt Rerun without changing their primary development language.
Limitation
Each language binding may have slight API differences; documentation varies in completeness.
Real-world use cases
Debugging Perception Pipelines
Computer vision engineerScenario
A computer vision engineer is developing a real-time object detection system and encounters intermittent false positives.
Solution
Using Rerun, they log camera frames, detection bounding boxes, and 3D reconstructions with minimal code. They then scrub through the temporal log to identify frames where the detector fails.
Outcome
Quickly pinpoint failure modes and iterate on model or preprocessing without writing custom visualization scripts.
Visualizing Research Papers
AI researcherScenario
An AI researcher wants to create an interactive supplement for a paper on 3D scene understanding.
Solution
They log their algorithm's intermediate outputs (point clouds, camera poses, semantic labels) using Rerun's Python SDK and export a shareable visualization.
Outcome
Reviewers and readers can explore the data temporally, leading to better understanding and reproducibility.
Exploring the Aria Dataset
AI researcherScenario
A research team is analyzing egocentric video and sensor data from the Aria Dataset to study human-object interactions.
Solution
They use Rerun to load pre-logged sequences and visualize camera views, eye gaze, and 3D scene geometry together on a timeline.
Outcome
Enables intuitive exploration of spatial and temporal patterns without custom tooling.
Monitoring Training of 3D Reconstruction Models
Data scientistScenario
A data scientist is training a neural radiance field (NeRF) model and wants to monitor reconstruction quality during training.
Solution
They log rendered views, depth maps, and loss curves at intervals using Rerun, then visualize progress over training steps.
Outcome
Early detection of training issues (e.g., mode collapse, overfitting) by comparing visual outputs across epochs.
Pros & cons
Pros
- Fast and efficient due to Rust implementation
- Flexible and easy to use
- Supports multiple languages (C++, Python, Rust)
- Open source
- Powerful interactive visualizations
- Embeddable in notebooks and web apps
Cons
- Data management at scale is under development
- Commercial data platform is still in development with select design partners
Frequently asked questions
How do I get started with Rerun?Workflow
The fastest way is to follow the quick start guide for C++, Python, or Rust on the Rerun website. It walks through installing the SDK, logging basic data, and launching the visualizer.
What languages does Rerun support?General
Rerun officially supports C++, Python, and Rust. Community bindings may exist for other languages, but they are not officially maintained.
Is Rerun open source?General
Yes, Rerun is open source under an MIT or Apache 2.0 license. The source code is available on GitHub.
Can Rerun handle large-scale data?Limitations
Yes, Rerun offers managed infrastructure for cloud-based ingestion, storage, and streaming to handle datasets that exceed local memory. However, for very large datasets, you may need to consider network bandwidth and storage costs.
How does Rerun compare to other visualization tools?Comparison
Rerun is specialized for spatial and temporal data from computer vision and robotics, with a focus on minimal-code logging and fast performance via Rust. It is not a general-purpose plotting library like Matplotlib nor a full-featured data science platform like TensorBoard. Its strength lies in multimodal temporal exploration.
What should I do if I encounter issues?Workflow
Set RUST_LOG=debug before running to get verbose logging output. If the issue persists, open a ticket on GitHub or join the Rerun Discord community for support.
Related tools in AI Developer Tools

Open-source LLMOps platform for building and operating generative AI applications.

Sports tracking cameras and AI analysis tools for recording and improving team performance.

Firecrawl turns websites into LLM-ready data with scraping and crawling capabilities.

Full-stack TypeScript platform with realtime database for reactive apps.

Technology platform for restaurants, offering solutions for in-store and online operations.

Ultralytics provides vision AI tools and platforms for creating, training, and deploying ML models.