# PlotJuggler 4: a time-series workbench for robot and sensor logs

> PlotJuggler 4 turns recorded and live sensor data into interactive time-series, XY, 2D and 3D views, with a plugin SDK for formats it does not ship. The install story is short; the interesting part is what the data model and the plugin boundary let you do, and where they stop.

**PlotJuggler/PlotJuggler** — The Time Series Visualization Tool that you deserve.

- Repository: https://github.com/PlotJuggler/PlotJuggler
- Website: https://www.plotjuggler.io
- Stars: 6,218 · Forks: 825
- Language: C++
- License: MPL-2.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/plotjuggler-plotjuggler

## What PlotJuggler 4 is for, and who ends up using it

The README frames PlotJuggler 4 as an "extensible, performant and open-source multi-modal visualization platform" and lists the workflow it targets: explore recorded or live data, compare test runs, and analyze and transform data in a single application. That is a narrower claim than "plotting library". The unit of work is an investigation, not a chart. You drag signals into time-series and XY plots, zoom into events, inspect individual samples, load several recordings, align their timelines and overlay signals to compare behavior.

The people this fits are the ones who already have logs and no good way to look at them together. Robotics and autonomy teams appear throughout the topic list (ros, rosbag, px4, ulog) and the README's supported formats confirm that bias. But the format table also includes CSV, Parquet, MCAP and LeRobot, plus live streams over MQTT, ZeroMQ, UDP, WebSocket bridges and Lab Streaming Layer. Anyone comparing runs of a sensor rig, a drone flight or a robot arm falls inside the target. Anyone who needs a chart embedded in a web page or generated inside a CI job does not.

The multimodal part is the differentiator worth naming. Images and video, pointclouds, meshes and URDF models, occupancy grids and elevation maps can share a workspace with the plots, synchronized in time. The screenshot caption in the README describes exactly that: a robot model, camera feeds, depth images and joint torque plots in one PJ4 workspace.

## The mechanism: a datastore, a plugin host, and scenes on one timeline

The repository layout is the clearest statement of the architecture. Top-level directories include pj_app, pj_datastore, pj_dialog_host, pj_marketplace, pj_plotting, pj_runtime, pj_scene2D, pj_scene3D, pj_scene_common, pj_scripting and pj_widgets. Read as a decomposition, that is an application shell, a data layer, a plugin host, a marketplace, a plotting module, a runtime, three scene modules, a scripting module and shared widgets. The 3rdparty directory holds vendored dependencies and conanfile.txt plus conan.lock pin the C++ dependency set; pixi.toml and versions.env handle the environment side.

The data flow implied by that split is: a loader or streamer plugin produces series into the datastore, the runtime drives them, and the plotting and scene modules render views that share a time axis. The README supports the rendering half of that with a concrete claim: "Efficient data storage, GPU-accelerated rendering and on-demand media decoding help keep large recordings responsive as you explore." Note the hedge. No numbers accompany it, so treat it as a design intention rather than a measured result.

Two mechanisms deserve attention because they change how you work. First, plugins are installed at runtime through File -> Marketplace rather than compiled in, so the set of supported formats is not fixed at build time. The README points to the plugin SDK and to the official plugins repository for custom loaders, streamers, parsers and toolboxes. Second, derived series are scriptable. The README says you can "Create derived series with custom transforms in Lua and Python, alongside the built-in filters", and the built-in set is named as filtering noise, measuring rates of change, integrating values and inspecting frequency content with Fast Fourier Transforms. The pj_scripting directory is where that lives.

## Installing PlotJuggler 4 and loading your first recording

The README does not ask you to build anything to try the application. It says to download PlotJuggler 4 for Linux (AppImage or Debian package) or Windows (installer), linking the releases page. The latest release listed in the repository is 4.0.0, dated 2026-09-21, so that is the artifact to look for.

On Linux the README names the AppImage, which needs no installation. The repository also ships build.sh and run.sh at the top level, alongside build.bat, run.bat and test.bat for Windows and test.sh for the test suite. Those are the development entry points the README points at when it says to see docs/BUILDING.md for compilation and development setup.

On Windows, download the installer from the same release and run it. Either way you should land in the empty PJ4 workspace shown in the README, with the menu bar containing the File menu the README refers to.

For a first real use, take a CSV you already have. Drag it onto the window, or open it from File. PlotJuggler reads CSV directly according to the supported formats table, so no plugin install is needed. Once the series appear in the list, drag one into a time-series plot and zoom into an event. That drag-and-drop step is the entire interaction model, and it is the same gesture for XY plots.

If your data is not CSV, install the loader first. The README puts ready-to-use loaders, streamers and tools behind File -> Marketplace, and lists MCAP, Parquet, PX4 ULog, LeRobot, MP4, PCD and PLY alongside CSV in the file formats table. For live data, the same marketplace carries the streamers, with ROS 2, MQTT, ZeroMQ, UDP, WebSocket bridges, WebRTC and Lab Streaming Layer named as sources. The README does not document which of those ship inside the default download and which require a marketplace install, so check the marketplace list before assuming a format is available.

When the view is arranged the way you want it, the README says you can arrange plots in tabs and dockable panels and then "save your layout and transforms for the next investigation". That save step is what turns a one-off look into a repeatable check.

## Where PlotJuggler 4 is the wrong tool

The README describes a desktop application. Every workflow it names assumes a person in front of a window: dragging signals, zooming into events, inspecting samples, arranging panels. There is no command-line interface, no headless batch mode and no library API mentioned anywhere in the README. If you need a plot generated inside a build step, or a service that renders charts on request, PlotJuggler is not that, and the plugin SDK does not change it. The SDK's stated purpose is building "a loader, streamer, parser or toolbox", which are extensions to the application, not an embedding surface.

The second boundary is format coverage. The supported list is broad but finite, and the README is explicit that some of it arrives through the marketplace rather than the base install. A format that is not in the table and has no plugin is a format you would have to write a loader for, in C++, against the SDK. That is a real project, not an afternoon.

The third is the scripting layer. Lua and Python transforms are named, but the README does not enumerate the functions available in either, nor does it describe the performance characteristics of a scripted transform over a large recording. If your derived series is expensive and runs on every load, you are trusting the datastore and the scripting bridge without a documented guarantee. The same caution applies to the rendering claim: "GPU-accelerated rendering" tells you the intent, not the threshold at which a recording stops being responsive.

Finally, consider what you are taking on operationally. The application ships for Linux and Windows only, per the README. The related searches show people looking for a Mac build and a browser-based version; the README does not describe either, so neither should be assumed.

## How it differs from Foxglove Studio and from scripted plotting

The closest comparison a robotics engineer will make is Foxglove Studio, which also targets robot logs with panels for plots and camera feeds. The difference visible in the README is the extension model. PlotJuggler's format support is not baked into the binary: loaders, streamers, parsers and toolboxes are installed through File -> Marketplace and built against a published plugin SDK with an official plugins repository alongside it. That makes the set of supported formats something you can add to without forking the application. It also means the base download and the marketplace inventory are two different things, and the README does not draw the line between them.

The other axis is analysis depth in the application itself. The README names filters, rates of change, integration and Fast Fourier Transforms as built-ins, and Lua and Python transforms as the extension path for derived series. A workflow built on pandas and matplotlib can do all of that and more, but it does so by writing code for every question, and it cannot show you a pointcloud, a URDF model and a torque curve on one timeline. The trade is explicit: PlotJuggler gives you the synchronized multimodal view and a scripting layer, and gives up the programmatic composability of a general-purpose data stack.

A third option is the vendor tool that came with your hardware. Those tend to be narrower by design. PlotJuggler's advantage is that PX4 ULog, ROS 1/2, MCAP and CSV all sit behind the same interface, so a comparison across two ecosystems does not require two applications.

## Maintenance, licensing and what an upgrade costs you

The repository is not archived, and the last push was on 2026-09-22. Release 4.0.0 landed on 2026-09-21, following three betas: 3.999.9 (PlotJuggler 4: beta 3) on 2026-08-10 and 3.999.3 (PlotJuggler 4: beta2) on 2026-07-20. The version numbering is worth reading carefully. The betas used 3.999.x and the final used 4.0.0, so anything you built against a beta is on a version line that no longer exists. If you have scripts or saved layouts from a beta, treat the move to 4.0.0 as a migration and re-run them rather than assuming they load unchanged. The README does not document a rollback path between major versions.

On licensing, the project is released under the Mozilla Public License 2.0, and the README adds that "Third-party dependencies retain their own licenses." MPL-2.0 is file-level copyleft: modifications to covered files carry obligations, but the licence does not reach across into separate files the way a stronger copyleft would. The practical consequence for a plugin author is that the licence question is not only about PlotJuggler. The dependency tree is pinned by conanfile.txt and conan.lock, and the 3rdparty directory is vendored, so the full set of licences you are actually shipping is larger than the LICENSE file in the repository root. That is a question for your own legal review, not something this article can settle.

Upgrade cost splits by how you use the application. If you only load files and arrange plots, an upgrade is a new artifact and, at most, a re-check of your saved layouts. If you maintain a plugin against the SDK, an upgrade is a rebuild against the new SDK and a re-test of your loader or streamer, and the SDK lives in a separate repository, so its release cadence is not tied to the application's.

## Conclusion

Adopt PlotJuggler 4 if your work is inspecting recorded or live sensor and robot data and you want one application that holds time-series, XY, 2D and 3D views over the same timeline. Do not adopt it as a headless pipeline component or as a plotting library for a service you intend to ship; the README describes a desktop application, and the plugin SDK is the extension path for custom formats, not a server API. Before committing, verify that the format you actually record is listed under File -> Marketplace, confirm your platform has an artifact on the releases page (Linux AppImage or Debian package, Windows installer), and check that a Lua or Python transform can express the derived series you need, since the README names both languages but does not enumerate the available functions.

## FAQ

### What is PlotJuggler?

It is an open-source desktop application for exploring recorded and live data, comparing test runs, and analyzing and transforming that data in one place. The README describes it as an extensible, multi-modal visualization platform, with time-series and XY plots alongside images, video, pointclouds and 3D scenes.

### How to install PlotJuggler?

Download PlotJuggler 4 from the releases page. The README lists a Linux AppImage or Debian package and a Windows installer. Building from source is covered in docs/BUILDING.md and is not required to use the application.

### How to install PlotJuggler on Windows?

The README points to the releases page and names a Windows installer as one of the available artifacts. Download and run it; no separate dependency installation is described.

### How to use PlotJuggler with ROS 2?

ROS 2 is listed among the live stream sources, and ROS 1/2 among the message encodings. The README directs you to File -> Marketplace to install ready-to-use loaders and streamers, so the ROS 2 streamer is the component to look for there.

### How to use PlotJuggler?

Drag a supported file onto the window or open it from the File menu, then drag signals from the list into a time-series or XY plot and zoom into events. Layouts and transforms can be saved so the same arrangement is available for the next investigation.

## Sources

- [License: MPL-2.0](https://github.com/PlotJuggler/PlotJuggler/blob/main-4.x/LICENSE)
- [PlotJuggler/PlotJuggler on GitHub](https://github.com/PlotJuggler/PlotJuggler)
- [Project website](https://www.plotjuggler.io)
- [README](https://github.com/PlotJuggler/PlotJuggler/blob/main-4.x/README.md)
- [Releases](https://github.com/PlotJuggler/PlotJuggler/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/plotjuggler-plotjuggler