Real-Time Visualization with Foxglove and RT-Kernel

Foxglove integration for RT-Kernel is more than just a software add-on; it’s a bridge between two worlds. It brings the observability and agility of modern robotics development into embedded real-time systems.

Bringing observability into embedded

Robots and machines are no longer hidden behind lines of code and blinking LEDs. With the new Foxglove integration for RT-Kernel RTOS, what happens inside a real-time system can now be seen, explored, and understood in real time. Complex sensor data, motion paths, and control loops become visual, alive, and interactive.

RT-Labs has brought modern visualization into the heart of embedded development. The integration connects RT-Kernel directly to Foxglove, letting engineers stream structured data over Ethernet and watch their systems in action. This article explains how it works, why it matters, and how it’s changing the way real-time robotics is built and tested.

Foxglove in Modern Robotics Workflows

In today’s robotics projects, data is king. Whether it’s sensor streams, robot states, or diagnostic info, engineers need to see what their robots are thinking and doing. Foxglove Studio has emerged as a purpose-built platform for exactly this task. It’s a desktop and web-based tool that allows robotics teams to visually debug robots, inspect sensor data, replay logs, and collaborate on findings. Originating in the ROS (Robot Operating System) ecosystem, Foxglove has grown to support many data sources beyond ROS. It enables visualization of multimodal data, from camera feeds and point clouds to actuator signals and system logs, all in a single unified interface.

One important note about Foxglove is its licensing model: it’s open-core, which means the company provides a core platform and libraries that are free (and partially open source), while some advanced features and cloud services are proprietary. In practice, this open-core approach has made Foxglove widely accessible to developers (a free tier and community tools exist), but it isn’t a fully open-source project. Still, Foxglove Studio has quickly become a staple in modern robotics workflows due to its powerful visualization capabilities and ease of integration. Teams can connect Foxglove to live robots or recorded data and immediately get rich introspection, graphs of sensor readings over time, 3D renderings of environments from lidar, images from cameras, plots of joint angles, and much more. By offering these insights at a glance, Foxglove helps engineers iterate faster and with greater confidence.

www.foxglove.dev

RT-Kernel: A Real-Time Foundation for Embedded Systems

On the other side of the robotics equation is RT-Kernel, the real-time operating system developed by RT-Labs. RT-Kernel is a compact and efficient RTOS designed for embedded systems that demand hard real-time behavior. In applications like industrial control, automotive powertrain, or robotics, real-time behaviour is critical, i.e. tasks must execute within strict deadlines and with minimal jitter. RT-Kernel was built to meet these demands. It provides a secure and reliable kernel that can schedule tasks with deterministic timing, manage hardware interrupts promptly, and prioritize critical operations so nothing gets delayed unpredictably. Its small footprint and optimized design mean it can run on resource-constrained microcontrollers while still delivering high performance.

RT-Kernel has been battle-tested in domains such as manufacturing and automotive, where safety and precision are highly important. It supports a range of processor architectures and includes drivers and support for communication protocols commonly used in industry (Ethernet, CAN, etc.). This makes it a strong foundation for robotics as well, especially for robots that require real-time responsiveness (for motion control, sensor fusion, etc.) on embedded hardware. Until now, however, one aspect where RT-Kernel differed from larger operating systems was in developer-facing tooling. Traditional robotics stacks (like ROS on Linux) have extensive tools for logging, visualization, and debugging. An engineer working with an RT-Kernel device might have relied on custom logging or low-level debuggers to understand what was happening inside the system. This is where the new Foxglove integration changes the game, blending RT-Kernel’s real-time strengths with Foxglove’s observability.

Streaming Real-Time Telemetry from RT-Kernel to Foxglove

The Foxglove integration for RT-Kernel is a new add-on component that enables RT-Kernel-based devices to stream structured telemetry data directly into Foxglove Studio in real time. In simple terms, it turns a real-time embedded device into a live data source that a developer’s PC can connect to and visualize. Instead of treating an embedded system as a “black box” that only outputs occasional logs, this integration allows the system to continuously broadcast its internal state over a network connection. An engineer can run Foxglove Studio on their computer, open a connection to the device over Ethernet, and immediately watch the real-time data flowing out of the embedded system as the robot operates.

What kind of data can be streamed? Virtually any telemetry or state information that the embedded software can access. For instance, point cloud data from a 3D lidar sensor can be sent out and viewed live in Foxglove’s 3D viewer, showing a robot’s perception of its environment. Joint positions and motor states from a robotic arm’s controllers can be published so that the arm’s movements and angles are plotted in real time, allowing developers to see each joint’s behavior or trajectory. Camera images or video frames captured by an embedded vision sensor can be streamed to Foxglove, so engineers get a live feed without needing additional custom PC software. And of course, various diagnostics and system health metrics can be sent as structured messages, whether it’s battery voltage, CPU load, error codes, or custom status flags, all of which can be displayed in Foxglove’s dashboards or time-series plots.

Crucially, the data is transmitted in a structured JSON format. This means instead of just spitting out plain-text logs or ad-hoc strings, the RT-Kernel integration organizes telemetry into JSON objects with well-defined fields (keys and values). The integration uses structured JSON telemetry so that Foxglove Studio knows exactly how to interpret each incoming message – for example, a message might be a JSON object representing a sensor reading:

				
					{"sensor": "wheel_speed", "value": 42.7, "unit": "rpm", "timestamp": 1633036800}
				
			

By using structured messages, Foxglove can decode the fields and allow the user to visualize or plot them appropriately (perhaps plotting value over time, etc.).

Under the hood, the system leverages JSON Schema definitions to describe each type of message. JSON Schema is a way to formally specify the structure of JSON data (what fields, what types, nested structure, etc.). When Foxglove Studio connects to the device, the device’s Foxglove server component provides the schemas for the message types it will send. This dynamic schema exchange means Foxglove doesn’t need any hardcoded knowledge about RT-Kernel’s data, the device itself tells Foxglove what data it will send and in what format. This is powerful because it allows complete flexibility: developers can define custom telemetry messages specific to their application, and as long as they provide the schema and adhere to the agreed format, Foxglove will be able to display the data.

How the Integration Works: Architecture Overview

Let’s dive a bit into the architecture that makes this possible. RT-Kernel’s networking stack includes support for standard internet protocols, and notably it can run a WebSocket server. WebSocket is a modern web technology that enables full-duplex (two-way) communication over a single TCP connection. It’s widely used for real-time web apps and is ideal here because it allows continuous, low-latency data streaming between an embedded device and a PC application. In this integration, the RT-Kernel device acts as the WebSocket server hosting the telemetry stream, and Foxglove Studio acts as the client that connects to it. This might seem reversed at first (we often think of the device as the client), but Foxglove’s design intentionally has the PC initiate the connection to the device. This way, the developer can control when and how to connect, and multiple clients could potentially listen if needed.

When an RT-Kernel device boots up with the Foxglove integration enabled, it will start the WebSocket server on a specified port (for example, port 8765, though the exact number can be configured). The integration software on the device registers various data channels – think of these like topics or feeds – each corresponding to a particular kind of telemetry (e.g. a channel for “lidar_points”, another for “joint_states”, another for “diagnostics”, etc.). For each channel, there is an associated JSON Schema that defines what the messages on that channel look like. All of this information is made available to any WebSocket client that connects.

On the developer’s side, using Foxglove Studio is straightforward. The engineer would open Foxglove Studio (either the desktop app or the web app) on their computer, then choose to “Open Connection” to a custom data source. By entering the address (IP and port) of the RT-Kernel device, Foxglove Studio will initiate a WebSocket connection to the device. Upon connecting, a handshake occurs where the device sends over metadata about the available channels and their schemas. Foxglove then presents these channels in its UI as available data sources. The developer can select which channels to view and choose appropriate Foxglove panels to visualize them – for example, using a 3D point cloud panel for the “lidar_points” channel, or a time-series plot for the “joint_states/angle” field, or an image viewer for the camera channel.

As the robot runs, RT-Kernel continuously sends JSON messages over the WebSocket for each channel at whatever rate the data is produced (respecting real-time constraints and network bandwidth). Because the data is structured and tagged by channel, Foxglove can merge it into its live timeline and display updates instantly. The experience for the engineer is transformative: you can watch a real-time embedded system’s inner workings live, with graphical views, instead of having to rely on scrolling text logs or pausing the system to dump data.

Importantly, the use of Ethernet and WebSocket means the connection is not limited to a direct USB or serial link – you can stream over a local network. This is useful in scenarios like larger robots or machines where the development PC might connect over Wi-Fi or LAN. It’s also possible to connect multiple devices or instances to Foxglove at once (Foxglove can handle multiple data sources), though in practice one would typically connect to one robot at a time per Foxglove instance. The integration ensures that even though RT-Kernel is extremely light and real-time focused, the extra overhead of streaming data doesn’t compromise its determinism. The telemetry is typically sent in a low-priority background task or network thread, so it won’t interfere with critical control loops – but thanks to RT-Kernel’s efficiency, even high-rate data (like a lidar scan at tens of Hz) can be pushed out without issue.

WebSocket protocol allows for full-duplex communication between a client and server. This means that both parties can send data to each other simultaneously, rather than sending data one way at a time using HTTP protocols, as has been done before.
WebSocket protocol allows for full-duplex communication between a client and server. This means that both parties can send data to each other simultaneously, rather than sending data one way at a time using HTTP protocols, as has been done before.

Two-Way Communication: Closing the Loop from Studio to Device

While streaming data out of the embedded system is the headline feature, the Foxglove integration also supports two-way communication. Because WebSocket is bi-directional, Foxglove Studio can not only receive data but also send commands or updates back to the device. The integration takes advantage of this to allow parameter adjustments and control messages to flow from the developer’s UI to the real-time system, all on the fly.

What does this enable? Imagine you’re watching a live plot of a robot’s motor controller gains or a sensor filter parameter. Previously, if you noticed something was off (say the robot arm is oscillating slightly, indicating a tuning issue), you would have to stop the system, change a parameter in code, recompile or reflash, and then test again. With two-way messaging, you can instead adjust those parameters in real time from Foxglove. For example, Foxglove could provide a simple UI slider or input box (via a custom panel or the parameter tuning panel) that is tied to a specific JSON command. If you decide to increase a damping coefficient or tweak a threshold, you move the slider or input the new value, and Foxglove sends a JSON message back down the WebSocket to the RT-Kernel device. The integration on the device receives this message (which would conform to a predefined schema like:

				
					{"param_name": "joint_damping", "value": 5.0}
				
			

and then applies the change to the running system, perhaps by calling an API to update that parameter in memory. The effect is immediate: the next moments of operation use the new parameter, and you can see the results live in Foxglove’s visualization. This tight feedback loop dramatically accelerates tuning and debugging. It’s like having an interactive control panel for your embedded system, one that’s fully integrated with your telemetry viewer.

Two-way communication isn’t limited to tuning gains. It could be used for a variety of control commands: switching the robot’s mode, resetting a sensor, triggering a calibration routine, or injecting test signals, all without needing to physically access the device or restart code. It effectively brings some of the interactivity of high-level robotics frameworks directly into the embedded world of RT-Kernel. And because all of this is done with structured messages and via a network protocol, it can be done remotely as well. An engineer could be at their desk, connected to a robot across the lab (or theoretically across the country, network permitting), observing data and sending adjustments in real time.

It’s worth noting that Foxglove’s architecture originally gained popularity through ROS (which has a concept of dynamic reconfiguration and topic publishing). With this integration, similar capabilities are available to non-ROS, RT-Kernel-based systems. This opens the door for using RT-Kernel in robotics projects without sacrificing the developer experience of runtime introspection and adjustment.

Integration Availability and Setup

The Foxglove integration is available as an optional add-on component for RT-Kernel. It is not included in the standard RT-Kernel package but can be obtained from RT-Labs by teams that want to extend their development workflow with real-time visualization. The component is offered as an upgrade that adds significant value to projects where data insight and interactive debugging are key.

Integrating Foxglove with an RT-Kernel project is straightforward. Developers link the Foxglove module, define which data to publish, and add a task or callback in the firmware that packages and sends telemetry at suitable intervals. The integration uses RT-Kernel’s existing JSON and WebSocket capabilities, so it fits naturally into the existing network stack without extra dependencies. Currently, the RT-Kernel Foxglove integration focuses on JSON as the data encoding for messages. JSON was chosen for its simplicity and the fact that it’s human-readable (great for debugging) and widely supported.

On the desktop side, Foxglove Studio connects directly to the device over Ethernet. Once the connection is established, the available telemetry channels appear automatically in the interface, ready to visualize. No special plugins or configuration are required, the RT-Kernel device speaks the same open WebSocket protocol that Foxglove natively supports.

Real-World Use Cases

The Foxglove integration for RT-Kernel is more than a technical feature, it is a new way to experience what happens inside a real-time system. By making data visual, interactive, and live, it changes how engineers develop, test, and refine complex robotics and automation projects.

To illustrate its impact, let’s look at two examples. The first takes place in a robotics lab, where engineers are fine-tuning a robotic arm for precision motion. The second takes us to the test track, where an autonomous vehicle’s ECU, running RT-Kernel, is streaming real-time telemetry from its control system. Both cases show how live visualization helps engineers understand their systems faster, tune them safely, and build more reliable machines.

Use Case 1: Tuning a Robotic Arm with Live Telemetry

Imagine a robot developer is working on a six-degree-of-freedom robotic arm, powered by RT-Kernel on a high-performance microcontroller. The arm is meant to perform precise movements for an industrial welding task. Achieving smooth and accurate motion requires careful tuning of control parameters (like PID gains for each joint’s motor controller) and verification that the arm’s sensors (encoders, current sensors, IMUs) are all reporting correctly during operation.

Without Foxglove, the developer’s workflow might involve instrumenting the code with serial prints or logging variables to a file, then running the arm through motions and later analyzing that data offline. Perhaps they use an oscilloscope or a custom PC application to observe a few signals in real time, but it’s a limited view. Each tweak to the control algorithm means stopping the system, changing code, and re-running tests which is a fairly slow cycle.

Now enter the RT-Kernel Foxglove integration. The developer enables telemetry on key data: the commanded vs. actual joint angles for each motor, the motor currents, and maybe the output of the PID controllers (the error values). They also set up a channel for important events or diagnostics (e.g., “joint_limits_exceeded” warnings or thermal sensor readings). After flashing the new firmware, they connect Foxglove Studio from their laptop to the arm’s controller over Ethernet. Immediately, they are greeted with multiple live plots updating in sync: each joint’s angle is plotted over time against the commanded trajectory, and you can see on the graph if there’s any lag or overshoot. In another panel, numeric gauges show the current drawn by each motor in real time. A 3D view might even render a model of the arm, moving as the actual arm moves, because the joint state telemetry is driving a visualization – this helps catch any kinematic issues or unexpected motions at a glance.

As the arm runs through its routines, the developer notices joint 3 is consistently overshooting and oscillating slightly when reaching a target angle – a classic sign of an under-damped controller. Instead of halting everything, the engineer opens Foxglove’s parameter panel (mapped to the JSON command channel for tuning). They find the entry for “joint3_damping_factor” (a parameter they set up to be adjustable) and increase it slightly. Within seconds, that new value is sent down to the RT-Kernel system. The effect is reflected immediately: the next move of joint 3 shows a much smoother response on the plot, with the oscillation gone. They effectively just tuned the control loop in real time, with visual confirmation. The entire process took perhaps a minute, whereas doing this blind or in a compile-test cycle could have taken hours of guesswork.

The use case doesn’t stop at tuning. Suppose later, a problem occurs in the field, the robotic arm occasionally stalls and triggers a safety stop. The developers can replay a log of telemetry in Foxglove (since Foxglove can record data streams) or even connect live to a unit on the floor to see what’s happening. They might add extra diagnostic info via the integration, like the state of limit switches or the internal temperature of motor drivers. All that data, visualized together, helps pinpoint the issue (maybe a certain joint is hitting a physical stop or overheating). Foxglove’s ability to present a synchronized timeline of events and values makes troubleshooting significantly more efficient. In this way, the integration not only accelerates development but also aids in maintenance and support of deployed systems.

Use Case 2: Real-Time Insight in an Autonomous Vehicle

Imagine a development team working on a fully autonomous vehicle designed to operate safely in complex urban environments. The car’s Electronic Control Unit, ECU, is built around RT-Kernel, which manages the most safety-critical functions in real time. This includes reading data from multiple sensors, handling time-sensitive control loops for braking and steering, and coordinating with higher-level decision-making systems that run on separate compute units.

The vehicle carries a wide array of sensors: high-resolution lidars, radar units, multiple cameras, and precise GPS and IMU systems. The challenge for the embedded engineers is to ensure that every piece of data is captured, processed, and acted upon within strict timing windows. A delay of even a few milliseconds in sensor fusion or actuator response can affect both performance and safety. Traditionally, diagnosing timing or synchronization issues in such a distributed system would require offline log analysis, and understanding how different sensors and controllers interacted at a given moment could take days.

With the new Foxglove integration, the team gains immediate visual insight into the car’s real-time behavior. As the vehicle drives through a test route, the embedded control unit streams telemetry directly to Foxglove Studio over Ethernet. The engineers watching from the control center can see a live 3D representation of the car’s sensor data, lidar point clouds forming a detailed picture of the surroundings, camera frames updating in sync, and a set of plots showing critical real-time parameters such as wheel speeds, braking torque, and steering angle commands.

At the same time, internal states that were previously invisible are now clearly visible. Timing margins for each task, queue depths, and CPU utilization on the real-time controller are displayed alongside the sensor data. When a latency spike occurs, for example, if a radar frame arrives late or a processing task runs slightly over its deadline, the anomaly appears instantly in the diagnostic panels. Engineers no longer need to dig through timestamped logs after the fact. They can see the issue as it happens, correlate it with sensor data, and pinpoint whether the delay came from the network, the driver interface, or the scheduling of a specific task.

The integration also enables the team to perform safe, remote adjustments during testing. Through Foxglove’s two-way communication, they can fine-tune controller parameters in real time. Suppose the steering control loop feels slightly too aggressive at highway speed. Instead of stopping the test and redeploying new firmware, the control engineer can open Foxglove’s parameter panel, reduce the proportional gain of the steering PID, and apply the change instantly. The next curve in the test track shows a smoother response, confirming that the adjustment worked. The data stream simultaneously verifies that the stability margins remain within safety limits.

Later in testing, the engineers use Foxglove to verify synchronization between multiple sensors and the central perception module. By visualizing the timestamps of lidar scans, radar detections, and camera frames together with vehicle motion data, they confirm that all inputs align correctly in time. This ability to observe live timing correlations across multiple real-time domains dramatically simplifies validation of complex sensor fusion systems.

In this setting, the Foxglove integration transforms how an autonomous vehicle development team interacts with its embedded real-time platform. What was once a black box running deterministic code now becomes an observable, interactive system. Engineers can visualize, diagnose, and adjust in real time, shortening feedback cycles from days to minutes. The result is faster development, improved safety margins, and a higher degree of trust in the behavior of the autonomous system under test.

Conclusion: Power and Insight in Real Time

The new Foxglove integration for RT-Kernel is more than just an add-on, it bridges two worlds. By combining real-time performance with powerful visualization, it brings modern development workflows into embedded robotics. Engineers can instrument their systems with telemetry from the start and use Foxglove’s dashboards to see exactly what’s happening inside the robot. This boosts development speed, improves debugging, and reduces risk by catching issues early. For embedded and robotics teams, it means faster iterations, deeper insight, and more reliable systems.

Get started with foxglove – contact RT-Labs today