Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
jazzy

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
kilted

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/schemas.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status MAINTAINED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/schemas/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
rolling

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro ardent showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro bouncy showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro crystal showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro eloquent showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro dashing showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
galactic

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/schemas.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status MAINTAINED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/schemas/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
foxy

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/schemas.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status MAINTAINED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/schemas/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
iron

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/schemas.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status MAINTAINED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/schemas/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro lunar showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro jade showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro indigo showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro hydro showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

No version for distro kinetic showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
humble

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
melodic

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/schemas.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status MAINTAINED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/schemas/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange

Package symbol

foxglove_bridge package from foxglove_msgs repo

foxglove_bridge foxglove_msgs

ROS Distro
noetic

Package Summary

Tags No category tags.
Version 0.11.0
License MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/foxglove/foxglove-sdk.git
VCS Type git
VCS Version main
Last Updated 2025-08-27
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

ROS Foxglove Bridge

Additional Links

Maintainers

  • Foxglove

Authors

  • Foxglove

foxglove_bridge

[!IMPORTANT] This upcoming version of foxglove_bridge is built using the Foxglove SDK and is in public beta. There may be some remaining bugs or unexpected behavior. We encourage users to take it for a spin and submit feedback and bug reports.

Older versions of foxglove_bridge, including those targeting ROS 1, still are available from the foxglove/ros-foxglove-bridge repository or via the ROS package index for your ROS distro.

ROS Humble version ROS Jazzy version ROS Kilted version ROS Rolling version

High performance ROS 2 WebSocket bridge using the Foxglove SDK, written in C++.

Motivation

Live debugging of ROS systems has traditionally relied on running ROS tooling such as rviz. This requires either a GUI and connected peripherals on the robot, or replicating the same ROS environment on a network-connected development machine including the same version of ROS, all custom message definitions, etc. To overcome this limitation and allow remote debugging from web tooling or non-ROS systems, rosbridge was developed. However, rosbridge suffers from performance problems with high frequency topics and/or large messages, and the protocol does not support full visibility into ROS systems such as interacting with parameters or seeing the full graph of publishers and subscribers.

The foxglove_bridge uses the Foxglove SDK (this repo!), a similar protocol to rosbridge but with the ability to support additional schema formats such as ROS 2 .msg and ROS 2 .idl, parameters, graph introspection, and non-ROS systems. The bridge is written in C++ and designed for high performance with low overhead to minimize the impact to your robot stack.

Build and install

Install using Docker

Docker images are built and published to our public Docker image registry for your convenience.

[!NOTE] We currently only provide Docker builds targeted to the linux/amd64 platform.

Images can be pulled with

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:<tag>

where <tag> takes the form of:

ros-<ROS distro>-<foxglove SDK version>

For example, if you wanted to pull an image based on ROS Kilted and Foxglove SDK v0.11.0:

docker pull us-central1-docker.pkg.dev/foxglove-images/images/foxglove_bridge:ros-kilted-v0.11.0

Build from source

Getting the sources

Clone this repo from GitHub and cd to the local ROS workspace:

git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/ros

All commands in this README hereafter assume you’re in the /ros subdirectory relative to the repository’s root.

Build using your ROS environment

Make sure you have ROS installed and your setup files are sourced. Then build:

make

Build using Docker

You can also build the bridge using a ROS environment within a Docker container:

# You can also append your preferred ROS 2 distro codename (e.g. make docker-build-jazzy). If omitted, ROS 'rolling' is used.
make docker-build

The built ROS workspace will be written to /ros in your foxglove_sdk directory.

Running the bridge

To run the bridge node, it is recommended to use the provided launch file.

If foxglove_bridge was built outside your ROS workspace, you need to source the local setup files so ROS 2 can find it:

source install/local_setup.bash

Once ROS is aware of the foxglove_bridge package, you can launch the bridge process:

ros2 launch foxglove_bridge foxglove_bridge_launch.xml port:=8765

You can also add foxglove_bridge to an existing launch file:

```xml

File truncated at 100 lines [see the full file](https://github.com/foxglove/foxglove-sdk/tree/main/ros/src/foxglove_bridge/README.md)
CHANGELOG
No CHANGELOG found.

Launch files

  • launch/foxglove_bridge_launch.xml
      • port [default: 8765]
      • debug [default: false]
      • address [default: 0.0.0.0]
      • tls [default: false]
      • certfile [default: ]
      • keyfile [default: ]
      • topic_whitelist [default: ['.*']]
      • param_whitelist [default: ['.*']]
      • service_whitelist [default: ['.*']]
      • client_topic_whitelist [default: ['.*']]
      • min_qos_depth [default: 1]
      • max_qos_depth [default: 10]
      • num_threads [default: 0]
      • send_buffer_limit [default: 10000000]
      • use_sim_time [default: false]
      • capabilities [default: [clientPublish,parameters,parametersSubscribe,services,connectionGraph,assets]]
      • include_hidden [default: false]
      • asset_uri_allowlist [default: ['^package://(?:[-\\w%]+/)*[-\\w%.]+\\.(?:dae|fbx|glb|gltf|jpeg|jpg|mtl|obj|png|stl|tif|tiff|urdf|webp|xacro)$']]
      • ignore_unresponsive_param_nodes [default: true]

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged foxglove_bridge at Robotics Stack Exchange