Announcing: the Foxglove SDK

We're thrilled to announce the public release of the Foxglove SDK—a unified toolkit designed to make integrating your robotics stack with Foxglove easier than ever before. Whether you're building a small research project or scaling a production fleet, the Foxglove SDK simplifies your journey with a consistent, powerful, and intuitive API for live visualization, structured logging, and remote monitoring.

Why we built the Foxglove SDK.

Integrating robotics systems with visualization and debugging tools has historically been messy and fragmented. It would often involve:

• Manually interact with MCAP files and websockets.
• Implementing custom logging stacks.
• Grappling with inconsistently documented protocols.

The Foxglove SDK abstracts away the complexities and lets you focus on what matters most by unifying scattered tools and processes under one consistent API, including:

Unified logging interface

• Record to MCAP files and stream live data with the same code.
• Log from your devices, simulations, and jupyter notebooks.

Cross-language consistency

• Available in C++, Python, and Rust.
• All bindings share a common Rust core, ensuring consistent behavior and avoiding feature drift across languages.

High-level and low-level APIs

• Use high-level APIs for common schemas like CompressedImage and SceneEntity.
• Drop down to low-level APIs to log fully custom message types with minimal boilerplate.

Live visualization support

• Seamlessly stream live data to the Foxglove app via WebSocket.
• Support for future UDP-based protocols (e.g., WebRTC, WebTransport) is on the roadmap to better handle lossy network conditions.

Getting started: simplicity by design.

Getting up and running is easy. Here's a simple Python example to get you started with both live streaming and recording to an MCAP file:

import foxglove as fg

from foxglove.schemas import Pose, PoseInFrame, Quaternion, Timestamp, Vector3

# start a live websocket server
fg.start_server()

# simultaneously log to an mcap file
with fg.open_mcap("foo.mcap"):
   fg.log("/example", PoseInFrame(
       timestamp=Timestamp(sec=0),
       frame_id="ego",
       pose=Pose(
           position=Vector3(x=1, y=2, z=3),
           orientation=Quaternion(),
       ),
   ))

With just a few lines, you can:

• Open a local server for live visualization.
• Write structured logs to disk.
• Stream data to the Foxglove Web or Desktop app.

Designed for robotics, built for developers.

We’re building the Foxglove SDK to feel idiomatic in each supported language. We prioritize ease of use without sacrificing power.

To move faster and provide a more consistent experience, we’ve been consolidating functionality into a core codebase, written in Rust. We then write Python and C++ SDKs around this core. This will feel natural to users of those languages, while still maintaining some consistency between them. This will give us improved maintainability and allow us to focus on what matters: making it easier to integrate with robotics stacks and unify output for MCAP recording and live visualization.

At the core of the SDK is the foxglove Rust crate, responsible for:

• Context management for writing to MCAP files and the Foxglove app.
• Buffering and connection management for the WebSocket server.
• Serialization and deserialization of Foxglove schemas, when users don't care about having control over that.

Where it makes sense, we auto-generate parts of the SDK, including schemas and type-safe channels. This allows us to support the full range of schemas that the app supports, but also be flexible with how the interfaces are presented in each language.

Why Rust? C++ probably has broader adoption across robotics today, but Rust usage is growing rapidly, and we've found it a good choice with modern tooling and ergonomics.

Join us on this journey.

The Foxglove SDK represents a leap forward in simplifying how you interact with your systems. We invite you to dive in, try it out, and send us feedback. Your input will shape the future of how the robotics world logs, visualizes, and scales.

Get Started with the Foxglove SDK