Jupyter Blog - Jeremy Tuloup

JupyterLite 0.8 is released! 🎉

2026-07-10T05:01:00+00:00

JupyterLite is a Jupyter distribution that runs entirely in the web browser without any server components. Deployment and hosting are easy as JupyterLite sites are just static websites.

The new 0.8 release includes a number of new features, bug fixes, and enhancements. This release also brings significant improvements to the user experience and new customization options for JupyterLite deployments.

When the REPL toolbar is enabled, it now includes a Copy Shareable Link button. Clicking it captures the current state of the REPL, the prompt content, the selected kernel and theme, and any non-default options, into the page URL, and copies the resulting link to the clipboard. A notification confirms the link was copied, making it easy to share a ready-to-run REPL with others.

Refreshed Loading Screen

The loading indicator shown while JupyterLite starts up has been redesigned to match the JupyterLab splash screen to make the transition from the initial loading screen to the fully loaded application feel more seamless.

The loading indicator remains configurable, and can be enabled or disabled for specific applications. See the loading indicator guide for more details.

File System Reliability Improvements

JupyterLite 0.8 includes many fixes to the in-browser file system used to store your notebooks and files. Creating files and directories is now faster and more reliable, saving a file to a directory that does not exist is now rejected with a clear error rather than failing silently, and files are no longer opened twice on startup when using query parameters. These changes make working with files in JupyterLite smoother and more dependable.

JupyterLab 4.6 and Notebook 7.6

JupyterLite 0.8 is built on top of JupyterLab 4.6 and Notebook 7.6, and brings many of the respective improvements and bug fixes. Check out the announcement post to learn more about these new releases.

This JupyterLite release includes 9 new features and enhancements, 11 bug fixes, and 5 documentation improvements. 13 people contributed to this release. Across 85 maintenance tasks and dependency updates, we kept JupyterLite up to date with the latest JupyterLab and Notebook releases.

A Terminal in the Browser

The JupyterLite Terminal adds a fully in-browser command-line terminal to JupyterLite, powered by the cockle shell. Commands run as WebAssembly directly in the browser, with no server involved. Version 1.5 adds compatibility with JupyterLite 0.8, and recent releases include:

A growing set of familiar command-line tools compiled to WebAssembly, including ls, cat, cp, mv, grep, sed, tree, git, and the vim and nano editors.
Tab completion for commands, arguments, and file names, with a confirmation prompt before listing a very large number of matches.
New JupyterLab commands for running shell commands programmatically and capturing their output, without opening a terminal panel.

Running terminal commands in the browser

More Kernels with jupyterlite-xeus

jupyterlite-xeus builds JupyterLite deployments around Xeus-based kernels and lets you pre-install packages from conda-forge and emscripten-forge straight into the browser environment through an environment.yml file. Its recent releases (the 4.5 series and the new 5.0) are compatible with JupyterLite 0.8 and add a number of improvements:

A growing list of supported kernels, including xeus-python, xeus-r, xeus-cpp, xeus-lua, xeus-nelson, xeus-octave, and xeus-javascript.
Installing packages at runtime now feels more natural: you can run pip installor conda installdirectly in a cell, with the leading % or ! now optional.

To learn more about pre-installing packages, mounting files, and the available kernels, see the jupyterlite-xeus documentation.

Python 3.14 with the Pyodide Kernel

The Pyodide kernel has been updated to version 0.8.0. It bundles the latest Pyodide release, which upgrades the in-browser Python interpreter to Python 3.14. Notebooks and consoles running on the Pyodide kernel now use the newest Python version, including recent standard library additions such as the new compression.zstd module.

For deployments that pre-compute the set of packages to ship offline, the kernel’s lock add-on can now build a customized pyodide-lock.json from your own requirements — including reading dependencies from a requirements.txt file or a pyproject.toml dependency group — giving site authors finer control over which packages are available without a network connection.

See the pyodide-kernel 0.8.0 release notes for the full list of changes.

Pyodide 314 in JupyterLite

JavaScript Kernel Improvements

The in-browser JavaScript kernel has gained several improvements in its 0.4 development line:

A new iframe-based execution mode with better support for libraries that need direct access to the DOM, such as p5.js.
Initial support for Jupyter Widgets, through Comm channels and a set of base widgets.
Clearer error messages and tracebacks, including a fix for errors that previously rendered as blank in Firefox.

Jupyter Widgets and dynamic imports with the JavaScript kernel

Try it in your browser

If you would like to try the new release in your browser, click on the following link:

Acknowledgments

Thanks to Bloomberg for funding the work on JupyterLite at QuantStack, and for their ongoing support for JupyterLite in general.

Many thanks to all the contributors to JupyterLite. The list below is based on GitHub usernames for the 0.8 release across the different projects:

New contributors: @Darshan808, @MMesch, @MUFFANUJ, @wata727
Returning contributors: @DerThorsten, @agriyakhetarpal, @bollwyvl, @ianthomas23, @jasongrout, @jtpio, @martinRenou, @trungleduc

Thank you to the extended group of contributors in Jupyter Frontends and related project in the Jupyter ecosystem 💛

JupyterLite 0.7 is released! 🎉

2025-12-04T22:11:00+00:00

JupyterLite is a Jupyter distribution that runs entirely in the web browser without any server components. Deployment and hosting are easy as JupyterLite sites are just static websites.

The new 0.7 release includes a number of new features, bug fixes, and enhancements. This release also brings significant improvements to the user experience and new customization options for JupyterLite deployments.

Workspace Support

Support for workspaces is now available in JupyterLite. Workspaces allow you to organize your notebooks and files into separate workspace environments, making it easier to switch between different projects or contexts.

Workspaces are now supported in JupyterLite

The UI layout is also now automatically persisted across sessions. When you return to JupyterLite, your panel arrangements, open files, and workspace configuration will be restored exactly as you left them.

Audio and Video Playback

JupyterLite now includes built-in audio and video viewers, allowing users to open audio and video files directly from within the UI.

Open audio and video files in JupyterLite

Basic Interrupt Functionality

The interrupt button now cancels the execution of cells that are scheduled to run after the currently executing cell. While this doesn’t interrupt the currently running cell itself, it provides better control when executing multiple cells in sequence.

The stop button now cancels the execution of scheduled cells

Basic Notebook Export

JupyterLite now includes basic notebook export functionality through a custom export plugin. Users can export notebooks to different formats including .ipynb (notebook format) and script formats directly from the File menu.

Additionally, JupyterLite provides extension points for third-party extensions to register custom exporters. This enables the development of additional export formats, such as PDF, in future extensions.

Note: there is currently no built-in support for PDF export, but this may be added in the future via a third-party extension.

Basic notebook exports are now available

A download entry has been added to the File menu, making it easier to download files from your JupyterLite environment.

Download a notebook using the file menu entry

Enhanced Markdown Support

Markdown cells now support displaying base64-encoded images stored in the browser’s local storage. This makes it easier to include images in your notebooks without requiring external hosting or network access.

JupyterLab 4.5 and Notebook 7.5

JupyterLite 0.7.0 is built on top of JupyterLab 4.5.0 and Notebook 7.5.0, and brings many of the respective improvements and bug fixes. Check out the announcement post to learn more about these new releases.

JupyterLab 4.5 notably includes significant notebook performance improvements, such as the new optimized cell rendering with the new contentVisibility windowing mode.

Walkthrough video

For a more interactive tour of the new features, watch the video below:

Try it in your browser

If you would like to try the new release in your browser, click on the following link:

Acknowledgments

Thanks to Bloomberg for funding the work on JupyterLite at QuantStack, and for their ongoing support for JupyterLite in general.

Many thanks to all the contributors to JupyterLite. The list below is based on GitHub usernames for the 0.7.0 release:

New contributors: @rgaiacs, @tan-i-ham
Returning contributors: @DerThorsten, @bollwyvl, @diegofcornejo, @ianthomas23, @jtpio, @krassowski, @martinRenou

Thank you to the extended group of contributors in Jupyter Frontends and related project in the Jupyter ecosystem 💛

JupyterLab 4.5 and Notebook 7.5 are available!

2025-11-24T09:32:00+00:00

JupyterLab 4.5 has been released! This new minor release of JupyterLab includes 51 new features and enhancements, 81 bug fixes, 44 maintenance tasks and 38 documentation improvements. There were 51 contributors to this release.

Jupyter Notebook 7.5 has also been released, including many of the fixes and enhancements in this JupyterLab 4.5 release. While the releases on GitHub provide additional detail on the updates made to both JupyterLab 4.5 and Notebook 7.5, this article highlights some particularly notable changes.

Extension authors can refer to the Extension Migration Guide for information on API updates and details regarding changes to core packages.

Performance and windowing

The default windowing mode is now contentVisibility which improves cell rendering and alleviates previously reported issues. The minimap can be enabled for all windowing modes and all notebooks via the Settings menu, or by toggling the minimap per notebook with the View -> Show Minimap option. Additional fixes improve layout containment and scrollbar behavior when working with long cells.

Notebook improvements

Saving large notebooks is now faster and more responsive thanks to streamed uploads and users can now open notebooks without starting a kernel, via the Open With context menu option.

Open a notebook without a kernel

Markdown support has been expanded for using grid and flex based layouts and the Table of Contents has been significantly improved to better handle markdown headings, fixing issues with HTML tags, comments, and horizontal lines.

Copying and pasting cells across browser tabs is now supported and the “Line Wrap” toggle in settings now correctly applies line wrapping to cells.

Other improvements include: restored scrolling to in-notebook links, manual saving support in collaborative mode, and improved performance and memory usage when streaming text outputs.

Debugger and Console improvements

The debugger’s evaluate dialog has been replaced with an interactive console with syntax highlighting and code completion, and the variables panel now preserves its contents when switching editors. Selected breakpoints are now visually highlighted and breakpoints correctly handle empty lines and duplicate clicks. A visual indicator is displayed when the debugger is paused.

Debugger panels as well as console debugging panels now reference the cell execution count helping users relate breakpoints, call stacks and source code to the cells they originate from.

JupyterLab 4.5 includes many improvements to the debugger

For the Log Console, users can now configure the default log level via settings, as well as customise the toolbar.

New search functionality inside terminals

The terminal now includes search functionality, with search highlights that adapt to theme changes.

Search is now compatible with terminals

Media and content support

JupyterLab now includes built-in audio and video viewers, allowing users to open audio and video files directly from within JupyterLab.

Open audio and video files in JupyterLab

File browser enhancements

Uploaded files can auto-open, with controls for size limits and behavior, and a new allowFileUploads setting provides control over upload permissions.

There is now a menu option for creating new Python, R, or Julia files, and a “Select All” command has also been added, also accessible via the Ctrl + A keyboard shortcut.

Users can now configure file browser breadcrumbs through the settings editor options breadcrumbsLeftItems and breadcrumbsRightItems.

JupyterLab 4.5 includes many improvements to the file browser

Updates to file dialogs and navigation have addressed column spacing, preferred-directory handling and double-click behavior.

Keyboard shortcuts and commands

Code fold and unfold commands have been added and shortcuts for these can be set in the settings editor.

The “Show Workspace Indicator” command has been added to the command palette and the “Send Code to Console” shortcut has been restored. The previous issue involving editing shortcuts on Safari loosing focus, has been resolved.

With Jupyter Notebook 7.5.0, the O key has been defined as the keyboard shortcut to toggle cell outputs, restoring this familiar functionality from the classic notebook.

Settings

The settings editor now supports a toSkip configuration to hide specific plugins from view.

A new setting, addExtraLineOnCellMerge, allows to remove the extra line added when merging cells, which is expected behavior based on the classic notebook.

User interface and accessibility

JupyterLab can now automatically switch between light and dark themes when “Synchronize with System Settings” is enabled.

Dialog components display buttons and checkboxes on separate lines for better readability, and selections in the terminal under high-contrast themes have better visibility.

Keyboard navigation and tab order in the status bar has also been improved.

Update from JupyterCon

At JupyterCon 2025 in San Diego, the Jupyter Frontends team presented an update on features released since JupyterLab 4.0. This session covers the progress made since the previous conference in 2023. You can watch the full recording below.

Acknowledgements

Thank you to all the new contributors, the Jupyter Frontends team hopes to see you back!

JupyterLab: @Ankitaupadhaya, @CrafterKolyan, @EtiennePelletier, @Frank-Steiner, @Meriem-BenIsmail, @arjxn-py, @bnavigator, @bsundaram1, @dnlzrgz, @dotnetautor, @gjmooney
Notebook: @honnix, @jchen1223, @sangampaudel530

And thank you to returning contributors for their continued work!

JupyterLab: @Darshan808, @DenisaCG, @HaudinFlorence, @MUFFANUJ, @RRosio, @SylvainCorlay, @achhina, @afshin, @andrii-i, @bollwyvl, @brichet, @choldgraf, @cmarmo, @davidbrochart, @ianthomas23, @isabela-pf, @itsmevichu, @jasongrout, @jrdnbradford, @jtpio, @kathatherine, @kr-2003, @krassowski, @mahendrapaipuri, @martinRenou, @minrk, @nkn2022, @peytondmurray, @ritzdevp, @robertstrauss, @rschroll, @shreve, @skapin, @trungleduc, @yacchin1205, @yukiiii04, @zanieb
Notebook: @choldgraf, @itsmevichu, @jasongrout, @jtpio, @krassowski, @minrk

Thank you to all the people who tested and provided feedback for the pre-releases! Lastly, thank you to the weekly triage group for triaging JupyterLab, Notebook and JupyterLab Desktop issues: @RRosio, @krassowski, @andrii-i, @danyeaw among others who attend.

JupyterLite 0.6.0 is released! 🎉

2025-06-12T15:04:00+00:00

JupyterLite is an unofficial Jupyter distribution that runs entirely in the web browser without any server components. Deployment and hosting are easy as JupyterLite sites are just static websites.

The new 0.6.0 release includes a number of new features, bug fixes, and enhancements. This release also brings significant improvements to the user experience and new customization options for JupyterLite deployments.

Interactive Input Support

Support for kernel stdin requests is now available, enabling interactive input functions like Python’s input()and getpass() in notebooks. This fixes a long standing limitation of JupyterLite when executing the following code:

name = input("What is your name? ")
print(f"Hello {name}!")

Using input() and getpass() in a JupyterLite notebook

Since input()is used quite extensively in introductory Python courses, this new feature should help make teaching with JupyterLite easier!

New REPL Options

The REPL exposes new options as URL parameters:

promptCellPosition — place the prompt cell to the top, left, right or bottom
clearCodeContentOnExecute — when disabled, the code submitted for execution remains in the code editor, allowing for further edits.
hideCodeInput — when enabled, only the execution output is shown in the console.
clearCellsOnExecute — when enabled, only the last cell is displayed.
showBanner — when disabled, hide the banner for the kernel

Toggling all the new options transforms the console into an interactive editor resembling an ephemeral notebook with a single cell.

A single executable cell in JupyterLite

In addition to these URL parameters, the toolbar includes new items to:

Execute code
Restart the kernel
Clear the cells
Switch the kernel

Check out the REPL documentation for more details on how to use these parameters.

Kernel Indicator and Logs

A new notebook toolbar item has been added to show the kernel status with three different states:

Loading: the kernel is starting or performing some actions
Success: the kernel is ready to execute code
Failure: an error occurred while starting the kernel or during execution, and likely requires a restart of the kernel

This new toolbar item gives users better visibility into the kernel’s status and allows them to view the kernel logs by clicking on the toolbar item to open the log console.

Kernel logs can help troubleshoot JupyterLite issues

Clear Browser Data

By default JupyterLite stores user-created notebooks and settings in the browser.

In previous versions, users had to manually clear the data using the browser developer tools. With JupyterLite 0.6.0 it is now possible to clear the browser data from the UI by clicking on the Help > Clear Browser Data menu item. The confirmation dialog will show options to clear settings and contents.

The confirmation dialog for clearing browser data

Loading indicator

A new indicator has been added to let users know JupyterLite is currently starting up, which is useful for deployments that take some time to load, especially on slow connections.

By default, the loading indicator is only visible in the JupyterLab application (not for Jupyter Notebook or REPL). If you would like to enable or disable the indicator for some or all applications, check out the guide in the documentation.

The loading indicator lets users know something is happening when the page is loaded

Settings import and export

Settings can now be exported to an overrides.json file from the Settings Editor. This file can then be used to pre-configure defaults in deployments or to restore settings.

This allows users to interact with a JupyterLite deployment, make a couple of changes to the settings, and export them to an overrides.json that can be then included in a JupyterLite deployment, or imported in another one.

The new export and import buttons in the Settings Editor

Plugin Manager

Open the command palette and search for Advanced Plugin Manager to open the plugin manager. With the plugin manager, users can:

View active plugins in the running JupyterLite environment
Understand dependency relationships between plugins
Gain better visibility into the configuration of their environment

The plugin manager lists active plugins in a JupyterLite deployment

Improved Multi-site Contents Management

The default in-browser storage is now scoped using the baseUrl of the deployment. This allows hosting multiple sites under the same domain, and keeps user created files isolated from each other.

For example if two sites are hosted on GitHub Pages and available under the following URLs:

In practice this fixes the issue where users would create new files in one site, and they would show up in another site hosted under the same domain.

Multi-Tab File System Access

Using JupyterLite in multiple browser tabs at the same time should now result in less issues, in particular when interacting with the file system.

Extension system

In previous versions, JupyterLite was creating a separate application to register “server” extensions. Examples of such extensions are the different managers (sessions, kernels, settings, contents) but also the actual kernels (Pyodide, Xeus Python). This was not ideal because it introduced a separate namespace for these extensions, and extension authors had to configure their extension to be either a regular JupyterLab extension or a JupyterLite “server” extension.

Starting with JupyterLite 0.6.0, all extensions are now registered at the same level as regular JupyterLab extensions, making use of the new ServiceManagerPlugin type of extension introduced in JupyterLab 4.4.

JupyterLab 4.4 and Notebook 7.4

JupyterLite 0.6.0 is built on top of JupyterLab 4.4 and Notebook 7.4, and brings many of the respective improvements and bug fixes. Check out the announcement blog post to learn more.

Kernel and other updates

In addition to the JupyterLite 0.6.0 release, the Pyodide and Xeus Python kernels have also been updated to be compatible with the latest release.

Other components of the stack such as Voici and thebe-lite will also soon be updated.

Closing the gap with JupyterLab

As mentioned above, JupyterLab 4.4 introduced the ability to replace some of the core ServiceManager plugins responsible for interacting with the server, such as the kernel and session managers.

This allows JupyterLite to progressively become a set of JupyterLab extensions that can be integrated in regular JupyterLab instances.

Using in-browser and regular kernels together

⚠️ This is still very experimental!

An example of such integration is the jupyterlab-hybrid-kernels extension.

This extension allows using both in-browser (JupyterLite) and regular Jupyter kernels together in the same JupyterLab session.

There is also some work happening to explore automatically promoting in-browser kernels as regular kernels when some computations are not possible in the browser, or when some modules are not available.

Promoting in-browser as regular kernels

Migrating to 0.6.0

If you maintain a JupyterLite deployment and would like to update to the latest version, check out the migration guide.

Walkthrough video

For a more interactive tour of the new features, watch the video below:

Try it in your browser

If you would like to try the new features in your browser, click on the following link:

Acknowledgments

The work on JupyterLite at QuantStack was contributed by Anastasia Sliusar, Ian Thomas, Jeremy Tuloup, Martin Renou and Thorsten Beier.

Thanks to Bloomberg for funding this work and for their ongoing support for JupyterLite in general.

Thanks to the Bill & Melinda Gates Foundation (through a grant to CourseKata) for funding the work on the interactive input feature.

Many thanks to all the contributors to JupyterLite, Jupyter Frontends and related project in the Jupyter ecosystem (list below is based on GitHub usernames):

JupyterLab 4.4 and Notebook 7.4 are available!

2025-05-21T09:54:00+00:00

JupyterLab 4.4 has been released! This new minor release of JupyterLab includes 28 new features and enhancements, 76 bug fixes, 63 maintenance tasks and 34 documentation improvements. There were 56 contributors to this release.

Jupyter Notebook 7.4 has also been released, including many of the fixes and enhancements in this JupyterLab 4.4 release. While the releases on GitHub provide additional detail on the updates made to both JupyterLab 4.4 and Notebook 7.4, this article highlights some particularly notable changes.

Extension authors can refer to the Extension Migration Guide for information on API updates and details regarding changes to core packages.

Code console improvements

The code console prompt can now be positioned on the top, left, or right side of the console, in addition to the default bottom placement. The placement is persisted in the Prompt Cell Position setting. The console toolbar now includes buttons to:

Execute code
Restart the kernel
Clear the cells
Switch the kernel

Changing the position of the prompt cell in JupyterLab code consoles

Additional settings for console behavior have been added:

Clear Code Content on Execute (enabled by default) — When disabled, the code submitted for execution remains in the code editor, allowing for further edits.
Hide Code Input — When enabled, only the execution output is shown in the console.
Clear Cells on Execute — When enabled, only the last cell is displayed.

Toggling all the three new settings transforms the console into an interactive editor resembling an ephemeral notebook with a single cell.

The code console configured as a single executable cell

Settings import and export

Settings can now be exported to overrides.json from the Settings Editor, which can be used to pre-configure defaults in deployments or to restore settings.

Import and export settings from the Settings Editor

Workspace indicator

An opt-in workspace indicator is displayed on the top bar (next to the menu bar). It can be enabled in the Settings → View → Appearance → Show Workspace Indicator:

The workspace indicator

Support for collaboration without `RTC:` drive

Real time collaboration in previous versions of JupyterLab (which can be enabled by installing jupyter-collaboration package) was implemented by swapping the default JupyterLab file system drive to a collaborative drive with the RTC: prefix. This approach was incompatible with multiple extensions. JupyterLab 4.4 introduces the Content Providers API, which allows the next version of jupyter-collaboration to work without changing the drive prefix. This improves compatibility with extensions that do not support arbitrary drives.

Kernel subshells support

Kernel subshells, introduced in JEP 91, enable concurrent code execution in kernels that support them. When performing long-running computations (such as training a model), subshells enable users to:

Use ipywidgets with updates displayed immediately
Monitor kernel resource usage (e.g. memory usage)
Invoke arbitrary commands (e.g., refine code for a subsequent cell) while maintaining live access to previously defined variables

Subshells are supported by ipykernel 7 (currently in alpha).

To create a subshell, open context menu (right-click) over a notebook using a kernel supporting subshells and select “New Subshell Console for Notebook”. A new console panel will open allowing access to variables from the main session.

Creating a new subshell console for a notebook in JupyterLab 4.4

JupyterLab can automatically create subshells for comm messages if kernels support this feature. This enables concurrent execution of ipywidgets callbacks without requiring a user action. This behavior can be changed from the settings, with options to:

disable that feature to not use subshells for comms
(default) automatically create one subshell per comm-target (e.g. one subshell for all ipywidgets)
automatically create one subshell per comm (this can lead to issues if creating many comms)

The context menu, available under right mouse click in browsers, can now be disabled globally by toggling the Enable Context Menu option available in the Command Palette, or via the JSON Settings Editor in the Application Context Menu.

Slimmer status bar

The terminals counter no longer appears in the status bar if no terminals are open. The kernels counter can be disabled by toggling the Show the status bar item setting in Running Terminals and Kernels (code name showStatusBarItem).

Walkthrough video

If you prefer a more interactive tour of the new features mentioned in the post, check out the video below:

Acknowledgements

Thank you to all the contributors (list below is based on GitHub usernames):

JupyterLab: @Adam-D-Lewis @afshin @ajbozarth @AmberArr @andrewfulton9 @andreytaboola @andrii-i @bollwyvl @brichet @Carreau @claytonparnell @cmarmo @Darshan808 @davidbrochart @deephbz @dlqqq @echarles @fcollonval @fleming79 @holzman @hxrshxz @ianthomas23 @iisakkirotko @itsmevichu @JasonWeill @jesuino @joaopalmeiro @jtpio @kellyrowland @krassowski @kuraga @maitreya2954 @martenrichter @martinRenou @mgeier @MUFFANUJ @nkn2022 @Nriver @pawel99k @pdarshane @peytondmurray @pre-commit-ci @Princekumarofficial @Rishab87 @rpwagner @RRosio @rsaditya01 @SamuelMarks @SatyajitRedekar @SylvainCorlay @trungleduc @Zsailer
Notebook: @andrii-i @jdavid @jtpio @krassowski @RRosio

Special thank you to all the new contributors, the Jupyter Frontends team hopes to see you back!

Thank you to all the people who tested and provided feedback for the pre-releases! Lastly, thank you to the weekly triage group for triaging JupyterLab, Notebook and JupyterLab Desktop issues: @krassowski, @RRosio, @andrii-i, @danyeaw among others who attend.

JupyterLab 4.3 and Notebook 7.3 are available!

2024-12-05T22:41:00+00:00

JupyterLab 4.3.0 has been released! This new minor release of JupyterLab includes 1 new feature, 42 enhancements, 62 bug fixes, 48 maintenance tasks and 35 documentation improvements. There were 38 contributors to this release including 18 new contributors to JupyterLab.

Jupyter Notebook 7.3.0 has also been released, including many of the fixes and enhancements in this JupyterLab 4.3.0 release. While the releases on GitHub provide additional detail on the updates made to both JupyterLab 4.3 and Notebook 7.3, this article highlights some particularly notable changes.

Extension authors can refer to the Extension Migration Guide for information on API updates and details regarding changes to core packages.

Minimap

The virtual scrollbar now acts as a minimap and exposes information on whether a cell:

is running/scheduled ([*]), idle ([ ]) or was already run (e.g. [1]),
was modified since it was last executed (“dirty”) — orange background,
has an output that contains an error — red background,
is markdown/code ([ ]/[*]/[1] for code, nothing for markdown),
an how much text/code it contains.

To enable the minimap, click on the hamburger icon (≡) which appears in the notebook toolbar. If you do not see the hamburger icon, go to Settings → Notebook → Windowing mode and choose “full”.

The notebook minimap in JupyterLab 4.3

Fullscreen mode

JupyterLab now offers two ways to toggle the full screen mode from within the application:

using the View → Appearance → Fullscreen Mode menu entry,
using a customizable shortcut, by default F11 (custom shortcuts are supported in Chrome, Safari and Edge).

File browser enhancements

The file browser now:

supports resizing the columns and remembers the column sizes after reloading JupyterLab,
supports uploading folders by drag-and-drop,
supports navigation with a single click (opt-in in JupyterLab, default in Jupyter Notebook),
has the file filter collapsed by default (funnel icon), increasing the space available.

File browser enhancements in JupyterLab 4.3

Server-side execution and collaboration

JupyterLab 4.2 added the option for extensions to implement server-side execution, which preserves outputs created when the browser window is closed or disconnected. The server-side execution builds on the same shared models API as the real-time collaboration (RTC).

You can try these features by installing extensions:

jupyter-server-nbmodel* provides server-side execution for jupyter-server,
jupyter-collaboration provides the real-time collaboration features,
jupyverse is an alternative server (a replacement for jupyter-server) which supports server-side execution.

* while jupyter-server-nbmodel is developed by maintainers of JupyterLab, as of the JupyterLab 4.3.0 release date it is not an official Project Jupyter extension.

Improved kernel and server interactions

The previous release enabled connecting to external kernels, such as those spawned by a third-party application like Blender. In this release the kernel selector dialog was improved to also show the external kernels.

The previous release improved the awareness of the kernel/kernel specification distinction by providing both tree and list view in the kernels sidebar panel, but only the tree view featured the kernel identifiers. In this release both the list and tree view show the kernel identifier stub.

A new toolbar button was added in the kernel allowing to shut down unused kernels (kernels with no widget attached).

Shut down unused kernels in JupyterLab 4.3

Full Width Notebook

In Jupyter Notebook 7.3, it is now possible to configure the notebook to take up the full width of the page via:

a setting that can be defined by a user via the Settings Editor
the View > Enable Full Width Notebook menu entry
the command palette, searching for Enable Full Width Notebook

Full width notebook in Jupyter Notebook 7.3

JupyterLab 3 end of maintenance

As a reminder, JupyterLab 3 will reach its end of maintenance date on December 31, 2024, anywhere on Earth. Users are highly encouraged to update to JupyterLab 4 as soon as possible.

For more information, please refer to the announcement post.

Acknowledgements

Thank you to all the new contributors, the Jupyter Frontends team hopes to see you back!

JupyterLab: @jgoodson, @Wzixiao, @krishanbhasin-px, @hnben, @sanskriti2005, @achhina, @mahendrapaipuri, @Renegade334, @Nazeeh21, @pauldruce, @EdsterG, @gderocher, @dhysdrn, @algonell, @nekomeowww, @mjpsyapse, @kaushalaaditya99, @Nagidrop
Notebook: @bluestealth, @andyscho, @algonell, @gjmooney

And thank you to returning contributors for their continued work!

JupyterLab: @afshin, @ajbozarth, @andrewfulton9, @andrii-i, @brichet, @cmarmo, @Darshan808, @davidbrochart, @fcollonval, @gabalafou, @HaudinFlorence, @itsmevichu, @JasonWeill, @joaopalmeiro, @jtpio, @krassowski, @maitreya2954, @Mehak261124, @NexVeridian, @RRosio
Notebook: @JasonWeill, @jtpio, @krassowski, @martinRenou, @RRosio

Thank you to all the people who tested and provided feedback for the pre-releases! Lastly, thank you to the weekly triage group for triaging JupyterLab, Notebook and JupyterLab Desktop issues: @JasonWeill, @krassowski, @RRosio, @andrii-i among others who attend.

Automate your releases with the Jupyter Releaser 🚀

2024-10-28T18:09:00+00:00

In the world of open-source software, releases ensure that the latest features, bug fixes, and improvements reach users promptly. However, the process of managing releases, especially for large projects, can be complex and error-prone. This is where Jupyter Releaser comes into play.

Jupyter Releaser is an automation tool developed by the Jupyter team to streamline and standardize the release process across Jupyter projects. Its goal is simple: reduce the manual burden on maintainers, ensure consistency, best practices, improve confidence, and eliminate the potential for human error.

😔 The Problem: Manual Release Processes

Many maintainers of libraries have experienced the pains of a manual release process:

Versioning Issues: Manually updating version numbers across multiple files can lead to inconsistencies and errors.
Changelog Generation: Creating and maintaining accurate changelogs can be time-consuming.
Publishing: Whether it’s for PyPI or npm, the process involves multiple steps that are easy to mess up, and requires maintainers to manage their own credentials and tokens.

These pain points are not just frustrating; they can also delay the release of new versions and introduce issues that affect the end-users.

🤩 The Solution: Jupyter Releaser

Jupyter Releaser automates and standardizes the release process, ensuring that everything from versioning to changelog generation and publishing is handled efficiently. It helps maintainers reduce toil and save time in the release process by enforcing best practices to:

Automate a changelog for every release
Verify the install and import of dist assets, such as Python wheels and npm packages, to ensure packaging is done correctly
Commit a message with hashes of dist files
Annotate the git tag in a standard format
Create a GitHub release with a changelog entry, and automatically populate a changelog file
Trigger a dry run publish on CI, to make sure the project is in a releasable state at any time
Consistently publish final packages to PyPI and npm

➡️ Getting Started with Jupyter Releaser

Step 0: Set up

Setting up a repository to use the Jupyter Releaser involves a few steps which are listed on this page of the documentation.

The first one is to create a GitHub app for the organization or profile that owns the repo, following this guide. Then continue with the steps in the documentation to fill in the values for the app.

To follow best practices it is also recommended to create a release environment on the repo to add the APP_ID variable and APP_PRIVATE_KEY secret.

If you publish a package to PyPI, you will also need to add a trusted publisher, which usually corresponds to the source repository.

For npm, don’t forget to specify a "publishConfig": { "access": "public" } to the package.json.

Finally, copy the prep-release.yml and publish-release.yml workflows from the example-workflows folder to your repository.

Quite a few steps, but you should now be ready to go! Fortunately this setup needs to be done only once per repository. If you release multiple projects hosted under the same organization, you can reuse the same GitHub app.

Again, feel free to refer to the documentation for the complete checklist.

Step 1: Prep Release

To start the release, go to the “Actions” tab of the repo and select “Step 1: Prep Release”. Open the “Run Workflow” dropdown and fill in the appropriate parameters.

Running the “Prep Release” workflow for a JupyterLab extension (speed x5)

Running this workflow will create a draft GitHub release with the generated changelog for the new version. You can edit the changelog by editing the release if needed. Don’t forget to click on “Save Draft” and not “Publish Release” if you make any changes! (the releaser will do the publishing in the next step)

Step 2: Publish Release

If the changelog and draft GitHub release look good, go back to the “Actions” tab and click on “Step 2: Prep Release”.

In most cases, you can leave the fields empty and the releaser will automatically publish the GitHub Release previously created.

Publishing the extension (speed x5)

Congrats, you just made your first release with the Jupyter Releaser! 🎉

Going further

Jupyter Releaser also provides a set of hooks and options, such as running an arbitrary command after a given step, or providing a custom strategy for versioning packages. This allows for great flexibility in more complex repositories.

Check out the documentation for more information.

🌐 How Jupyter Releaser Fits into the Jupyter Ecosystem, and beyond

Releases are moments of celebration in any project, a chance to deliver new features, enhancements, and bug fixes to users. But they shouldn’t be a source of stress. Jupyter Releaser makes releases smoother for maintainers across the Jupyter ecosystem and beyond.

Jupyter Releaser is now used for most of the projects in the Jupyter stack with great success, such a JupyterLab, Jupyter Notebook, Jupyter Server, ipykernel, and many more. It greatly simplified the previously complex JupyterLab release process, which used to take 30 minutes, and now boils down to clicking on just a few buttons on GitHub and waiting for the workflows to complete.

Although its name has “Jupyter” in it, the releaser is not limited to releasing Jupyter related projects only, If you maintain a simple Python or npm package, you can also use the Jupyter Releaser to publish your package(s) to PyPI, npm or both!

In the end, Jupyter Releaser can simplify your workflow and save you valuable time. Give it a try and check out the repo here to see how it can make software releases a breeze!

🙏 Acknowledgments

Many thanks to Steven Silvester for creating the Jupyter Releaser and helping with its adoption across the Jupyter stack.

Jupyter Releaser is an official Jupyter project, and the Jupyter Releaser maintainers would also like to thank the contributors in the Jupyter community who help improve the tool and provide feedback ❤️

Report on the JupyterLite Community Workshop 💡

2023-01-27T13:06:00+00:00

The JupyterLite Community Workshop, held at the OVHcloud headquarters in Paris, France from December 7th to December 9th, 2022, brought together a group of developers, educators, and data scientists to discuss the latest advancements in the Jupyter and Python in the browser ecosystems.

Jupyter Community Workshops are a series of community-organized events that aim to tackle challenging development and design projects, grow the community of contributors, and strengthen collaborations.

One of the main focuses of the workshop was the JupyterLite project, a Jupyter distribution built from the ground-up using JupyterLab components and extensions, allowing for very scalable deployments. It already powers inline consoles and notebooks on the websites of major projects of the PyData ecosystem, such as NumPy, SymPy, PyMC, and many more.

The workshop also gathered the main developers and contributors of the Pyodide, PyScript and Emscripten-Forge projects that enable using Python in the browser.

Highlights of the week

During the workshop, attendees had the opportunity to participate in group discussions, and split into smaller group to work on specific topics:

Pyodide, Emscripten Forge, PyScript, and more generally Python in the browser. This lead to discussions about making WebAssembly a first-class platform for the Python ecosystem, as per https://discuss.python.org/t/make-wasm-a-1st-class-platform-in-the-python-ecosystem/21798
A proof of concept for using the Language Server Protocol in JupyterLite was also presented, showcasing its potential for improving developer productivity: https://github.com/jupyterlite/jupyterlite-lsp
A presentation about Capytale and Basthon and the use of Python in the browser in the French high school system, deployed for 5000+ schools and with more than 200,000 active users per month.
Integrating JupyterLite and Pyodide in thebe, for producing interactive documents in arbitrary websites.
Another topic of work was about using the latest real-time collaboration (RTC) improvements developed upstream in JupyterLab. Enabling RTC on a static JupyterLite website will make it an even more powerful tool for remote teams and online education.

Resources

You can find the detailed notes and relevant links taken during the workshop:

JupyterLite GitHub discussion: https://github.com/jupyterlite/jupyterlite/discussions/920
Jupyter Discourse topic: https://discourse.jupyter.org/t/jupyterlite-community-workshop-2022-paris-report/17255

Acknowledgments

Overall, the JupyterLite Community Workshop provided a valuable opportunity for the community to come together and share their knowledge, ideas, and experiences.

We are really grateful to Bloomberg and Amazon Web Services for their donations to the Jupyter Community Workshops program. This event would not have been possible without their generous support.

We are also grateful to OVHcloud for hosting this workshop, and for their continued support to the Jupyter project and the NumFOCUS foundation.

Jupyter Everywhere

2022-03-15T15:22:00+00:00

Easily embed a console, a notebook, or a fully-fledged IDE on any web page.

In a previous blog post, we announced JupyterLite, a JupyterLab distribution that runs entirely in the web browser, backed by in-browser language kernels.

By default, JupyterLite ships with a Python kernel powered by Pyodide and IPython, bringing a wide variety of features from code completion to interactive visualizations.

The latest releases of JupyterLite now ship with a REPL application by default, that you can embed in any website.

Embed a live Python console on your website 🚀

Do you want to add an interactive code console to your website, so your visitors can run Python code directly in their browser without installing anything?

Let’s say you already have a static website up and running. This could for example be a Jekyll blog. With the JupyterLite REPL, you can embed the interactive console in your website with something as simple as the following code snippet:

<iframe
  src="https://jupyterlite.github.io/demo/repl/index.html?kernel=python&toolbar=1"
  width="100%"
  height="500px"
>
</iframe>

And there you have it, a live Python REPL embedded in your blog! 🎉

An example of embedding a live Python console in a Jekyll blog.

This example relies on the publicly available demo website deployed to GitHub Pages. However we recommend setting up your own JupyterLite deployment, so you can have full control and use custom configuration and extensions (see the Deploying your JupyterLite website section below).

Powering the NumPy documentation 🐍

The NumPy project had already been using an interactive console on the numpy.org documentation website. The previous console was powered by Thebe and mybinder.org. While this gave great flexibility and a way for users to try NumPy without installing anything on their machine, it required starting a new Jupyter Server on Binder for each user, and then waiting for a kernel to start before being able to type some code.

This setup worked for a while but started to become more difficult to maintain and operate.

With the JupyterLite-powered Python REPL, numpy.org is now able to provide an interactive code console and let anyone try NumPy in their browsers. This considerably reduces the number of resources needed and allows for a smoother and snappier user experience.

The JupyterLite REPL on numpy.org

The REPL is currently based on the JupyterLab Code Console, which gives a familiar “look and feel” to Jupyter users. Other user interfaces such as a Single Executable Cell are also being considered for the next version of the REPL.

Try Jupyter 🟠

Another recent adopter of the JupyterLite stack is the official Jupyter website.

try.jupyter.org has been using the public-facing mybinder.org deployment to let users try the different Jupyter subprojects, such as Voilà and the Xeus-based kernels.

This setup has been working nicely for many years. However, the Binder project recently faced funding issues, which drastically reduced the overall capacity of the Binder federation. This means fewer resources are available to users for their projects, and this also impacted the Try Jupyter website.

To mitigate this, we decided to create a custom JupyterLite website and use it for some of the demos on Try Jupyter. Users can then continue to try some of the Jupyter interfaces in their browsers without installing anything on their machines. As a result, the JupyterLab and Jupyter Notebook demos now point to the new JupyterLite deployment.

Launching JupyterLite from try.jupyter.org

The “Try Jupyter with JupyterLite” deployment also includes the jupyterlab-tour extension, offering a user-friendly tour of the Jupyter interface to newcomers.

Deploying your JupyterLite website 💡

Contrary to a regular Jupyter deployment, JupyterLite can be served as a simple static website without running a Python server. This makes it simpler to deploy, and cheaper to operate.

Below are some examples for deploying your own JupyterLite and Python REPL.

Deploy to GitHub Pages

GitHub Pages is one of the simplest ways to host a JupyterLite website.

This is what the demo repository available at https://github.com/jupyterlite/demo does by default. It lets you bootstrap your JupyterLite website with a few clicks, and deploy it to GitHub Pages within a couple of minutes.

Creating a JupyterLite website with just a couple of clicks

After a few minutes, your website will be ready and you can then embed your live Python console with the following snippet:

<iframe
  src="https://yourhandle.github.io/my-custom-deployment/repl/index.html?kernel=python&toolbar=1"
  width="100%"
  height="500px"
>
</iframe>

The JupyterLite REPL running on GitHub Pages

Deploy to Vercel or Netlify

Hosted platforms like Vercel and Netlify are good options to deploy a static JupyterLite website.

The REPLite project is an example deployed to Vercel, based on the following repository with some custom configuration: https://github.com/jtpio/replite

The Python REPL can be embedded with an IFrame:

<iframe src="https://replite.vercel.app/repl?kernel=python&toolbar=1" width="100%" height="100%">
</iframe>

Here we use the ?kernel=python URL parameter to automatically choose the Python kernel on startup.

Deploying to ReadTheDocs using the Sphinx extension

Going the extra mile, jupyterlite-sphinx brings the power of JupyterLite to your Sphinx documentation. It automatically creates a JupyterLite deployment in your documentation website and provides some utilities for using that deployment easily.

If you are developing software, it’s a very convenient tool to let your users test your library directly on the documentation page!

This is also really useful for Jupyter users who want to easily share their work on readthedocs.org, GitHub Pages, or any other host that supports Sphinx documentation.

Installation

You can install jupyterlite-sphinx with pip:

pip install jupyterlite-sphinx

Then add the extension to your conf.py file:

extensions = [
    'jupyterlite_sphinx',
    # And other sphinx extensions
    # ...
]

And that’s it! jupyterlite-sphinx will automatically deploy a JupyterLite website when building your docs with Sphinx.

Usage

jupyterlite-sphinx provides multiple Sphinx directives for embedding Python consoles and custom Notebooks in your documentation:

To embed a Python REPL similar to the NumPy.org one:

.. replite::
   :kernel: python
   :theme: JupyterLab Light
   :width: 100%
   :height: 600px

    print('Hello from a JupyterLite console!')

Embedding the JupyterLite REPL

To embed a full Notebook:

.. retrolite:: my_notebook.ipynb

An interactive Jupyter Notebook on the ipycanvas documentation

Finally, you might also want to embed the full JupyterLite UI:

.. jupyterlite::

Note that the notebooks are saved in the browser local storage, so any work done on those Notebooks can be retrieved later when coming back to the web page with the same browser.

Documentation

You can find the jupyterlite-sphinx documentation with live examples following this link:

jupyterlite-sphinx — JupyterLite sphinx extension documentation

Example

You can find an example of jupyterlite-sphinx being used on ReadTheDocs here:

ipycanvas: Interactive Canvas in Jupyter — ipycanvas documentation

More examples

JupyterLite can be deployed on more platforms than just the ones mentioned above. Pretty much anything that can serve static files should work!

Feel free to check out the documentation to learn more about deploying your JupyterLite website on other platforms: https://jupyterlite.readthedocs.io/en/latest/deploying.html#hosted

Jupyter Everywhere 🌐

With JupyterLite gaining rapid adoption on widely visited websites such as numpy.org and try.jupyter.org, we envision Jupyter being adopted on more websites and documentation over the next months.

We hope to bring interactive computing with Jupyter to even more people than before and make it more accessible by lowering the barrier of entry.

Because JupyterLite can easily be extended with JupyterLab extensions, we also expect more Jupyter-based deployments and applications to flourish, making good reuse of the existing components that constitute the vibrant Jupyter ecosystem 🌸

Jupyter is language agnostic and more kernels are now available in JupyterLite, for example for Lua and SQLite based on the Xeus framework. Soon Jupyter will also power the documentation and websites of other languages, not just Python.

About the authors

Martin Renou is a Scientific Software Engineer at QuantStack and a Jupyter Distinguished Contributor. Martin works on a variety of projects, from xtensor and xeus-python in C++ to ipywidgets, ipyleaflet and bqplot in Python and TypeScript.

Jeremy Tuloup is a Scientific Software Engineer at QuantStack and a Jupyter Distinguished Contributor. Maintainer and contributor of JupyterLab, Jupyter Notebook, JupyterLite, Voilà, and projects within the Jupyter ecosystem.

JupyterLite: Jupyter ❤️ WebAssembly ❤️ Python

2021-07-13T09:11:00+00:00

JupyterLite is a JupyterLab distribution that runs entirely in the web browser, backed by in-browser language kernels.

Motivation

JupyterLite is a reboot of several attempts at making a full static Jupyter distribution that runs in the browser, without having to start the Python Jupyter Server on the host machine, usually done by running jupyter lab or jupyter notebook in a terminal.

The goal of the project is to provide a lightweight computing environment accessible in a matter of seconds with a single click, in a web browser, and without having to install anything on the end-user device.

With in-browser distributions, there is no need to provision the execution environment in the backend. Since the application is mostly a set of static files, it scales more easily, and it is also easier to deploy.

JupyterLite running in the browser as a static website on ReadTheDocs

A full JupyterLab distribution running in the browser

JupyterLite is built from the ground up, reusing many JupyterLab plugins and components as is.

In addition to JupyterLab, JupyterLite also includes the RetroLab interface by default:

JupyterLite with the RetroLab interface

By reusing JupyterLab components, JupyterLite benefits from many of the upstream improvements such as new features, accessibility fixes, and upkeep improvements. The recent work on real time collaboration coming in JupyterLab 3.1 and championed by Kevin Jahns, Carlos Herrero, and Eric Charles can be enabled in JupyterLite too!

Real Time Collaboration with JupyterLite on ReadTheDocs

Pyolite, a Python kernel backed by Pyodide

Pyodide consists of the CPython 3.8 interpreter compiled to WebAssembly which allows Python to run in the browser. Many popular scientific Python packages have also been compiled and made available. In addition, Pyodide can install any Python package with a pure Python wheel from the Python Package Index (PyPI). Pyodide also includes a comprehensive foreign function interface that exposes the ecosystem of Python packages to JavaScript and the browser user interface, including the DOM, to Python.

Pyodide: Python with the scientific stack, compiled to WebAssembly

Currently at version 0.17, Pyodide has benefited from many improvements over the past years: smaller binary size, support for asyncio, and better type translations between Python and JavaScript.

JupyterLite ships by default with Pyolite, a Python kernel backed by Pyodide. Pyolite runs in a Web Worker and thus doesn’t block the main UI thread when intensive computations are executed.

IPython in the browser

Thanks to the work by Madhur Tandon in this pull request, Pyolite is now powered by IPython. This provides access to magics, code completion, rich display, interactive widgets, and many other features.

Using IPython in JupyterLite

Interactive Visualization

Many visualizations libraries such as Altair and Plotly are also supported in JupyterLite, allowing for quick and convenient figures and plots right in the browser:

Using Altair in JupyterLite

Creating Plotly figures in JupyterLite

Support for Jupyter Widgets

Jupyter Widgets rely on the Custom Messages specification of the Jupyter Protocol to send messages back and forth between the kernel and the frontend. This pull request by Martin Renou added support for Comms in the Pyolite kernel, which enabled many of the existing core and third-party Jupyter Widgets to work out of the box in JupyterLite such as bqplot, ipyleaflet and ipycanvas.

JupyterLite comes with support for Jupyter Widgets

More than just Python

JupyterLite makes it possible to have plenty of other kernels also running in the browser. For now, the default distribution includes a JavaScript and a p5 kernel:

Multiple kernels are available in JupyterLite

Both the JavaScript and the p5 kernels run in an IFrame as the code execution sandbox. With the Jupyter display protocol, users can easily render custom animations in the browser:

The p5.js kernel in JupyterLite

Highly Customizable

Just like many existing Jupyter tools, JupyterLite can easily be configured for custom needs.

It supports the new JupyterLab prebuilt extension system added to the 3.0 release. Existing JupyterLab extensions can then easily be reused in JupyterLite too!

The JupyterLab Drawio extension running in JupyterLite

The in-browser server part of JupyterLite also follows a plugin-based approach. The server is a Lumino application without a shell and registers multiple plugins such as kernels, the contents manager or the sessions service. This plugin-based approach makes it very convenient for deployers and site administrators to swap a plugin for another one. For instance, they might want to swap the default contents manager that stores notebooks and files in the browser local storage with another plugin that would save them on AWS S3 instead.

Overview of the plugin-based architecture of JupyterLite

The modularity and flexibility of JupyterLite make it possible to easily add new kernels. For example, the Basthon kernel uses a slightly different execution model than Pyolite. It runs in the main UI thread so users can manipulate the main window DOM from within Python directly, while Pyolite runs in a Web Worker as a background thread. Both approaches have pros and cons, and the JupyterLite plugin system lets extension authors have full control over their kernels.

A prototype for running Basthon in JupyterLite is being developed in the following repository: https://framagit.org/casatir/basthon-jupyterlab/

Basthon in JupyterLite

Deploying JupyterLite

JupyterLite can easily be deployed as a static website. That’s it, no server, no complicated setup, no scalability issue. Just a plain HTTP server to serve static files to users.

This simple approach makes it possible to use a variety of options: nginx, Binder, GitHub Pages or GitLab Pages, Vercel, Netlify, and more. It can even be deployed to ReadTheDocs, which is where the default JupyterLite demo site is hosted and continuously updated.

Many of the deployment scenarios are already documented in https://jupyterlite.readthedocs.io/en/latest/deploying.html. There is also a demo template to easily deploy a custom JupyterLite website on GitHub Pages with a single click: https://github.com/jupyterlite/demo

Thanks to the work by Nicholas Bollweg in this pull request, JupyterLite now offers a jupyterlite command line tool to make custom deployments much more convenient.

One of the goals of JupyterLite is to let anyone build their custom distribution with the set of plugins and extensions they would like to use. For now, it requires using the jupyterlite CLI, but we can imagine having a more user-friendly way of exporting a custom JupyterLite website.

A mock-up for the JupyterLite Exporter

A wide range of use cases

With the ease of deployment and the low barrier to entry, JupyterLite is an excellent fit for a wide range of use cases.

In the educational space, it simplifies access to teaching materials and computing environments. Teachers and students can focus on the content of their classes without worrying about server deployments and monitoring.

With JupyterLite we also hope to enable the next wave of Jupyter users and make the whole ecosystem even more accessible to newcomers and the wider community.

For simpler and smaller-scale projects, it could even help reduce the load on mybinder.org by having a “binderlite” version of JupyterLite deployed on a CDN.

Try it online

JupyterLite can easily be tested in a web browser using the following link:

https://jupyterlite.github.io/demo

Try it locally

JupyterLite can also be used locally. First, install the CLI package with:

pip install --pre jupyterlite

Then, to build the JupyterLite website and serve it locally:

jupyter lite init
jupyter lite build
jupyter lite serve

Check out the documentation for more information about the jupyterlite command-line tool: https://jupyterlite.readthedocs.io/en/latest/developer-guide.html

Next steps

JupyterLite is still under active development, with a lot of improvements planned for the next iterations:

Improve tooling for authoring custom in-browser kernels, reusing the JupyterLab federated (prebuilt) extension system.
Improve the package management story in Pyodide with mamba and the conda-forge infrastructure.
Reuse the JupyterLite packages in other lab-based applications such as Voilà, Gator, and the Quetz Frontend.
Provide more user-friendly tools to easily export a custom JupyterLite distribution.

Getting involved

JupyterLite is under active development happening in:

the main repository: https://github.com/jupyterlite/jupyterlite
satellite repositories (kernels, demos) in the GitHub organization: https://github.com/jupyterlite

About the Author

Jeremy Tuloup is a Scientific Software Developer at QuantStack and a Jupyter Distinguished Contributor. Maintainer and contributor of JupyterLab, Voilà, and many projects within the Jupyter ecosystem.

Acknowledgments

We would like to acknowledge the previous work and the contributors who have worked on exploring the idea of Python in the notebook before us: Jyve, the Iodide notebook, Basthon, and the p5 notebook. It is also worth mentioning that similar projects exist outside of the Jupyter ecosystem, such as Observable and the Starboard Notebook.

We are grateful to Nicholas Bollweg, Madhur Tandon, Martin Renou for their contributions to JupyterLite, to Roman Yurchak and team for the work on Pyodide, Romain Casati for developing the Basthon kernel.

The work on JupyterLite by Jeremy Tuloup, Madhur Tandon, and Martin Renou was funded by QuantStack.

RetroLab — A JupyterLab distribution with a retro look and feel

2021-05-27T11:31:00+00:00

RetroLab is an alternative JupyterLab distribution, built from the ground-up, providing a notebook interface with a retro look and feel.

RetroLab in action

Motivation

Currently at version 3.0, JupyterLab provides an advanced computational environment that can be compared to traditional IDEs and text editors like VS Code and PyCharm.

However in some cases, having a leaner, simpler, and more focused interface to work on a notebook is really useful. For example when presenting an analysis to colleagues over a video call. Or teaching a topic and make sure the audience focuses on the content of the notebook.

The goal of the RetroLab project is to offer an interface with a retro look and feel, similar to the Classic Notebook, while leveraging the efforts put in the development of JupyterLab itself and its extension system.

Technically speaking RetroLab remixes many of the existing plugins for JupyterLab (notebook, toolbar, terminals) and reassembles them in a different way. It also supports prebuilt third-party extensions using the new distribution system added in JupyterLab 3.0. That way, many extensions built for JupyterLab will also be compatible with RetroLab.

JupyterLab itself is also built as a set of extensions and plugins. The JupyterLab extension system makes it very convenient to create new distributions from a subset of plugins.

Let’s have a look at some of features available in RetroLab.

Notebooks, Files and Terminal

RetroLab supports Notebooks, Files and Terminals.

Notebooks can be created using the File Browser, the menu items and the command palette.

Working in a notebook with RetroLab

The File Browser provides convenient buttons to quickly create new notebooks, files and terminals.

Creating a new Terminal

Long time users of the Classic Notebook will already have noticed that activities are opened in new browser tabs by default. This provides an alternative way to manage workflows. Users who prefer to manage everything within a single browser tab might want to stick to the JupyterLab default interface.

Open in a new Browser Tab by default

Zen Mode

RetroLab also offers a zen mode to quickly switch to full screen and hide the top area. Very useful to focus on a single notebook, and also during presentations or screen sharing sessions!

Zen Mode

Support for existing JupyterLab prebuilt extensions

One of the main features in JupyterLab 3.0 is the new extension distribution system, which makes it possible to distribute extensions as prebuilt extensions. Prebuilt extensions do not require users to rebuild JupyterLab or have Node.js installed.

Since prebuilt extensions are loaded dynamically, they can also be leveraged in RetroLab without any extra step!

Installing a new JupyterLab extension and using it in RetroLab

Note to developers: most of the time your extension will be compatible with RetroLab without changing anything. However it is good practice to think about the different types of JupyterLab distributions when developing the extension. For example some services and shell areas are not available in RetroLab: no left, right and bottom area, the main area supports adding only one widget…

Command Palette

RetroLab includes a command palette, just like in JupyterLab.

Hit Ctrl-Shift-C or Accel-Shift-C to activate it. Or via the menu with View > Activate Command Palette.

Using the command palette to restart the kernel

Themes

RetroLab also supports Dark Mode! 🕶️

In fact, it supports any other themes distributed as prebuilt extensions for JupyterLab 3.0.

Switching between the light and dark built-in themes

For an even more retro look, you might want to start retrolab with the --retro-logo flag:

jupyter retro --retro-logo

The RetroLab logo with the JupyterLab Miami Nights Theme

Compact View on Mobile Devices

RetroLab automatically switches to a more compact layout on mobile devices, making it convenient to run code on the go.

Compact layout by default on mobile devices

Next-gen JupyterLab features

Since RetroLab reuses many components from JupyterLab as-is, it automatically inherits many of the improvements and cool new features being developed upstream.

With the latest prerelease for RetroLab, folks can collaborate using RetroLab, JupyterLab or even JupyterLab in Simple Mode.

Real Time Collaboration with RetroLab and JupyterLab

Installation

To install RetroLab with pip:

pip install retrolab

With mamba:

mamba install -c conda-forge retrolab

With conda:

conda install -c conda-forge retrolab

To try the prerelease with support for real time collaboration:

pip install --pre retrolab

Development is happening is the following repository: https://github.com/jupyterlab/retrolab

Feedback, issues and pull requests are welcome!

Try it out on Binder

It is also possible to try RetroLab on Binder using the following link:

Next Steps

With RetroLab, we hope to inspire the development of distributions and applications built using JupyterLab components.

A couple of other initiatives have already started:

Gator: https://github.com/mamba-org/gator
Quetz Frontend: https://github.com/mamba-org/quetz-frontend

There are also plans to create a cookiecutter that can serve as a template to quickly bootstrap new lab-based projects from scratch.

Prior Art

This project is mostly a reboot of the two previous attempts at making something similar:

These projects really expressed the need for a stripped down, minimal version of the Jupyter Notebook UI, and were a huge source of inspiration for RetroLab. Many thanks to the contributors!

About the author

JupyterLab 3.0 is released!

2021-01-05T08:28:00+00:00

The 3.0 release of JupyterLab brings many new features to users and substantial improvements to the extension system.

Installation

To install JupyterLab with pip:

pip install jupyterlab==3

With mamba:

mamba install -c conda-forge jupyterlab=3

With conda:

conda install -c conda-forge jupyterlab=3

(Note that many third-party extensions are still in the process of updating to be compatible with JupyterLab 3.0 — please check the extensions you use and be patient, or even better, help them update! Also, it may help to uninstall JupyterLab 2 if you already have it installed.)

Here is an overview of the major user-facing changes in JupyterLab 3.0.

Debugger

Announced earlier this year, the visual debugger is now shipped by default with JupyterLab.

To use the visual debugger, you will need a kernel that supports debugging. An example of such kernel is xeus-python, the first Jupyter Kernel for Python with support for debugging.

Stepping into Python code in JupyterLab with the visual debugger

Check out the user documentation for more information, including a notebook based tutorial to interactively learn how to use the debugger.

The table of contents extension now ships with JupyterLab. This makes it easy to see and navigate the structure of a document.

Using the Table of Content in JupyterLab 3.0

Support for multiple display languages

JupyterLab now provides the ability to set the display language of the user interface.

Users will need to install the language pack as a separate Python package. Language packs are grouped in the language packs repository on GitHub, and can be installed with pip. For example, it is possible to install the language pack for Simplified Chinese using the following command:

pip install jupyterlab-language-pack-zh-CN

JupyterLab in Simplified Chinese

Check out the user documentation to learn more about the feature and how to add new language packs.

Improvements to the Simple Interface mode

The Simple Interface mode (previously known as the Single-Document Mode) has been significantly updated to have a more streamlined, document-oriented feel.

To make the Simple Interface mode more discoverable, there is now a switch to toggle it in the status bar. You can also toggle it from the View menu or the command palette, or use the default keyboard shortcut Ctrl/Cmd+Shift+D.

Enabling and disabling the Simple Interface Mode

Support for mobile has also greatly improved with a more compact layout. JupyterLab automatically switches to the Simple Interface when the window is resized down.

JupyterLab switches to the Simple Interface Mode on smaller screen

There is ongoing work to iterate on this concept and make the interface even more accessible on mobile devices.

Install new extensions with pip and conda / mamba

JupyterLab extensions can now be distributed as prebuilt extensions, which do not require a user to rebuild JupyterLab or have Node.js installed. Prebuilt extensions can be distributed as Python packages using familiar package managers such as pip, conda, and mamba. This makes installing and using extensions much faster and more convenient!

Installing a new extension with pip

Prebuilt extensions can be published to PyPI and conda-forge as separate packages, or bundled into existing packages with Jupyter Server extensions and Classic Notebook extensions. This helps make the ecosystem as a whole more coherent.

For example, install the new ipywidgets 7.6.0 with pip or conda to automatically enable ipywidgets in both the classic Jupyter Notebook and in JupyterLab 3.0 — no extra installation step or JupyterLab rebuild needed!

Installing ipywidgets works automagically in JupyterLab 3.0!

Improved development workflow for Extension Authors

The new prebuilt extensions are more convenient for extension authors to develop. The TypeScript extension cookiecutter has been updated to develop prebuilt extensions by default and provides all the necessary tooling to quickly create a new extension from scratch.

For more information, check out the Extension Developer Guide and the JupyterLab 2.x to 3.x Migration Guide.

Extension Examples

If you are looking for examples to learn how to make your own extension, make sure to check out the extension examples repository on GitHub. The examples have been updated to be compatible with JupyterLab 3.0 and provide a hands-on approach to developing extensions.

Changelog

This post was only an overview of what’s new in 3.0! If you are looking for a more complete list of the changes including bug fixes, be sure to have a look at the changelog.

Try it out on Binder

JupyterLab 3.0 can easily be tested on Binder using the following link:

Get Involved

There are many ways you can participate in the JupyterLab effort. We welcome contributions from all members of the Jupyter community:

Make your own JupyterLab extensions. Please add the jupyterlab-extension topic if your extension is hosted on GitHub. You can also help existing extensions update to JupyterLab 3.0. The changelog gives an overview of changes that may affect extension maintainers.
Contribute to the development, documentation, and design of JupyterLab on GitHub. To get started with development, please see the Contributing Guide and Code of Conduct. Many issues are ideal for new contributors and are tagged as “good first issue” or “help wanted”.
Connect with the community on GitHub or on the Gitter Channel. If you find a bug, have questions, or want to provide feedback, please join the conversation!

And don’t forget to participate in the user survey: https://www.surveymonkey.com/r/LCB7GBF

Thanks!

Plasma: A learning platform powered by Jupyter

2020-05-11T07:55:00+00:00

Jupyter has been a great choice for education for many years. The Jupyter Notebook has become one of the most popular tools to conduct workshops, tutorials, and teach online classes.

Recently we have seen the emergence and adoption of JupyterHub distributions to facilitate the deployment of Jupyter-based platforms, both on private servers and in the cloud.

We would like to share with you an open-source learning platform called Plasma, built with Jupyter at its core.

JupyterHub Distributions

JupyterHub is a highly customizable and modular framework. To simplify its adoption, JupyterHub distributions target specific deployment scenarios with opinionated defaults. They make it easier to deploy JupyterHub on a single server and in the cloud.

There are currently two popular JupyterHub distributions:

The Littlest JupyterHub (TLJH): for running JupyterHub on a single machine, targeting between 1 and 100 users
Zero To JupyterHub on Kubernetes (ZTJH): for running JupyterHub on top of Kubernetes, to scale to a large number of users and machines

Although not an official distribution, jupyterhub-deploy-docker is also a good resource for a full Docker-based setup. It runs JupyterHub itself in a Docker container and orchestrates the stack with Docker Compose.

The Plasma Stack

Plasma stands for PLateforme d’e-Learning pour l’Analyse de données Scientifiques MAssives, which can be translated to “An e-learning platform for massive scientific data analysis”.

The platform is typically meant to be deployed on high-end machines with multiple cores and GB of RAM.

Some of the requirements for the Plasma project fall somewhere between the TLJH and ZTJH distributions:

The deployment should be on a single server, and reproducible on other machines too (running on Ubuntu 18.04+)
It should support multiple user environments with different sets of dependencies
Users should authenticate as system users and their data should be persisted in their home directories on the host machine

Although TLJH doesn’t officially support container technology, its plugin system opens the door to many other use cases.

Because of this and to foster the TLJH plugin ecosystem, we decided to develop the Plasma stack as a plugin for TLJH and consolidate the deployment story with Ansible playbooks.

Plasma is an opinionated JupyterHub stack powered by The Littlest JupyterHub, with the following defaults:

PAMAuthenticator to authenticate JupyterHub as users existing on the host machine
SystemUserSpawner to start single-user servers in Docker containers, using the system user home directories for data persistence

To enable extra functionalities, the Plasma stack relies on:

The tljh-repo2docker plugin to create multiple user environments
The tljh-plasma plugin to define the JupyterHub config
Ansible playbooks to automate the deployment and configuration of the server and add additional tools

The Plasma stack also contains tools to monitor the system, create and configure users, and add hub admins. It can be visualized with the diagram below:

The Plasma Overview Diagram

The stack is defined in the following repository: https://github.com/plasmabio/plasma

There is also extensive documentation with detailed explanations on how to deploy the stack on a new server: https://docs.plasmabio.org

A repo2docker plugin for The Littlest JupyterHub

The tljh-repo2docker plugin lets JupyterHub admins create new user environments using repo2docker. This plugin starts a JupyterHub service to manage user environments from the JupyterHub UI.

For those already using Binder, the idea will sound very familiar. Under the hood, the tljh-repo2docker plugin also uses repo2docker to build the Docker images. It follows the same patterns and naming conventions as Binder, which makes it easier and more natural to test the environments on Binder before adding them to JupyterHub.

New environments can be added by clicking on the Add New button and providing a URL to the repository. Optional names, memory, and CPU limits can also be set for the environment:

Adding a new environment

The Environments page shows the list of built environments, as well as the ones currently being built:

Building a new environment

The status of the environment changes once the underlying Docker image has been built:

The list of available user environments

Once ready, the environments can be selected from the JupyterHub spawn page:

Selecting an environment

Because it is separate from the Plasma stack, this plugin can also be used for other temporary TLJH deployments on a virtual machine. For example, the organizer of a workshop can prepare a list of environments before the event, just like they would with Binder.

Automating deployments with Ansible

To minimize the number of manual steps involved in the setup of the stack, Plasma also provides a list of Ansible playbooks.

Ansible is an open-source tool to automate the provisioning of servers, configuration management, and application deployment.

Playbooks define a list of tasks that should be executed and declare the desired state of the server.

The list of playbooks and instructions on how to use them are provided in the Installation section of the documentation.

Overall, the playbooks make it easier to perform upgrades, to automate the deployment process, and to replicate the setup at other institutions and universities.

Here is an example of what an upgrade looks like:

Upgrading the stack with an Ansible playbook

This playbook defines the tasks to:

download the TLJH installer
execute the TLJH installer to perform the upgrade
update the TLJH plugins
set the idle culler timeout
set the default memory and CPU limits
reload JupyterHub
pulls the latest jupyter/repo2docker Docker image

Acknowledgements

The development of the Plasma stack at QuantStack was funded as part of the Plasma project, led by Claire Vandiedonck, Pierre Poulain, and Sandrine Caburet, associate professors at Université de Paris.

Sponsors to the Plasma initiative include:

Région Île-de-France, via the “Trophées franciliens de l’innovation numérique dans le supérieur” (EdTech 2018) grant program,
Université de Paris, via the Initiative of Excellence (IdEx) Label and its “inovating teaching” grant program,
EUR G.E.N.E., the graduate school on Genetics and Epigenetics,
the university training “Création, analyse et valorisation de données biologiques omiques” (DU Omiques).

A Gallery of Voilà Examples

2019-07-09T10:53:00+00:00

Voilà is one of the latest addition to the Jupyter ecosystem and can be used to turn notebooks into standalone applications and dashboards.

Today we are pleased to introduce the Voilà Gallery, a collection of examples built with Voilà.

The Voilà Gallery

The Voilà Gallery is a collection of live dashboards built with Voilà and Jupyter widgets.

The goal of the gallery is to provide inspiration to Jupyter users who want to convert their notebooks into web applications. Most of the examples rely on widget libraries such as ipywidgets, ipyleaflet, ipyvolume, bqplot and ipympl, and showcase how to build complex web applications entirely based on notebooks.

The landing page of the gallery lists all the available examples. Each entry contains can be used to launch the example and includes a button to view the source.

The Voilà Gallery landing page

Launch Example will bring you to the interactive application. Under the hood, a notebook server running voila and a live kernel are started.

GPX Viewer is an application built with Voilà

View Source will let you have a look at the source notebook used to create the example. This is useful to learn more about the inner workings of each dashboard.

Adding your own example

The source for the public gallery is available on GitHub: https://github.com/voila-gallery/voila-gallery.github.io

All the examples shown in the gallery come from the gallery.yaml file, which is automatically rendered on the landing page at voila-gallery.org.

You can contribute a new example to the gallery by following these steps, which consist in adding a new entry to the gallery.yaml file and opening a new pull request. The gallery will pick up the new example shortly after it has been added.

The voila-gallery organization on GitHub already contains a few examples that you can use as a starting point.

Deploying your own gallery

The gallery can also be deployed as a plugin for The Littlest JupyterHub (TLJH), which is a JupyterHub distribution meant to be used on a single server.

The plugin makes use of the JupyterHub REST API to create a new JupyterHub service and to launch the examples.

You can actually deploy your own gallery by following the instructions in the README. Within a few minutes, you will have a Voilà gallery running on your own server. You could even run it on a private instance.

What’s next?

We are still iterating on the content of the gallery to add some variety to the types of application that can be created using widgets, Jupyter notebooks and Voilà.

If you have authored an interesting dashboard and would like to share it with the rest of the world, feel free to open a pull request to add it to the list of examples!

Acknowledgments

We are very grateful to OVH for hosting the Voilà Gallery on their servers.

Thanks to Yuvi Panda and Pascal Bugnion for initially starting the Voilà Gallery project, and QuantStack for kindly sponsoring the development.

The development of Voilà at QuantStack is funded by Bloomberg.

Jupyter Blog - Jeremy Tuloup

JupyterLite 0.8 is released! 🎉

Sharing a REPL

Refreshed Loading Screen

File System Reliability Improvements

JupyterLab 4.6 and Notebook 7.6

A Terminal in the Browser

More Kernels with jupyterlite-xeus

Python 3.14 with the Pyodide Kernel

JavaScript Kernel Improvements

Try it in your browser

Acknowledgments

JupyterLite 0.7 is released! 🎉

Workspace Support

Audio and Video Playback

Basic Interrupt Functionality

Basic Notebook Export

File Menu Download Option

Enhanced Markdown Support

JupyterLab 4.5 and Notebook 7.5

Walkthrough video

Try it in your browser

Acknowledgments

JupyterLab 4.5 and Notebook 7.5 are available!

Performance and windowing

Notebook improvements

Debugger and Console improvements

New search functionality inside terminals

Media and content support

File browser enhancements

Keyboard shortcuts and commands

Settings

User interface and accessibility

Update from JupyterCon

Acknowledgements

JupyterLite 0.6.0 is released! 🎉

Interactive Input Support

New REPL Options

Kernel Indicator and Logs

Clear Browser Data

Loading indicator

Settings import and export

Plugin Manager

Improved Multi-site Contents Management

Multi-Tab File System Access

Extension system

JupyterLab 4.4 and Notebook 7.4

Kernel and other updates

Closing the gap with JupyterLab

Using in-browser and regular kernels together

Migrating to 0.6.0

Walkthrough video

Try it in your browser

Acknowledgments

JupyterLab 4.4 and Notebook 7.4 are available!

Code console improvements

Settings import and export

Workspace indicator

Support for collaboration without RTC: drive

Kernel subshells support

Context menu opt-out

Slimmer status bar

Walkthrough video

Acknowledgements

JupyterLab 4.3 and Notebook 7.3 are available!

Minimap

Fullscreen mode

File browser enhancements

Server-side execution and collaboration

Improved kernel and server interactions

Full Width Notebook

JupyterLab 3 end of maintenance

Acknowledgements

Automate your releases with the Jupyter Releaser 🚀

😔 The Problem: Manual Release Processes

🤩 The Solution: Jupyter Releaser

➡️ Getting Started with Jupyter Releaser

Step 0: Set up

Step 1: Prep Release

Step 2: Publish Release

Support for collaboration without `RTC:` drive