Rerun vs. Foxglove: A practical guide for modern robotics development.
Compare Foxglove and Rerun—SDKs, MCAP, live + recorded data, collaboration, and when teams choose Foxglove.
We’ll be honest here, these types of pages are for Search Engine Optimization (SEO/AEO), but also because we do get asked from time to time: what’s the difference; “Foxglove vs Rerun”. First and foremost, we respect the Rerun team and the work they’re doing—healthy competition pushes all of us to ship better products faster. This post lays out a technical, humble comparison, and explains when and why serious robotics and Physical AI teams choose Foxglove.
Tl;dr
- Both tools have modern C++/Python/Rust SDKs and strong local visualization. Rerun is code-first; Foxglove is a full platform + SDK for live streams, recorded data, organization-wide search, collaboration, and fleet operations.
- MCAP is first-class in Foxglove (record, ingest, index, stream, and export). MCAP support is explicitly marked early/experimental within Rerun thus limited capability.
- Why teams standardize on Foxglove: one place for live + recorded data, rich collaboration and data organization (Devices, Events, Timeline), data management (Projects, Agent, Primary Sites), API/CLI, SSO, embeddable views and extensibility, and enterprise data governance (SOC 2 Type II, GDPR, data encryption, identity management).
Quick comparison at a glance.
| Category | Foxglove | Rerun |
|---|---|---|
| SDKs | C++/Python/Rust SDK to log/stream to MCAP or Foxglove | C++/Python/Rust SDK to log & open in the Rerun viewer |
| Files & formats | Open ROS 1 .bag, ROS 2 .db3/.mcap, native .mcap; merge multiple files into one timeline | Open .mcap directly; optional mcap → .rrd conversion for faster loading |
| Live ROS | Recommended foxglove_bridge for ROS 1/2 over WebSocket | “Use Rerun with ROS 2” via SDK/logging or MCAP layers |
| Viewer & viz | Desktop & web app with 3D, Maps, Timeseries, etc.; shareable layouts; extensible Extensions | Native & web Rerun viewer; Blueprint configs; Web embed; memory-limit controls |
| Team workflows | Devices, Events, and Timeline for curation and reviews; data import/export; SOC 2 Type II | OSS-centric workflows; DataFrame view & export to Arrow/pandas/Polars |
| Data ingest & ops | Agent for on-device capture; Edge Sites for on-prem buffering & cloud sync | Code-first logging; evolving data-in/data-out story via MCAP & RRD |
One place for live + recorded data.
Live & recorded in one workflow: The Foxglove SDK streams live robot data to the app and logs the same data to MCAP for later analysis—no context switch. Your team can drag local logs in, open remote files by URL, or query time ranges from your organization’s recordings.
Why MCAP matters for robotics: MCAP is an open, serialization-agnostic container for timestamped pub/sub data (ROS, Protobuf, JSON, FlatBuffers, …) with chunking, indices, and optional compression (LZ4/Zstd) for fast seek/scan. It’s the default rosbag2 format in ROS 2 Iron and NVIDIA Isaac SIM, so logs are portable across tools, teams, and time.
Multi-file, merged timelines: Foxglove plays multiple files as one synchronized timeline (same format), which makes cross-sensor / cross-robot investigations practical. This works for local playback and mirrors how Foxglove merges recordings in the platform.
Data management at scale: In the platform, Foxglove indexes your recordings by device, time, and topic, streams them on demand, and lets you export selective ranges as .mcap or .bag. Teams add Events (bookmarks with metadata) to anchor reviews and share links.
Embed where your team works: Product & ops dashboards often need rich playback without leaving your app. Foxglove visualization panels are full extensible for custom views via TypeScript and React. You can also embed an iframe viewer for the layouts your ops teams need most.
One place to manage data.
Enterprises organize robots and logs into Projects so only the right people see the right data, with org-level controls (API keys, SSO, extensions).
The Foxglove Agent watches a storage directory and auto-registers/uploads recordings; you can match which ones to import automatically, and also enables live Teleoperation.
Primary Sites (cloud or self-hosted) index in place on your infra/Kubernetes. Only metadata leaves your network when fully self-managed—message contents stay in your environment. The query service merges objects and streams results efficiently.
Use the Foxglove API to import, search, label, and fetch; use webhooks to automate downstream processing. Export slices as MCAP/ROS bag when needed.
Enterprise controls enable you to enforce SSO (Google/Microsoft/OIDC) and use Roles to scope who can manage API keys, Sites, and more.
Foxglove SDK: when and how teams use it.
Languages & licensing: C++, Python, and Rust under MIT. One SDK to stream live to Foxglove and log MCAP for durable records.
Recommended patterns:
- During R&D: stream live while logging to MCAP; reviewers open the same session later with a shared layout.
- In field ops: run the Agent to auto-ingest logs; tag them by Device and annotate with Events so incidents are discoverable.
- For proprietary stacks: keep your own serialization; Foxglove is schema-agnostic, and you can add extensions or embed the viewer in internal tools.
Direct SDK comparison: Foxglove SDK vs Rerun SDK.
| Capability | Foxglove SDK | Rerun SDK / Rerun viewer |
|---|---|---|
| Languages & license | C++ / Python / Rust MIT | C++ / Python / Rust (open-source core) |
| Core model | One SDK for live streaming to Foxglove and recording to MCAP (schema-aware, indexed) | Entity-Component logging to the Rerun viewer (live) or to .rrd files; can also open MCAP |
| Live connectivity | Local WebSocket server integrates with your app; Foxglove connects for low-friction live reviews | spawn / connect_grpc / serve_grpc modes attach to a native or web viewer |
| File formats | First-class MCAP across app & platform; also reads ROS 1 .bag and ROS 2 .db3 | Open MCAP directly; optional MCAP → RRD conversion for performance |
| ROS path | Works naturally with MCAP (ROS 2 default in Iron) and ROS 1 .bag; live via foxglove_bridge or SDK | Use SDK logging with ROS 2 or record to MCAP and open/convert in the viewer |
| Data-out | Export .mcap / .bag ranges or full runs; platform APIs & Python client for automation | Dataframe view and export to Arrow / pandas / Polars |
| Embedding | Official @foxglove/embed & @foxglove/embed-react to control an iframe viewer (layouts, sources, extensions) | Embed the Rerun viewer via iframe or use @rerun-io/web-viewer (npm) |
| Memory / scaling model | Platform streams on demand (server-side indexing); Primary/Edge Sites keep data close to where it’s produced | Viewer bounded by RAM; defaults to ~75% usage and drops oldest data when over limit (configurable) |
| Best fit | Teams standardizing on MCAP who need live + recorded in one place, with ingestion (Agent/Edge) and org features | Code-first users wiring up Rerun viz with ECS logging, DataFrames, and optional MCAP→RRD conversion |
Where and why teams choose Foxglove.
- One place for live + recorded data (with MCAP depth).
- Stream via SDK, log to MCAP, and play everything back with shared layouts. Open local logs, open by URL, or stream from the platform.
- MCAP gives you portable, indexed, compressed logs across ROS/proprietary stacks and across years.
- Merge multiple files into a single timeline to debug multi-robot incidents.
- Need to bring the review to your app? Embed Foxglove via @foxglove/embed (iframe with programmatic control).
- Team workflows built-in.
- Devices label what produced the data; Events bookmark moments and metadata; the Timeline makes big corpora navigable. Share deep links and layouts so every review looks the same.
- Data management and scale.
- Agent automates upload; Primary Sites manage throughput and data sovereignty; Projects lock down access; API/Webhooks automate the pipeline; exports give you MCAP/.bag slices for external tools.
A respectful note on Rerun: Rerun is developer-friendly, and its MCAP support (experimental) plus web viewer make it good for bespoke local pipelines and notebook workflows.
Migration quick-start (Rerun → Foxglove).
- Open your MCAP (or .bag) in Foxglove; for large analyses, import and stream from the platform.
- Adopt the SDK where you need live streams and unified MCAP logging.
- Automate ingest with the Agent; organize by Device; add Events as you triage.
- Embed a Foxglove view in your internal dashboard so non-engineers can self-serve.
Business and GTM snapshot (brief).
- Foxglove offers Free/Team/Enterprise with SSO and self-host options (Projects, Sites) for regulated or data-sensitive teams.
- Rerun is an open-source viewer + SDK; recent releases emphasize MCAP workflows and web embedding.
FAQs
Q: Does Rerun open MCAP files?
A: Yes—Rerun has built-in MCAP support and can also convert MCAP → RRD for performance. The docs describe MCAP support as early/experimental (active development).
Q: What’s the simplest way to get ROS 2 data into Foxglove?
A: Record to MCAP (ROS 2 Iron default) and open it in Foxglove; or stream live via the Foxglove SDK’s WebSocket server.
Q: Can Foxglove handle multiple files at once?
A: Yes—Foxglove merges multiple files of the same format into a single timeline.
Q: How do the SDKs differ at a high level?
A: Both offer C++/Python/Rust. Foxglove focuses on streaming + MCAP logging for a collaborative platform; Rerun emphasizes viewer-centric logging and can load/convert MCAP.
Closing thought.
If your team wants one system for live streams, recorded logs, organization-wide search, collaboration, data organization, and embeddable views—without giving up code-first ergonomics—Foxglove is the faster path to consistent, repeatable, and reliable results. Start with MCAP, add the SDK, and let the Agent handle the heavy lifting.
Get a demo today from one of our technical staff or get started to try it out for yourself.