Johan Mabille · Jupyter Blog

Congratulations, Distinguished Contributors!

Johan Mabille — Wed, 24 Jun 2026 15:08:46 +0000

We are proud to announce the recipients of the Jupyter Distinguished Contributor (JDC) award for the 2025 cohort of contributors.

Project Jupyter Distinguished Contributors are recognized for their substantial contributions to Jupyter itself in both quality and quantity over at least two years. Contributions may include code, code review, infrastructure work, mailing list and chat participation, community help/building, education and outreach, fundraising, branding, marketing, inclusion and diversity, UX design and research, etc.

Please congratulate the winners of the 2025 cohort of Jupyter Distinguished Contributors!

James Colliander

Florence Haudin

Greg Mooney

Kirstie Whitaker

Congratulations, Distinguished Contributors!

Johan Mabille — Thu, 15 May 2025 15:15:28 +0000

We are proud to announce the recipients of the Jupyter Distinguished Contributor (JDC) award for the 2024 cohort of contributors.

Please congratulate the winners of the 2024 cohort of Jupyter Distinguished Contributors!

Denisa Checiu

Rowan Cockett

Mahendra Paipuri

Isabel Paredes

David L. Qiu

Rick Wagner

Announcing the 2023 Jupyter Distinguished Contributor Award Recipients

Johan Mabille — Wed, 04 Sep 2024 16:46:35 +0000

We are delighted to announce the recipients of the Jupyter Distinguished Contributor (JDC) award for the 2023 cohort.

Project Jupyter Distinguished Contributors are recognized for their significant and sustained contributions to Jupyter over a period of at least two years. These contributions encompass a wide range of areas, including code development, code review, infrastructure work, participation in mailing lists and chats, community building and support, education and outreach, fundraising, branding and marketing, efforts in inclusion and diversity, UX design, and research.

Please join us in congratulating the winners of the 2023 cohort of Jupyter Distinguished Contributors:

Nicolas Brichet
Piyush Jain
Duc Trung Le
Jason Weill

Their dedication and hard work have been instrumental in advancing the Jupyter project and community.

Johan Mabille — on behalf of the Jupyter Distinguished Contributors

Congratulations, Distinguished Contributors!

Johan Mabille — Fri, 02 Jun 2023 12:41:24 +0000

We are proud to announce the recipients of the Jupyter Distinguished Contributor (JDC) award for the 2022 cohort of contributors.

Please congratulate the winners of the 2022 cohort of Jupyter Distinguished Contributors!

Tania Allard

Carlos Herrero

Itay Dafna

Eric Charles

Max Klein

Ryan Lovett

Sharan Foga

Rollin Thomas

Ayaz Salikhov

Congratulations, Distinguished Contributors!

Johan Mabille — Wed, 16 Mar 2022 16:23:40 +0000

We are proud to announce the recipients of the Jupyter Distinguished Contributor (JDC) award for the 2021 cohort of contributors.

Please congratulate the winners of the 2021 cohort of Jupyter Distinguished Contributors!

Mehmet Bektas

David Brochart

S. Chris Colbert

Frédéric Collonval

Martha Cryan

Wayne Decatur

Sarah Gibson

Mariana Meireles

Isabela Presedo-Floyd

Nicolas Thiéry

Xeus 2.0

Johan Mabille — Tue, 28 Sep 2021 09:41:20 +0000

Announcing a major release of the Xeus library

We have just released Xeus 2. This is a major release of the library. While it includes backward-incompatible changes, they are very limited and upgrading your kernels should be relatively easy.

How to upgrade Xeus-based kernels

Let’s illustrate that with the code of a simple kernel before and after upgrading to Version 2. Most typically, only the kernel’s main file will have to be updated:

 25 diff --git a/example/src/main.cpp b/example/src/main.cpp
 26 index 29de437..eb8fdba 100644
 27 --- a/example/src/main.cpp
 28 +++ b/example/src/main.cpp
 29 @@ -21,12 +21,14 @@ int main(int argc, char* argv[])
 30      std::string file_name = (argc == 1) ? "connection.json" : argv[2];
 31      xeus::xconfiguration config = xeus::load_configuration(file_name);
 32 
 33 +    auto context = xeus::make_context<zmq::context_t>();
 34 +
 35      // Create interpreter instance
 36      using interpreter_ptr = std::unique_ptr<custom::custom_interpreter>;
 37      interpreter_ptr interpreter = interpreter_ptr(new custom::custom_interpreter());
 38 
 39      // Create kernel instance and start it
 40 -    xeus::xkernel kernel(config, xeus::get_user_name(), std::move(interpreter), xeus::make_xs    erver_zmq);
 41 +    xeus::xkernel kernel(config, xeus::get_user_name(), std::move(context), std::move(interpr    eter), xeus::make_xserver_zmq);
 42      kernel.start();
 43 
 44      return 0;

The first change is that you now have to instantiate and pass an additional argument to the kernel constructor: the context. Fortunately, Xeus provides a function to build such a context object, making the update straightforward. We will detail the reason for this change in the next section.

The second change is that the kernel constructor now requires a function to build the server while a default value was provided for it in Xeus 1.x. Again, the motivations for this change will be detailed in the next section. Finally the functions for building the servers have moved to different headers.

To summarize, here is the list of the breaking changes:

The kernel’s constructor now requires an additional argument, the context. Xeus provides a function to easily instantiate it.
The order of kernel’s constructor arguments has changed, and the function for building the server is now required.
The functions for building the servers have moved to the headers where the corresponding servers are defined.

Motivation for these changes

When we created Xeus, kernels were expected to run in separate processes. The communication between the kernels and the client was achieved with the ZeroMQ middleware framework, and it was natural to heavily rely on it in Xeus.

Recent developments have pushed in a different direction, where the kernel can run directly in the browser. In that case, a middleware library is not required anymore to communicate with the frontend. The architecture of Xeus was not suitable for this new kind of kernels. An update was required so that it is possible to build Xeus without the dependency on ZeroMQ.

About the developers

Johan Mabille is a scientific software developer at QuantStack. Johan is a co-author of Xeus, and developed the debugger extension to xeus-python.

Sylvain Corlay is the founder and CEO of QuantStack, and a core Jupyter developer. He co-authored Xeus and xeus-python.

Xeus is now a Jupyter subproject

Johan Mabille — Tue, 04 Feb 2020 12:08:39 +0000

It is a great pleasure to announce that the Xeus project has been incorporated as a Jupyter subproject. Xeus will now be subject to the Jupyter governance and code of conduct.

For reference, the Jupyter Enhancement Proposal (JEP) for the Xeus incorporation is available here.

What is Xeus?

The Xeus project is a C++ implementation of the Jupyter kernel protocol. Xeus is not a kernel, but a library meant to facilitate the authoring of kernels.
Several Jupyter kernels have been created with Xeus:

xeus-cling, a kernel for the C++ programming language, based on the Cling C++ interpreter. The cling project comes from CERN and is at the foundation of the ROOT project.

The xeus-cling Jupyter kernel for the C++ programming language.

xeus-python, a kernel for the Python programming language, embedding the Python interpreter.

The xeus-python Jupyter kernel for the Python programming language

xeus-calc, a calculator kernel, meant as an educational example on how to make Jupyter kernels with Xeus.

Beyond these three kernels built on top of Xeus by the Xeus maintainers, third-parties have developed other Jupyter kernels with Xeus:

JuniperKernel, a kernel for the R programming language by Spencer Aiello.
xeus-fift, a kernel for the fift programming language by Michael Zaikin. The fift programming language was developed by Telegram to create TON blockchain contracts.
SlicerJupyter, a kernel for the Python programming language by Kitware which integrates into the Qt event loop of the Kitware “Slicer” project.

Finally, the xeus-python kernel includes a first implementation of the Jupyter debugger protocol used by the Jupyter debugger project. xeus-python enables the Debug Adapter Protocol over the Control channel through new debug request/reply and debug event messages.

Why moving Xeus under the Jupyter governance?

While Xeus started as a side project for QuantStack engineers, the project now has several stakeholders who depend on it. We think that moving the project to an open governance organization may be a better way to reflect this situation.

Acknowledgements

Xeus was started by the team of open-source developers at QuantStack as a separate project, but with the full intent to incorporate it into Jupyter. The initial project development at QuantStack was funded by Bloomberg.
Now, Xeus contributors work in many institutions, including Université Paris-Saclay and École Polytechnique.

About the Author

Johan Mabille is a Scientific Software Developer at QuantStack, specializing in high-performance computing in C++. He holds master’s degree in computer science from Centrale-Supelec.

As an open source developer, Johan coauthored xtensor, xeus, and xsimd. He also made major contributions to the JupyterLab debugger project and bqplot.