Rerun (rerun.io)
Last reviewed
May 16, 2026
Sources
14 citations
Review status
Source-backed
Revision
v1 · 2,958 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
May 16, 2026
Sources
14 citations
Review status
Source-backed
Revision
v1 · 2,958 words
Add missing citations, update stale details, or suggest a clearer explanation.
Rerun is an open-source multimodal data stack and visualization system built for robotics, computer vision, and other forms of physical AI. The project is developed by Rerun Technologies AB, a Stockholm-based company founded in 2022 by Nikolaus West, Emil Ernerfeldt, and Moritz Schiebold. Its core deliverables are a viewer application and a logging SDK that lets engineers record, query, and play back time-aligned streams of images, point clouds, transforms, tensors, joint states, and text from a single timeline. The SDKs and viewer are dual-licensed under the MIT License and Apache License 2.0, and the project is hosted on GitHub at rerun-io/rerun.
Rerun positions itself as the "data layer for physical AI" and is used by robotics teams, perception engineers, and dataset curators who need to debug multi-rate sensor pipelines. It has been picked up by groups inside Meta, Google, Hugging Face, NVIDIA, and Unitree, and powers visualization for Hugging Face's LeRobot project, Meta's Project Aria egocentric research platform, and NVIDIA's PyCuVSLAM. In March 2025 the company closed a $17 million seed round led by Point Nine, with Sunflower Capital, Costanoa Ventures, and Seedcamp participating, bringing total funding to roughly $20.2 million.
Rerun sits next to, and often inside, the workflows that older tools like ROS RViz, Foxglove Studio, and TensorBoard were built for, but it is structured around an Apache Arrow columnar store rather than a ROS-style publish-subscribe graph. That choice is what lets it scrub through large multimodal episodes quickly and, in the commercial Rerun Hub product, stream training data directly to GPUs without intermediate preprocessing.
Rerun was incorporated in 2022 in Stockholm, Sweden. The three co-founders had previously worked across robotics, computer vision, and game development, and the team has since grown with hires from Apple, AWS, Meta, Unity, Zenly, and Zipline.
Nikolaus West serves as CEO. Emil Ernerfeldt is CTO and is the original author of egui, the most widely used immediate-mode GUI library in Rust. Ernerfeldt studied computing science at Umeå University, where his master's project produced the 2D physics sandbox Phun, which evolved into the educational app Algodoo at Algoryx Simulation. He later worked on graphics and engine programming for Gauntlet at Arrowhead Game Studios before starting Rerun. Moritz Schiebold rounds out the founding team and focuses on product and go-to-market.
The original problem the founders described was that perception and robotics teams almost always end up rebuilding the same kind of debugging stack in-house. Logs in one place, video in another, sensor data in a third, and a homegrown viewer that nobody outside the team can use. "Previously, everyone built much of their visualization and data infrastructure in-house," West said when the seed round was announced, but the resulting tools tended to be brittle. Rerun's pitch is to ship that infrastructure as a standard library so that physical AI teams can focus on the model and the robot.
The company sits inside a broader category that investors and the press now call "physical AI," covering humanoid robots, autonomous vehicles, drones, AR/VR headsets, and industrial perception. Rerun's bet is that this category needs its own multimodal data stack in the same way that web-scale machine learning ended up with TensorBoard and Weights & Biases for scalar metrics.
Rerun is split into three main pieces: a Rust core, a set of language SDKs, and a native viewer.
The core is written in Rust and built on Apache Arrow. Logged data is stored in column chunks rather than as ROS-style messages, which means that a single timeline can hold images, depth maps, point clouds, transforms, scalars, and text without the team needing to define and maintain a custom message schema for every new modality. The store is multi-rate by design, so a 200 Hz IMU stream and a 30 Hz camera stream sit on the same timeline without being resampled. Each logged value is associated with one or more entities (think of them as paths like world/robot/camera) and one or more timelines (wall clock, frame index, controller tick, anything the user picks), which is what makes the time-aligned scrubbing work.
The SDKs are thin wrappers that send log calls to the store. As of mid-2026 there are three first-party SDKs:
pip install rerun-sdk, which is the most widely used and the entry point for most robotics and computer-vision tutorials.All three SDKs share the same data primitives. A rr.log call in Python produces the same on-disk layout as the equivalent call in Rust or C++, and the recordings are portable across operating systems.
The viewer is a native desktop application built with egui and wgpu. It runs on Windows, macOS, and Linux, and is also available as a WebAssembly build that can be embedded in notebooks, browser pages, or web dashboards. Rendering is GPU-accelerated, which is what allows it to play back dense point clouds and high-resolution video on a single timeline without dropping frames.
Rerun also ships a commercial product called Rerun Hub. Hub adds a catalog, byte-range indexing, and retrieval over recordings stored in cloud object stores, along with single sign-on, security controls, and data governance features intended for enterprise teams. The hub piece is what enables streaming dataset mixes directly to GPUs during training, without the team having to write a separate data loader.
| Feature | What it does |
|---|---|
| Time-aligned viewer | Synchronizes images, point clouds, scalars, and text on a single timeline so engineers can scrub through an episode and see every sensor together. |
| Multi-rate timelines | Stores multiple timelines (wall clock, frame index, sim tick) for the same recording so high-rate IMU data and low-rate camera frames are not forced onto a common sampling grid. |
| Apache Arrow store | Uses columnar chunks rather than per-message types so a single recording can hold images, tensors, transforms, joints, and metadata without custom schemas. |
| Native desktop viewer | Cross-platform GPU-accelerated application written in Rust with egui and wgpu, handles dense point clouds and large recordings smoothly. |
| Distributed logging | SDK clients can log from many processes and machines into a single store, useful for multi-robot systems and CI pipelines. |
| Dataframe and SQL queries | Recordings can be queried with dataframe operations and SQL for analytics, dataset curation, and offline evaluation. |
| Web viewer | WebAssembly build that runs in Jupyter notebooks, Colab cells, and embedded browser pages. |
| MCAP and bag interop | Reads MCAP files directly; ROS bag files are typically replayed through a bridge node into Rerun. |
| Custom blueprints | Layouts (panels, plots, 3D views) can be defined in code and shipped with the SDK, so the viewer opens with the right configuration for a given project. |
| Streaming to training | Through Rerun Hub, columnar recordings can be streamed straight to GPUs as training data without intermediate ETL jobs. |
The viewer is also extensible. Custom data types can be defined in the SDK, and the rendering side of the viewer can be extended through the same Rust API the core uses internally, which is how integrations with engines like Bevy and Unity-side tools are typically built.
Rerun is general enough that the same library shows up in very different parts of the physical AI stack. The most common patterns look like this.
| Use case | Typical workflow |
|---|---|
| Robotics teleoperation debugging | Stream joint states, camera feeds, and end-effector poses live into the viewer while a human operator drives a robot, then replay the recording to find where things went wrong. |
| Dataset visualization for imitation learning | Open recordings from LeRobot or a custom collection, scrub through episodes, and inspect failure cases before training a policy. |
| Perception pipeline debugging | Log every step of a vision pipeline (raw image, detections, depth, fused output) under the same entity path and view them side by side on one timeline. |
| SLAM and 3D reconstruction | Log camera trajectories, feature points, and reconstructed meshes or splats, which is how systems like Brush and PyCuVSLAM use Rerun. |
| Autonomous vehicle development | Visualize lidar point clouds, radar returns, lane detections, and planner state for a single drive, often through a Python or C++ SDK bridge from an existing autonomy stack. |
| AR/VR research | Log egocentric video, IMU traces, eye-tracking signals, and 3D scene reconstructions, as in Meta's Project Aria. |
| Simulation introspection | Log per-tick state from a simulator (Genesis, Isaac, Bevy-based sims) to see what the physics engine produced step by step. |
| Notebook-based exploration | Use the WebAssembly viewer inside Jupyter or Colab to inspect tensors, images, and 3D scenes during model prototyping. |
In many of these flows Rerun is not the only tool in the stack. Teams still run a simulator, a training framework, and often a ROS or autonomy middleware alongside it. Rerun is the layer that ties the heterogeneous data those systems produce into a single, scrubable view.
For a project that did not exist before 2022, Rerun has spread quickly inside the physical AI community.
The public flagship is Hugging Face's LeRobot, an open-source library for end-to-end robot learning. LeRobot uses Rerun as its default visualizer for both collected datasets and policy rollouts, which has put the viewer in front of a large share of new robot-learning researchers. Meta Reality Labs uses Rerun in tutorials and reference code for Project Aria, its smart-glasses research platform, which deals with egocentric video, eye tracking, and IMU streams.
In the NVIDIA ecosystem, Rerun is the visualization stack used in PyCuVSLAM, NVIDIA's GPU-accelerated visual SLAM library, and shows up in robotics demos that combine NVIDIA Cosmos world foundation models with downstream perception pipelines. Google has used Rerun in open-source robotics work, and DeepMind's Brush 3D reconstruction engine, which builds Gaussian splats from images, uses Rerun for visualization. Unitree, the Chinese maker of quadruped and humanoid robots, also publishes Rerun-based reference code for its platforms.
On the research side, Rerun has been adopted by a long tail of academic robotics labs working on imitation learning, mobile manipulation, and humanoid control, and it appears in tutorials for warehouse-automation startups such as Ultra. Companies whose teams or open-source releases have integrated Rerun include Meta, Google, Hugging Face, NVIDIA, Unitree, and many smaller robotics startups.
Quantitatively, the rerun-io/rerun GitHub repository has roughly 10.7k stars and over 700 forks, with a development cadence of new minor versions every few weeks (latest 0.32.0 in May 2026 with 74 releases shipped overall).
Rerun has raised across two disclosed rounds.
| Date | Round | Amount | Lead | Other participants |
|---|---|---|---|---|
| 2023 | Pre-seed / seed extension | ~$3.2 million (implied) | Costanoa Ventures | Seedcamp and angels |
| March 2025 | Seed | $17 million | Point Nine | Sunflower Capital, Costanoa Ventures, Seedcamp |
Total funding to date is approximately $20.2 million.
The March 2025 round also brought in a long list of angel investors with strong ties to developer tools and physical AI. Among them are Guillermo Rauch, CEO of Vercel; Oliver Cameron, CEO of Odyssey; Wes McKinney, the original author of pandas and a co-creator of Apache Arrow and Ibis; Eric Jang, VP of AI at 1X; and Nicolas Dessaigne, a general partner at Y Combinator and co-founder of Algolia.
The presence of Wes McKinney is notable because Rerun's data model is essentially Arrow under the hood. Rauch's involvement reflects the company's positioning as a developer tools play first and a robotics company second.
Rerun is most often compared to RViz (the canonical ROS visualizer), Foxglove Studio, and TensorBoard. The three tools target overlapping but distinct workflows.
| Tool | Primary domain | Architecture | License | Live ROS | Web viewer | Strength |
|---|---|---|---|---|---|---|
| Rerun | Multimodal robotics and CV logging | Rust core, columnar Arrow store, native viewer | MIT and Apache 2.0 | Via bridge nodes | WebAssembly build | Code-first SDK with shared schema across Python, Rust, and C++; fast dense visualization |
| RViz / RViz 2 | ROS robot debugging | C++ desktop app tightly coupled to ROS | BSD 3-Clause | Native | None | Interactive 3D markers, TF, URDF for in-loop ROS development |
| Foxglove Studio | Robotics data inspection and team collaboration | Desktop and browser front end, proprietary backend | Proprietary, freemium | Via foxglove_bridge and SDK | Yes, first class | Multi-user dashboards, MCAP playback, cloud collaboration |
| TensorBoard | Scalar and ML metric tracking | Python backend, browser front end | Apache 2.0 | No | Yes | Standard for training-curve metrics and scalar dashboards |
The practical division most teams settle on is something like this. RViz is still the right tool for low-level ROS debugging with interactive markers and TF. Foxglove is the right tool when the priority is a shared dashboard for a robotics team with cloud storage and MCAP playback. TensorBoard remains the default for plain training metrics. Rerun is the right tool when the project produces heterogeneous multimodal data (images, point clouds, tensors, text, custom signals) that needs to live on a single timeline and be queried later, and when the team wants the same SDK to work from Python, Rust, and C++. It is also the tool that handles dense point clouds and large recordings best, because the viewer is GPU-accelerated and the store is columnar.
Rerun's main limitations relative to the alternatives are that it is not natively a ROS tool (ROS bags typically need to be replayed through a bridge), it does not yet open .bag files directly, and the collaboration and cloud features are still maturing inside the Rerun Hub commercial product.
Rerun's SDKs (Python, Rust, C++) and the viewer application are dual-licensed under the MIT License and the Apache License 2.0. Users can pick whichever license better fits their downstream project. There is no copyleft component to the core, and there is no paid tier required to use the open-source viewer, SDKs, or .rrd recording format in production.
The commercial product, Rerun Hub, sits on top of the open-source core and is licensed separately. It is currently in early access and is intended for enterprises that need cloud-hosted catalogs, multi-tenant access controls, single sign-on, and a managed retrieval layer over recordings stored in object storage.
The project's open-core posture (permissive license for the SDK and viewer, commercial offering for hosted infrastructure) is similar to that of HashiCorp Terraform's earlier years or Grafana Labs. It is meant to lower the friction of putting Rerun into a robot stack without forcing teams to commit to a vendor.
Reception inside the robotics and computer vision communities has been broadly positive. The viewer is regularly cited in tutorials and blog posts as a faster, more pleasant alternative to writing one-off matplotlib code or hand-rolling a Three.js debugger. Robohub published a profile in 2024 calling it "an open source package for beautiful visualizations," and TechCrunch's coverage of the 2025 seed round framed the company as the leading bet on an open data stack for physical AI.
Foxglove's own 2025 comparison piece acknowledged that Rerun is the strongest "code-first" option in the space and that its SDKs are particularly comfortable for Python users, while arguing that Foxglove's integrated dashboards still win for teams that want a single hosted product. ReductStore's independent comparison reached a similar split: RViz for deep ROS work, Foxglove for collaboration, Rerun for performance on dense multimodal data.
The most common criticisms in community discussions are the ones the company itself acknowledges: ROS integration is via bridge nodes rather than native, direct .bag reading is not yet supported, and large-scale team collaboration features are still being built out inside Rerun Hub. The dual-licensed MIT and Apache stance, the speed of the native viewer, and the cross-language SDKs are the features that get cited most often in favor of the project.
On the investor side, the fact that Point Nine led the seed and that the round attracted angels like Wes McKinney, Guillermo Rauch, Eric Jang, and Nicolas Dessaigne has been read as a signal that the developer-tools community sees physical AI infrastructure as a serious category, not a side branch of ROS.