Jupyter Blog - JupyterCAD

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.

Announcing JupyterCAD 3.0

2025-02-17T09:38:00+00:00

We are thrilled to introduce JupyterCAD 3.0, the newest version of the collaborative CAD modeler designed for JupyterLab.

JupyterCAD is an unofficial JupyterLab extension for 3D geometry modeling with collaborative editing support. It is designed to allow multiple people to work on the same file at the same time, and to facilitate discussion and collaboration around the 3D shapes being created.

JupyterCAD 3.0 represents a significant leap forward in usability and user experience compared to the previous release.

What’s new in JupyterCAD 3.0?

Color customization

JupyterCAD 3.0 allows you to customize object colors directly within the application, while we were limited to gray models in earlier versions. Adjust colors easily to suit your design needs or preferences.

Embedded Python console

The new embedded Python console offers advanced users direct access to JupyterCAD’s Python API, enabling on-the-fly scripting and automation for power users.

UX improvements

The new AxesHelper provides a clear visual reference for coordinate axes, making it easier to navigate and align models in 3D space.

We have also added copy-paste functionality using Ctrl+C and Ctrl+V shortcuts, making it faster and easier to duplicate objects within your models.

An improved toolbar now includes options to toggle wireframe, toggle transform controls, toggle clip plane and a toggleable console, giving users quick access to essential tools.

JupyterCAD 3.0 also introduces smooth camera tracking, where selecting an object from the object tree triggers a smooth transition of the camera to focus on the selected object, enhancing navigation and model exploration.

Mouse-based 3D controls

Move or rotate your 3D models effortlessly with mouse-based controls that bring fluidity and precision to model editing and interaction.

Suggestions support

With JupyterCAD 3.0, collaboration becomes even more seamless with suggestions. Collaborators can propose changes to a model, which can be reviewed and applied collaboratively, fostering a dynamic and efficient workflow.

Try it!

Screenshot of JupyterCAD GitHub repository, with a link to try JupyterCAD (circled in red) with JupyterLite. This is simply deployed as a static website on “GitHub Pages”.

Explore JupyterCAD 3.0 in action with our JupyterLite deployment — no installation required. Visit us at jupytercad.github.io/JupyterCAD and start modeling directly in your browser.

Installing JupyterCAD

You can easily install JupyterCAD with pip or mamba:

pip install jupytercad

or:

mamba install -c conda-forge jupytercad

Additionally, you can install FreeCAD along with the JupyterCAD-FreeCAD plugin to enable support for FCstd files:

mamba install -c conda-forge freecad jupytercad-freecad

What’s next?

JupyterCAD is evolving rapidly, with some exciting updates just around the corner and others in active development:

Upcoming Features

Enhanced User Experience:
- Smoother exploded view
- Support for renaming objects directly from object tree
- Incremental rotation controls for precise adjustments
- Enhanced 3D view settings for better customization.
Nested & Refined Side Panel: Navigate and organize objects more easily with a refined and nested side panel experience.
Support for more File Formats: Broaden compatibility with support for more file formats.

Features in Development

New CAD Operations: New tools for operations like linear and radial patterns to expand modeling capabilities.
Support for measuring distances: Tools to measure distances and dimensions directly in the viewport.
Improved 2D Sketcher: Enhanced features to make 2D sketching more intuitive and robust.

Acknowledgements

The development of the JupyterCAD open-source project by QuantStack was funded by a grant from DGAC in the framework of the French “Plan de Relance” (refinanced by Next generation EU) as part of a collaboration between Safran Aircraft Engines, INRIA, and Akkodis.

We also extend our gratitude to the external contributors whose efforts and feedback have been instrumental in shaping this release. Your support and collaboration drive the ongoing success of JupyterCAD.

This work was built upon the strong foundation laid by open-source software projects such as Three.js, OpenCascade, OpenCascade.js, FreeCAD, JupyterLab and JupyterLite.

About the authors

JupyterCAD is an open-source project resulting from contributors’ collective efforts. Below, we highlight the primary contributors for this release:

Le Duc Trung is a Scientific Software Developer at QuantStack. He works on several projects within the Jupyter ecosystem, from the main projects like JupyterLab, Voilà, and ipywidgets to various JupyterLab extensions and widgets.

Martin Renou is a Technical Director at QuantStack and a maintainer of Project Jupyter. Among other projects Martin is a core team member of the ipywidgets project and maintains many Jupyter widget packages such as ipyleaflet, ipydatagrid, ipygany, ipycanvas, and bqplot. He is a co-creator of the Voilà dashboarding system, and the xeus-python kernel.

Arjun Verma is a Scientific Software Development Intern at QuantStack. He is also a final year undergraduate student at Cluster Innovation Centre, University of Delhi. He loves 3D & GIS and also contributes to JupyterGIS and is one of the maintainers of PyBaMM where he has also been GSoC contributor and mentor.

Exploring a Document’s Timeline in JupyterLab

2024-09-13T19:15:00+00:00

In collaborative environments, keeping track of changes and understanding the evolution of a document is crucial. This is especially true in fields like scientific computing and data science, where multiple contributors work together on complex projects. To address this need, we’re excited to introduce a document timeline component, a new feature that ships with the Jupyter Collaboration extension and enhances how teams interact with shared documents.

The timeline component is designed to give users control over a document’s history. Positioned as a slider in the JupyterLab status bar, it allows users to navigate through the timeline of a document. You can explore past versions, compare changes over time without altering the original document, and even restore specific versions. This feature is compatible with all types of shared documents within Jupyter, including notebooks, text files, and even third-party document types like JupyterCAD models.

Exploring the history of a Jupyter Notebook with the timeline component

How Does it Work ?

Co-editing of notebooks and other documents was introduced in JupyterLab 3.1 and has been improved and consolidated in subsequent releases. The feature can be enabled by installing the Jupyter Collaboration extension, which is built upon the Yjs framework, an implementation of CRDTs (Conflict-free Replicated Data Types). An important byproduct enabling real-time collaboration was the introduction of a journal of updates capturing all changes made by collaborators, which we leveraged to implement document timeline navigation.

Two key changes to Jupyter collaboration underlie the timeline component:

The ability to fork the document history, which is required to visualize the past state of the document without altering it.
The support of Undo/Redo operations in the Python implementation of Yjs, PyCRDT, through the implementation of an undo manager. While this was already available in Yjs, it was missing in PyCRDT until now.

As you move the slider to go back in time, the first operation that takes place is forking the document. Forking creates a new branch of the document at the selected point in history. This approach ensures that the most recent version of the document remains unaltered while you explore earlier versions. The forked version essentially acts as a sandbox where you can navigate through the document’s history, test out changes, and decide on the best course of action without modifying the main document.

When you navigate through the document’s timeline using the slider, the undo manager allows you to reverse or reapply any series of changes, stepping back through the document’s history without losing any information. If you decide to move forward again, the undo manager reapplies those changes in the exact order they were originally made, preserving the document’s integrity.

After reviewing the timeline, you can choose to restore a particular version at a selected timestamp. This restored version becomes the new active state of the document, effectively merging the changes from the forked branch back into the main document.

The document timeline component in the status bar offers an intuitive, flexible way to manage document history. Users can confidently experiment with different versions of their work, knowing that every action is reversible and that no progress will be lost. Whether you’re refining a piece of code, iterating on a design, or reviewing past contributions, the timeline equips you to iterate efficiently and effectively.

Seamless Integration with JupyterCAD

The document timeline is not just limited to text-based documents or notebooks. It was designed in a document-agnostic way, allowing its usage for any collaborative document. Consequently, it integrates seamlessly with JupyterCAD, JupyterLab’s extension for creating and manipulating 3D models. For engineers and designers, this integration is a game-changer.

In complex engineering projects, design iterations are common, and the ability to track the evolution of a 3D model is crucial. With the document timeline, users can effortlessly navigate through different stages of their design process. If a recent change in the 3D model doesn’t yield the desired results, the document timeline allows you to slide back to a previous version and pick up your work from there.

By combining the power of JupyterCAD with the document timeline’s history management, a team can achieve a more dynamic and flexible design process, ensuring that every idea is captured and every change is reversible. This integration exemplifies how the Jupyter Collaboration extension is enhancing not just collaborative editing but also specialized workflows in engineering and design.

Exploring the history of a JupyterCAD document with the timeline component

A New Era of Collaboration in Jupyter

The document timeline is a significant step forward in our ongoing work to make Jupyter a user-friendly platform for collaborative technical computing. By leveraging the advanced capabilities of the PyCRDT undo manager, we’ve created a tool that simplifies document history management and enhances the overall collaborative experience.

As we continue to innovate and expand the Jupyter Collaboration extension, we invite the community to try out the new document timeline feature and share their feedback. Together, we can further refine these tools and ensure that Jupyter remains at the forefront of collaborative computing, empowering users across all disciplines to achieve more.

Acknowledgments

The development of the document timeline and its integration into the Jupyter Collaboration extension has been a true team effort, made possible by the dedication and expertise of many individuals. Special thanks are extended to the following team members for their invaluable contributions:

David Brochart : For their innovative approach to integrating the undo manager within PyCRDT.
Afshin T. Darian : For their supervision and feedback, which have been crucial in refining the functionality of the timeline component.
Duc Trung Le : For their expertise in JupyterCAD and for ensuring that the timeline component seamlessly integrates with 3D model workflows.

About the Author

Meriem Ben Ismail just completed her Software Engineering degree at INSAT (National Institute of Applied Sciences and Technology in Tunisia) and her six-month internship as an open-source scientific software engineer at QuantStack.

Collaborative CAD in JupyterLab

2023-06-02T15:15:00+00:00

We are thrilled to introduce JupyterCAD, a tool that integrates Computer-Aided Design (CAD) capabilities into JupyterLab. With its JupyterLab extension, dedicated JupyterCAD application, and Python API for CAD operations, JupyterCAD allows users to effortlessly create, edit and share 3D designs without leaving the Jupyter ecosystem.

This blog post provides an overview of JupyterCAD’s features and highlights its collaborative editing capabilities which enable teamwork in the realm of CAD.

Everything that is shown below can be tested by installing JupyterCAD from PyPI:

# From PyPI
pip install jupytercad

One extension, three interfaces

Built using the latest JupyterLab 4 release, JupyterCAD combines CAD functionalities with the enhanced performance and accessibility improvements introduced in JupyterLab 4. The flexibility of JupyterLab allows us to create the extension once but deploy it in multiple ways to target three groups of audiences: users who prefer working in the JupyterLab environment, users who favor dedicated applications, and those advanced users who do everything programmatically.

JupyterLab Extension

Experience CAD features directly within JupyterLab with the JupyterCAD extension. Open and edit FreeCAD files, perform CAD operations, including creating 3D primitives, applying boolean operators, and exploding the view. JupyterCAD’s extension integrates seamlessly into JupyterLab, providing an intuitive environment for CAD enthusiasts and data scientists alike.

JupyterCAD extension inside JupyterLab

JupyterCAD Application

For a streamlined CAD experience, JupyterCAD offers a dedicated application that eliminates distractions and emphasizes CAD features.

The standalone JupyterCAD Application.

Starting the dedicated JupyterCAD application is as simple as starting JupyterLab or Jupyter Notebook:

jupyter cad

This dedicated application has been built in a similar way to the coming Jupyter Notebook 7. It’s a JupyterLab “remix” built from the ground up using JupyterLab core components and custom extensions. Much like JupyterLab, it offers theming and localization support, and more planned features on the horizon.

Python API for CAD Operations

Advanced users can unlock the full potential of CAD operations with JupyterCAD’s Python API. JupyterCAD allows users to programmatically visualize, create, and manipulate the shapes from a Jupyter Notebook. For example, one can open a FreeCAD file and start modifying it from the notebook with:

from jupytercad import CadDocument
doc = CadDocument('example.FCStd')
# Create a cone, a sphere then cut the cone with the sphere.
doc.add_cone().add_sphere(radius=0.8).cut()
display(doc)

Adding object to FreeCAD file from Jupyter Notebook.

JupyterCAD API also integrates nicely with the OpenCascade Python API, providing expanded capabilities for working with shapes.

from jupytercad import CadDocument
...
# Create a prism shape with OpenCascade
prism = BRepPrimAPI_MakePrism(profile, vec).Shape()
doc = CadDocument()
doc.add_occ_shape(prism)
display(doc)

Visualize OpenCascade shape object with JupyterCAD.

Unlocking teamwork with real-time collaboration

Collaborative Editing

One of the standout features of JupyterCAD is its shared editing functionality, which seamlessly connects users across different interfaces within the JupyterCAD ecosystem. Whether collaborators are using the dedicated JupyterCAD application, the JupyterLab extension, or working with the Python API in a Notebook, any changes made to a shared document are instantly reflected for all users.

Real-time collaboration allows individuals working in the Python API to make modifications to the CAD document, while simultaneously providing a synchronized view for collaborators using the JupyterLab extension or the JupyterCAD application. This ensures that all participants have access to the most up-to-date version of the design, fostering efficient communication and eliminating the need for manual synchronization or file exchange.

Real-time collaborative editing in JupyterCAD.

Follow Mode

With JupyterCAD’s follow-mode feature, collaboration becomes even more fluid. You can follow another user’s camera movements and view adjustments in real-time. This mode allows you to gain insights into the design process, and enhance communication among team members.

Follow Mode in action.

Annotations System

The annotations system in JupyterCAD adds an interactive layer to 3D designs. Now you can add annotations to specific shapes within a CAD file, give context, provide feedback, or write instructions.

Adding annotation at precise positions

What goes on under the hood?

All the above features are made possible thanks to two major open-source components: OpenCascade.js, the WebAssembly build of OpenCascade, and jupyter_collaboration, the real-time collaboration framework of JupyterLab.

In-browser geometric modeling kernel

To execute all geometric operations, JupyterCAD uses a custom build of OpenCascade.js, which is a port of the OpenCascade library to JavaScript and WebAssembly via Emscripten. Running on a separate thread, the CAD Kernel of JupyterCAD allows users to perform complex operations at near-native speed. It also helps to lower the load of the server while serving JupyterCAD to many users.

JupyterLab Real-Time Collaboration framework

In JupyterLab 4, Real-Time Collaboration (RTC) is not only about editing notebooks but it has become a framework for building collaborative applications. Using the components of jupyter_collaboration helps us accelerate the development of the RTC features in JupyterCAD. Collaborative Editing is built upon a shared data model where jupyter_collaboration handles all the transportation and conflict resolution, while Follow Mode makes use of Awareness, a lightweight notification system provided by the library.

Future work

The current state of JupyterCAD illustrates the capabilities of JupyterLab as a foundation to build complex applications, not just for scientific computing but also for more general technical computing applications.

We will continue to improve JupyterCAD on two axes:

Enhancing the 3D viewer with features to help users interact with the objects
Enriching the Python API to improve interoperability with other CAD libraries

We plan on upstreaming some of the features of JupyterCAD, like the annotations system and the Follow Mode, to jupyter_collaboration to enable it in other file contexts in JupyterLab (Notebooks, text files, etc).

User feedback from the community also plays a big role in the project roadmap. Try JupyterCAD and share your feedback with us using the project’s GitHub issues!

About the Authors

Martin Renou is a Technical Director at QuantStack and a maintainer of Project Jupyter. Among other projects Martin is a core team member of the ipywidgets project and maintains many Jupyter widget packages such as ipyleaflet, ipydatagrid, ipygany, ipycanvas, and bqplot. He is a co-creator of the Voilà dashboarding system, and the xeus-python kernel.