We’re thrilled to announce internationalization support in Foxglove Studio – a feature contributed by a member of the Foxglove community. This update adds initial support for Chinese, while also creating a framework for others to contribute additional languages and translations.

The pull request leverages i18next, an internationalization framework written in JavaScript, to add a “Language” setting to Foxglove Studio’s in-app Preferences:

Chinese translations in
Preferences tab

Having all translations for a given view isn't required to contribute them to the Foxglove Studio repo.

Since the Foxglove platform is utilized by robotics teams across the globe, we are very excited to see how this localization support will benefit both current and future Foxglove Studio users.

To add your own translations, check out our contribution guide and open a pull request in the Foxglove Studio GitHub repo. Translations are organized by both language and app view (e.g. Chinese for the Preferences dialog), so you can take on manageable sections of the app without committing to translating the entire app for your language.

We hope this newly added internationalization support makes our platform even easier to use for our growing community of Foxglove users! If you have any feedback or questions, please feel free to reach out to the Foxglove team directly in our Slack community.


In previous posts, we've covered how visualizing ROS 2 transforms in Foxglove Studio can help us describe the relative positions of a robot’s components.

In this tutorial, we'll learn how ROS 2 transforms can help us calculate the position of an object not explicitly linked to a robot – in relation to both the sensor that detected it and the actuator that will interact with it.

Calculating positions in different frames

Let’s consider the robot model from our previous ROS transforms tutorials:

If our robot’s sensor were to detect an object, we'd have that object’s position in the sensor\_link frame. To use our robot’s arm to grab it, however, we’d then need to calculate the object’s position in the arm\_end\_link frame.

With the ROS 2 tf2 library, we can easily transform our object’s position across frames – all without worrying about any of the complicated mathematical operations happening under the hood – and deduce how our arm needs to move to complete this task.

Create a sensor node to simulate object detection

First, let’s create a node that simulates our robot’s sensor.

In a sensor.cpp file, include the following libraries:



Define a Sensor class with the following private variables:



It should also include a timer callback, to periodically publish the detected object’s position:



Next, write a class constructor that publishes the detected object’s pose on a timer (every second). Since poses are not transform messages, they will be published on a /detected\_object topic (instead of /tf or /tf\_static):



Finally, add the main function that declares and spins the node:



Create a listener node to calculate the object’s position

Next, let’s create a listener node to transform the object’s position from the sensor\_link frame to the arm\_end\_link frame.

In a tf\_listener.cpp file, include the following libraries:



Define a TfListener class with the following private variables:



It should also include a poseCallback function, which looks up the transform between the source and target frames every time the sensor sends a new pose:



Next, write a class constructor that loads and listens to your buffer of transforms, and then subscribe’s to the sensor’s /detected\_object pose topic:



Lastly, write a main function that declares and spins the node:



Add the following lines to your CMakeLists.txt to add the executables to the compilation list:



Compile your package with $ colcon build --symlink-install.

Launch nodes and visualize transforms

Let’s first publish the transforms between our base\_link and both arm\_base\_link and sensor\_link. Use the static\_transform\_publisher we’ve learned in the previous post:



You will also need the tf\_broadcaster that publishes the arm\_end\_link frame:



Finally, run your new nodes:



Open a connection to your data in Foxglove Studio using the Foxglove bridge. Open a 3D panel to visualize the frames and detected object positions, and a Log panel to see the printout of our object’s position.

visualizing in Foxglove Studio
The object is represented by a purple arrow in the 3D panel. Its position in the arm\_end\_link frame is printed by the tf\_listener node in the Log panel.

Notice that the object arrow is different from the axes arrows that represent each frame. This is because the object is not a transform, but a Pose. If you use the Teleop panel to move the arm\_end\_link frame around, you can see firsthand how the position of your detected object changes.

Create a launch file

In a launch folder, let’s create a tf\_launch.launch.py file to launch all nodes together:



Add the following lines in the CMakeLists.txt:



Compile your package with $ colcon build --symlink-install.

Now you can start all nodes, the Foxglove bridge connection, and Foxglove Studio with a single command.

launching in Foxglove Studio

Stay in touch

By leveraging ROS 2 transforms and the tf2 library, you can easily integrate your robots' sensors and actuators to work better together.

For a reference to all the code covered in this post, check out our foxglove/tutorials GitHub repo. And as always, feel free to reach out to us directly in our Slack community to request a topic for the next tutorial!


Foxglove users can now set their storage region to the United States or Europe when creating a Foxglove organization.

With this new support, you can now upload robotics data to Foxglove Data Platform without having to export log data outside of your geography. This can aid in compliance with GDPR and other privacy requirements, giving you additional confidence in data privacy and security.

When you first sign up for a Foxglove organization, you will be prompted to choose a storage region for your default Foxglove site. If you’re on the Enterprise plan, you can also bring your own cloud storage to set up self-managed sites in the storage region of your choice.

We’re excited to see this new feature unlock more data management capabilities for users across the world. Check out the Data Platform docs for more information on how to add self-managed Primary Sites. If you have any other questions, you can contact us directly or join our community Slack for live support.


Announcing EU Hosting for Foxglove Data

Read more:

Ready to try Foxglove?