Jupyter Blog - robotics

A Robotics Workbench for JupyterCAD

2026-09-02T18:22:00+00:00

Robotics education often hits a wall before the fun even begins. Students and engineers must first navigate a labyrinth of installations: ROS, environment configurations, dependency management, and a patchwork of software, just to visualize a simple robot. It doesn’t have to be this way.

Thanks to Jupyter and its extensions, the entire process, from designing a robot to simulating its kinematics, can now happen entirely in the browser, in a single workspace with zero local installation.

The Problem: The Fragmented Robotics Pipeline

Traditionally, creating a robot model involves dealing with three distinct, often incompatible worlds:

Parametric Design: Creating the shapes in dedicated CAD software (FreeCAD, SolidWorks, and the like).
Mesh Generation: Exporting those solid bodies into triangular meshes (STL) while manually managing the coordinates and file paths.
Kinematic Description: Writing URDF (Unified Robot Description Format) XML that ties the meshes together using joints and other parameters.

Getting this pipeline working locally typically requires a complete ROS installation, a source of friction for students and educators.

The Solution: A Unified Browser Workflow

By leveraging the JupyterCAD and JupyterLite, this entire toolchain is delivered as an instant, zero-install workspace in the browser. It is made available on the notebook.link service.

1. JupyterCAD: The Design Hub

JupyterCAD is a JupyterLab extension for collaborative 3D modeling. It also supports FreeCAD files and offers a full set of tools for creating, transforming, and combining 3D shapes.

It can also export to various formats:

STL/BREP: Users can simply right-click any shape and generate meshes directly in their browser.

FreeCAD: Through the JupyterCAD-FreeCAD plugin, designs can move freely between the browser and desktop CAD (FreeCAD) without losing the feature tree, exporting back and forth between the .jcad and .FCStd formats.

2. JupyterCAD-URDF: The URDF Workbench for JupyterCAD

JupyterCAD-URDF is a JupyterCAD plugin for exporting CAD designs to the URDF format.

It generates STL meshes automatically for complex shapes. For simple primitives (boxes, spheres, and cylinders), it emits XML tags instead of producing external mesh files.
It produces a URDF XML document that references those meshes while preserving hierarchies, names, colors and placements.

3. JupyterLab-URDF: Interactive Kinematics

Once the model is exported, the JupyterLab-URDF extension, which can be used in JupyterLab independently of JupyterCAD, allows for inspection of the XML content as well as interactive 3D visualization:

Real-Time Kinematic Articulation: Drag joint sliders to test degrees of freedom, joint limits, and coordinate hierarchies in real time.
3D Scene Controls: The control panel has several settings to customize the scene, such as coordinate frame helpers, lighting controls, mesh visibility, and other options.
Joints Editor: An interface to define kinematic relationships (joints) between parts by selecting them directly in the 3D scene. This allows for creating new joints or editing existing ones.

Walkthrough: Zero-to-Robot Workflow

This new pipeline allows a student to go from a blank page to a moving robot:

Phase 1: CAD Modeling & Export (JupyterCAD + JupyterCAD-URDF)

Design parametric parts in JupyterCAD.
Export to URDF using JupyterCAD-URDF.

Phase 2: Assembly & Simulation (jupyterlab-urdf)

Assemble the generated URDF in jupyterlab-urdf and use the Joints Editor to connect links.
Simulate the robot movement using the joint sliders.

You can try it right now without any local installation thanks to the deployment on notebook.link, by following the link below.

Repos

All tools in this pipeline are free, open source, and available on GitHub, PyPI, npm, and Conda-forge:

Acknowledgements

This work was conducted at QuantStack as part of an effort to make 3D modeling and robotics accessible directly in web-native environments.

Special thanks go to everyone in the open-source community who made this possible, to Isabel Paredes, the creator and maintainer of the jupyterlab-urdf extension, to Le Duc Trung and Martin Renou, the main contributors to JupyterCAD, and to everyone else at QuantStack who helped with this project.

About the Author

Yahia Heni is a software engineer at QuantStack, focusing on the Jupyter Ecosystem, by contributing to Jupyter and several of its extensions, as well as notebook.link and other related open-source projects.

JupyterLab, the Cloud Robotics Command Station

2020-08-11T13:19:00+00:00

JupyterLab-ROS with Voilà to quickly make a standalone web app

The ROS open-source project (Robot Operating System) has become a de-facto industry standard in the robotics community. Very much like with Project Jupyter, a large collection of software has been built upon well-specified communication protocols. ROS has become a rich ecosystem of standardized tools for building and distributing ROS-based software, exploratory robotics development, and much more.

With Industry 4.0, the number of robots and smart devices has been increasing exponentially. We are talking about fully automated factories with hundreds of robots and thousands of connected sensors, generating large amounts of raw data.

There is an opportunity in bridging the ROS and the open-source data science ecosystems and tools.

For this reason, we set ourselves to bring together these ecosystems,

by producing a collection of JupyterLab extensions for ROS, turning JupyterLab into a cloud robotics command station,
by integrating ROS packages with conda / mamba package management system, to enable their installation alongside other open-source data-science packages.

JupyterLab, the cloud robotics command station

While the traditional developer tools from the ROS stack such as RViz are desktop-based, we think that a robotics development environment running in a web browser would provide a lot of flexibility. Also, the ideal robotics developer platform should be plugin-based, and easily extensible to account for the diversity of use cases to enable, from simple interactive scripting to visualization or large datasets. Finally, we should build this environment upon broadly adopted foundations, with open governance, and not let a single entity hold the keys to the ROS ecosystem.

Jupyter is a natural candidate to serve as the foundation for a web-based robotics development environment.

JupyterLab is a web-based interactive development environment that has many of the much-needed features

In JupyterLab, everything is a plugin, including the core components to the application. Anyone can produce a “remix” of core and third-party JupyterLab extensions to their needs.
Very much in the spirit of ROS, one of the keys to Jupyter’s success is that the project was built upon well-documented and specified protocols and file formats that anyone could implement.
Jupyter is a multi-stakeholder project, not backed by a single corporation, but by a community of developers at a variety of companies, universities, as well as individual contributors.

Today, we are announcing the first beta of JupyterLab-ROS, a collection of JupyterLab plugins to integrate ROS with the JupyterLab platform. We combine the best of the data-science and robotics worlds to help developers build custom solutions for the industry. ROS can run in a high-performance server while JupyterLab is accessed in a web-browser (on Windows, OS X or Linux).

JupyterLab-ROS

JupyterLab-ROS automatically starts a rosmaster and rosbridge_server making all the painful setup of WebSockets connections completely transparent to users. A status bar widget allows you to start and stop the rosmaster server with a simple click and displays its state in real-time. Internally this widget runs a launch file which can be changed from the JupyterLab settings UI to launch additional nodes.

Master status widget

Another important component of the ROS stack is RViz, a desktop-based 3-D visualization tool. It’s web-based counterpart in JupyterLab is Zethus, started by Rapyuta Robotics. This plugin supports most of the display types supported by RViz. It also provides an info panel that displays the raw messages in realtime, and a web-based version of rqt_graph for visualizing the ROS node graph.

Zethus

A robotics station would be incomplete without a tool for debugging. For that purpose, ROS provides rosconsole, a package which allows developers to send messages to rosout and make them available on every node. The console gives access to these debugging messages in JupyterLab and provides additional features such as filtering by level and by node.

Log Console

Robotics Notebooks

A key component to the Jupyter stack is the Notebook, an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text. It’s frequently used to do data cleaning and transformation, numerical simulation, statistical modelling, data visualization, machine learning etc.

The notebook could be the perfect tool for robotics researchers and educators to make (and share) experiments in control algorithms, working in a dynamic and interactive development environment that allows quick prototyping and exploratory analysis while having access to the sophisticated mathematical libraries already well integrated with Jupyter. It can be tedious to have a different platform for interacting with robots and processing the data obtained from these, JupyterLab-ROS combines both toolsets and enables an integrated workflow.

At the same time, many projects are becoming more and more interdisciplinary. Currently, it is common to see projects mixing topics like machine learning and robotics. JupyterLab-ROS opens a new world of possibilities for machine learning researchers that are interested in applying their models to robots: now they have the possibility of connecting a robot to a development environment that they are very familiar with.

JupyROS is another powerful library that leverages ipywidgets and bqplot to integrate ROS in Jupyter Notebooks, being able to show real time plots from ROS messages and create intuitive forms to control robots in minutes.

Interactive Robotics in the Jupyter Notebook, with live plotting

ROS Package management

Modern scientific computing applications typically depend on a large number of libraries. Conda-forge is a community initiative to package scientific libraries for the conda package manager, and has become a de-facto standard source of packages for the scientific computing community, with tens of thousands of available packages, and thousands of contributors.

During the last year, we have worked hard to package more and more of ROS as conda packages. Conda-packages for ROS Melodic, including RViz are now available on all three operating systems! You can find the packages on the RoboStack channel (a more detailed blog post about this is going to follow soon).

Conda can be used to create virtual environments for ROS projects, which makes it possible to install Melodic, Kinect and Dashing side-by-side on the same Linux system, and have exact control over package versions.

We are also working on Mamba, a conda-compatible package manager implemented in C++. Together with Boa this effort will help to continuously build and release ROS packages on conda.

Try it online!

You can try the JupyterLab-ROS extension online without installing anything by just clicking on the following binder link:

JupyterLab-ROS is under active development. We are working on new features such as a rosbag widget to play and record bag files and improving existing ones like the roslaunch widget. If you are interested in contributing to JupyterLab-ROS you can find the code at this repository in the RoboStack organization. Contributions are always welcome!

Installation

You can install JupyterLab-ROS using Mamba, the first step to create a new environment with JupyterLab and the ROS packages necessary, then you can install the extension.

mamba create -n test -c conda-forge -c robostack python=3.6 nodejs=12 jupyterlab ros-melodic-ros-core ros-melodic-rosauth ros-melodic-rospy ros-melodic-rosbridge-suite ros-melodic-rosbag ros-melodic-tf2-web-republisher

conda activate test

pip install jupyter-ros-server

If you have any questions don’t hesitate to contact us on the RoboStack or QuantStack chats.

This work has many collaborators around the world, and we are especially grateful to Deep Chaitanya & Ashish Chaudhary from Rapyuta Robotics, Sean Yen from Microsoft for his amazing work on vinca that automagically generates the conda-recipes, Tobias Fischer for many patches and pushing us to bring OS X support to the conda packages as well. Many thanks to Jeremy Tuloup for his help with the JupyterLab extension system.

About the authors

Wolf Vollprecht works as a scientific and robotics software developer for QuantStack in Paris and Berlin.

Carlos Herrero is a Computer Engineer passionate about AI and his applications on robotics. Currently working at QuantStack helping to develop Open Source projects.

ROS @ Jupyter

2019-04-07T21:15:00+00:00

This may be the right time for Jupyter-based developer tools, as cloud robotics is taking off. A PR2 robot in the browser, and making him dance through the traditional Qt interface

Historically, the ROS (Robot Operating System) community has relied on Qt for building complex user interfaces. Nowadays, the Jupyter notebook and the ipywidgets framework offer a compelling alternative for several reasons:

Code and interface are not separated — both are in the same notebook.
Complex widgets using browser technology are possible: from JavaScript sliders to 3D with WebGL, real time video streaming with WebRTC…
Works with any web browser — not bound to Linux, and no Qt applications need to be compiled.
Doesn’t need to run locally! Applications can run on a server far away, without any manual setup or installation procedure.

However, ROS does not play nicely with Jupyter. For example, rospy is inherently multi-threaded (every new ROS topic subscriber spawns a new thread). Debug printouts in callbacks result in Jupyter printing that content into the output area of the active notebook cell, quickly flooding the user interface — and there is no easy way to stop logging threads once started.

ipywidgets to the rescue: jupyter-ros

That is why jupyter-ros was created. It is a suite of plugins to the Jupyter ecosystem to make working with ROS inside Jupyter a breeze.

Subscribing with jupyter-ros produces an interactive widget

First, when you subscribe using jupyter-ros, the function returns an ipywidget with a start/stop button and a dedicated output area for debug prints. Internally this re-routes all print outs from your subscriber thread to this Jupyter cell, and gives full control over the thread (by being able to stop and restart it at any time).

The jupyros publishing sugar

If you call the publish function in jupyter-ros, a widget is automatically generated from the message specification. For example, a ROS message String field automatically becomes a text input widget, a Float32 becomes a FloatSlider…

Live plotting IMU data from a BBC micro:bit

Another interesting functionality is the live plotting, similar to rqt_plot. For this we use bqplot, a “jupyter-native” solution to plotting. With jupyter-ros, you can select a couple of fields from your message, and they will be automatically plotted to a bqplot.

Going 3-D

Most robots are three dimensional, and so should be the visualizations! The go-to tool in the ROS ecosystem at the moment is RViz, a very powerful 3-D visualization tool.

Some of RViz’s functionality has already been ported over to the web browser as part of the RobotWebTools effort. We’ve been able to piggy-back on their impressive work, and we’re releasing the first iteration of ROS3D Jupyter widgets. Currently, they allow you to programatically plug together RViz like visualizations for different data types, such as laser scans, robot trajectories, and 3D (URDF) models of the robot!

Thanks to the ipywidgetification, you can now bring complex visualizations to the web, without writing any JavaScript, and arrange those visualizations freely in JupyterLab.

Interactive widgets showing ROS data inside JupyterLab

Jupyter, Widgets, and Cloud Robotics

We hope that Jupyter, and the jupyter-ros widgets will play a big role in cloud robotics. In cloud robotics, some of the software powering one or multiple robots runs on powerful computers in data centers. For monitoring purposes, or development, Jupyter and JupyterLab are perfect candidates. Robot customers will be able to login to a single user-friendly interface, without having to install any custom software on their machine, or run a specialized operating system (ROS usually runs on Ubuntu). Exciting possibilities arise: it is already possible to run a Docker container running JupyterLab and jupyter-ros on the leading cloud robotics platforms, Rapyuta Robotics and their freshly launched platform rapyuta.io.

Installation & source

The jupyter-ros widgets can be installed from PyPI using

$ pip install jupyros
$ jupyter nbextension enable --py --sys-prefix jupyros

The examples and the source code can be found on github: https://github.com/robostack/jupyter-ros

This work is still early stages and you might find some rough edges. We look forward to collaborating with the community to polish these widgets to the highest standards!

About QuantStack

QuantStack is located in the center of Europe (Paris). We are core Jupyter developers, and love ROS, and the cloud. If you are interested in working with us on professional user interfaces for developers or clients in the cloud, do not hesitate to send us an email: wolf.vollprecht@quantstack.net