Jupyter Blog - releases

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 💛

JupyterLab 4.6 and Notebook 7.6 are out!

2026-07-02T16:13:00+00:00

JupyterLab 4.6 features new interface customization options, improved file browser and debugger, an easy way to jump between recently edited cells, and numerous other notebook experience improvements. Keyboard shortcuts, navigation and accessibility is another focus area in this release. Jupyter Notebook 7.6 has also been released, including the fixes and enhancements of JupyterLab along with a new Scratchpad console and other Notebook-specific improvements. This article highlights notable changes in both applications.

You can try out the changes in your browser: JupyterLab 4.6, Notebook 7.6
At the time of publication, the preview runs on JupyterLite 0.8.

Overview of some user interface enhancements visible in JupyterLab UI

Enhancements shared by JupyterLab and Notebook

Notebook improvements

Two new navigation commands, “Select previous last modified cell” and “Select next last modified cell”, allow jumping back and forward through recently edited cells. The commands are accessible from the Command Palette and as buttons in the Table Of Contents toolbar when a notebook is active.

Clicking the highlighted button will jump to a previously edited cell

Copy, cut, and paste text commands have been added to the notebook context menu. This feature requires permission to access clipboard to work reliably and may not work in Firefox depending on version and additional restrictions.

Copy/Cut/Paste Selected cells expose clipboard actions on cell source

The cell toolbar delete button now shows a confirmation dialog to prevent accidental deletion. The “Do not ask me again” checkbox is available and the preference is persisted in Cell Toolbar settings. The standard keyboard shortcut (D, D) is unaffected.

Dialog shown when deleting a cell from cell tollbar

Pressing Ctrl + B (Cmd + B on macOS) in a markdown cell wraps the selected text in bold formatting.

When exporting a notebook as HTML via File → Save and Export Notebook As → HTML, a dialog now asks whether to sanitize the HTML output before download.

File browser: new column, editable breadcrumbs, open in terminal

A new “Date Created” column has been added to the file browser, showing when files were created. The column can be toggled via Settings → File Browser → “Show date created column” or by right-clicking the column header. The latest jupyter-server (v2.18+) is required for accurate values across operating systems.

New date created column in file browser

The breadcrumb bar now supports direct path editing with tab-completion. Clicking the area behind breadcrumbs (highlighted on hover), or using the Command Palette, opens an editable text field where pressing Tab completes the longest common prefix of matching subdirectories.

Editable breadcrumbs

A new “Open in Terminal” option in the file browser context menu opens a terminal navigated to the selected directory. When multiple directories are selected, one terminal is opened per directory.

Opening terminal for a specific directory is now easier.

Additional file browser improvements include: a configurable file name sort order, persistence of the sort state across sessions, automatic clearing of the file filter when changing directories, and a loading animation during file browser refresh.

Debugger: kernel sources filter, floating overlay

The debugger Sources panel has been moved out of the debugger sidebar; the Sources now open as read-only editors in the main area, keeping the sidebar uncluttered while you explore the code state. The previous behavior can be restored by disabling the “Show Sources in Main Area” setting in the Debugger settings.

An overlay with continue/step in/stop buttons has been added easing the control of the debugger steps:

The Kernel Sources filter bar has been moved to the toolbar and now supports live filtering, making it easier to search through kernel source files while debugging.

The refresh button for sources list was removed — the sources will now update automatically after each code execution.

Keyboard navigation has been improved across several components:

The terminal no longer traps keyboard focus, allowing users to move focus away with the keyboard.
The console and file browser breadcrumbs both received keyboard navigation fixes.
Focus is now correctly restored after closing the command palette, and input elements in dialogs opened from the command palette receive focus immediately.
The find-and-replace button focus in the document search box has been corrected.

Screen reader behavior has been improved in the launcher and notebook. Toolbar buttons now correctly reflect their pressed state via the aria-pressed attribute.

The Keyboard Shortcuts settings panel has been updated to improve accessibility, including better keyboard interaction and screen reader announcements within the shortcuts editor dialog.

Focus indicators have been improved across the interface, including the status bar and other interactive components.

Keyboard shortcuts

Shortcuts can now be added from the UI shortcut editor for any command (previously this required writing JSON in Advanced Settings Editor).

“Find and Replace” has been added to the Edit menu with the keyboard shortcut Ctrl + H (Cmd + H on macOS).

Ctrl + Y has been added as a redo shortcut on Windows and Linux.

Pressing 1, 2, 3, 4, 5 and 6 will no longer convert a focused code or raw cell to Markdown to avoid accidental conversions. These shortcuts continue working on markdown cells, switching the heading level, as they did before.

Internationalization

Language packs can now be installed directly from within JupyterLab by selecting “Install more languages…” at the bottom of the Settings → Language menu. This opens the Extension Manager pre-filled with a search for available language pack extensions.

Terminal enhancements

Pressing Shift+Enter in the terminal now inserts a newline without executing the current line. This matches the behavior expected by certain terminal applications.

Inline completion enhancements

Inline completion suggestions can now be rendered with syntax highlighting that matches the active editor language. This can be enabled in Settings → Inline Completer → “Ghost text syntax highlighting”.

Ghost text is now also shown for all active cursors in a multi-cursor editing session.

JupyterLab-specific enhancements

Layout and interface customization

The activity bar can now be positioned at the top or bottom of the interface, in addition to the default left and right placement. The setting is available under Settings → Interface → Activity Bar Position.

Sections of accordion sidebars can now be moved between panels via a context menu. Right-clicking a section header shows a “Move To” menu. The placement and collapsed state of moved sections are persisted across sessions.

The sidebar panels themselves can be moved between areas. Right-clicking a sidebar shows submenu with options to move it to the main area, a different sidebar, or the down area.

Tabs can now be split in four directions using the “Split Tab” context menu item (or the command palette), which adds split left, right, up, and down options.

Individual panels can be zoomed in or out using Ctrl + mouse wheel (when “Enable Ctrl+ Scroll Zoom” is turned on in Settings → Interface) or via the command palette, without affecting other panels.

Performance

Panel resizing is now more responsive; the width of individual widgets inside resized panels is frozen during the drag. This behaviour can be disabled by toggling “Optimize panel resize” in Settings → Application Shell.

Notebook-specific enhancements

Scratchpad console

A scratchpad console can now be opened next to a notebook, sharing the same kernel. This makes it easy to run quick experiments or inspect variables without modifying the notebook itself.

The scratchpad console can be opened from the File -> New -> Scratchpad console menu, from the command palette, or with the Ctrl + B (or Cmd + B on macOS) keyboard shortcut, which toggles the console panel.

Confirmation dialog when closing and shutting down a notebook

The “Close and Shut Down Notebook” command now asks for confirmation before closing the browser tab and shutting down the kernel. The confirmation prompt can be disabled in the Settings Editor with the “Prompt for confirmation before closing and shutting down” setting.

Miscellaneous

Tab widths in JupyterLab are kept frozen while the mouse pointer hovers over them, making it easier to close multiple tabs with the mouse
Autocompletion heuristics were improved; the autocompletion (which remains opt-in) should no longer trigger in unexpected scenarios
The output scroll overlay collapse icon is now visible regardless of the output size and scroll state
The fonts used across components were standardized and fonts specified by themes or overrides are respected in every component of the application

For extension authors

Building extensions (and JupyterLab/Notebook themselves) is now ~5 times faster thanks to migration from webpack to Rspack. Building extensions no longer requires a full JupyterLab installation as the relevant machinery was extracted to jupyter-builder (see this blog post for more details). This (among others) enables faster build environment setup on CI. Future improvements to the build system can now be released independently of the JupyterLab release cadence.

Please refer to the Extension Migration Guide for more details on API changes and up-to-date advice.

As large as minor releases go

This JupyterLab release includes 68 new features and enhancements, 97 bug fixes, and 38 documentation improvements. 95 people contributed to this release. Across record-breaking 171 maintenance tasks we kept the dependencies up-to-date, improved quality of code and reduced the time to PRs getting merged by improving the CI performance and robustness. These efforts were in part funded by Jupyter Foundation Community Proposals.

While the size of minor releases fluctuated across years, this one is on the higher side, with only v3.1 featuring slightly more merged PRs. The reviewers worked hard to ensure no regressions are introduced, but if any slipped through, please open an issue in respective repository (JupyterLab or Notebook).

Acknowledgements

Thank you to all the new contributors, we hope to see you back!

JupyterLab (39): @aarondr77, @Akshitguptaa, @altis0725, @amanparganiha, @anafontan, @autodots-AHassan, @aviu16, @bittoby, @boskodev790, @chenjiahan, @cursoragent, @dhgoal, @DTiming24, @github29tani, @GlassOfWhiskey, @harshaagrawal20, @hroncok, @jayaprajapatii, @JaYRaNa213, @jianyexi, @ktaletsk, @lin9long, @mfisher87, @MMesch, @moktamd, @nightcityblade, @nthiery, @raffaelemancuso, @RamiNoodle733, @reteps, @rodrigosf672, @Siddhazntx, @statxc, @TheChyeahhh, @tsharma-dev, @tubaman, @u-wlkjyy, @Yahiewi, @ZhYGuoL
Notebook (9): @bodhisilberling, @Darshan808, @goelakash, @joaovml, @KH-Coder865, @Mirochill, @xlumzee, @yangsong97, @Yann-P

And thank you to returning contributors for their continued work!

JupyterLab (56): @aaron-seq, @afshin, @agriyakhetarpal, @AliMahmoudDev, @andrii-i, @apoorvdarshan, @arjxn-py, @arun-357, @bollwyvl, @brichet, @Carreau, @ceasermikes002, @cmarmo, @CrafterKolyan, @Darshan808, @davidbrochart, @DeborahOlaboye, @doshi-kevin, @erkin98, @fcollonval, @filipeoliveira05, @flaviomartins, @fleming79, @FoSuCloud, @frenzymadness, @HaudinFlorence, @i-aki-y, @ianhi, @ianthomas23, @IsabelParedes, @itsmejay80, @itsmevichu, @JamesWrigley, @jasongrout, @JasonWeill, @jimangel, @jtpio, @krassowski, @Krish-876, @linlol, @martinRenou, @Meriem-BenIsmail, @MUFFANUJ, @peytondmurray, @prajyot-porje, @pranshugupta01, @RRosio, @schmidi314, @soniya-malviy, @superlevure, @SylvainCorlay, @tmetzl, @utsav-develops, @xc2, @Yann-P, @Zsailer
Notebook (9): @andrii-i, @brichet, @Carreau, @jtpio, @krassowski, @martinRenou, @minrk, @RamiNoodle733, @takluyver

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 and Notebook issues: @RRosio, @krassowski, @andrii-i, @rodrigosf672, @ktaletsk among others who attend.

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 ❤️

JupyterLab 4.2 and Notebook 7.2 are available!

2024-05-22T21:00:00+00:00

JupyterLab 4.2.0 has been released! This new minor release of JupyterLab includes 3 new features, 20 enhancements, 33 bug fixes and 29 maintenance tasks. There were 39 contributors to this release including 10 new contributors to JupyterLab.

Jupyter Notebook 7.2.0 has also been released, including many of the fixes and enhancements in this JupyterLab 4.2.0 release. While the releases on Github provide additional detail on the updates made to both JupyterLab 4.2 and Notebook 7.2, 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.

Easier Workspaces Management with GUI

It is now possible to manage workspaces from within JupyterLab with the workspaces graphical user interface. This long awaited feature offers users an additional way to interact with workspaces beyond the existing URL and CLI-based options, providing a more user-friendly and accessible alternative for some.

JupyterLab 4.2.0 Workspaces UI

Recently opened/closed files

Jupyterlab-recents, an extension for tracking recent files and directories has now been integrated into core JupyterLab. This extension adds a main menu entry for recently opened/closed files. JupyterLab users now have this native functionality that provides a quick reference to files they have recently worked with. Further development work in JupyterLab core now also allows users to search for and access recently closed files and folders through a modal via the shortcut Ctrl + Alt + A.

JupyterLab 4.2.0 Recently Closed Submodal

Full notebook windowing mode by default

The previously available full notebook windowing mode has now been made the default mode. This mode renders only the cells visible in the window, leading to improved performance. With this mode using the JupyterLab search function is recommended due to false negatives with the web browser’s native search functionality.

Improved Shortcuts Editor

Users can enjoy an improved experience when customizing shortcuts. Various improvements have been made to the shortcuts editor, namely: default shortcuts can be deleted, and shortcuts are sorted appropriately when using a language pack. Entries for shortcuts with varying arguments are also now accurately presented as separate items.

Modal option to delete shortcut key binding.

Dark High Contrast Theme

The JupyterLab Dark High Contrast Theme is now available for users who might benefit from higher contrast as outlined by the WCAG AAA accessibility standards for color contrast.

JupyterLab 4.2.0 Dark High Contrast Theme

Keyboard Shortcuts

The shortcuts extension received some improvements based on user feedback. The Ctrl + D shortcut has been restored to allow users to use to delete a line. In the interest of code editor compatibility the Ctrl + Shift + K shortcut can still be used for deleting lines and multi-cursor selection is now available via the default shortcut: Ctrl + Shift + D. Users are now able to toggle line comments with the shortcut Ctrl + / and toggle block comments with Alt + A, both of which are customizable via the Settings Editor. This release also addresses issues related to using various keys on international keyboards in macOS.

Acknowledgements

Thank you to all the new contributors, we hope to see you back!

JupyterLab: @linlol, @erkin98, @mdietz94, @UntitledError-09, @Susilkessav, @Tanmay-Deshmukh, @AnastasiaSliusar, @milinm, @Rob-P-Smith, @NexVeridian.
Notebook: @afeld

And thank you to returning contributors for their continued work!

JupyterLab: @davidbrochart, @fcollonval, @FoSuCloud, @JasonWeill, @jtpio, @krassowski, @Alanhou1222, @divyansshhh, @itsmevichu, @kolibril13, @sawickid, @andrii-i, @bollwyvl, @brichet, @Mehak261124, @e218736, @echarles, @gabalafou, @m158261, @afshin, @minrk, @RRosio, @trungleduc, @blink1073, @diyoyo, @AllanChain, @ericsnekbytes, @HaudinFlorence
Notebook: @jtpio, @krassowski

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 among others who attend.

Contributors to this blog post: @krassowski, @jtpio, @JasonWeill, @RRosio.

JupyterLab 4.1 and Notebook 7.1 are here 🎉

2024-02-26T22:57:00+00:00

JupyterLab 4.1 and Notebook 7.1 are now available! These releases include several new features, bug fixes, and enhancements for extension developers. This release is compatible with extensions supporting JupyterLab 4.0 and Notebook 7.0.

JupyterLab 4.1 is one of the largest minor releases of JupyterLab to date, bringing 6 new features, 39 enhancements, and 114 bug fixes to users, and addressing 140 maintenance tasks. Project Jupyter thanks the 70 contributors, including 13 new code/documentation contributors, who helped us build this new version.

Jupyter Notebook 7.1 is the first minor release after the transition to the new codebase, which re-uses JupyterLab components. As such, Notebook 7.1 inherits many of the new features and fixes from JupyterLab 4.1. Feature parity with Notebook 6 was also improved in this release.

JupyterLab Desktop was also upgraded to version 4.1, receiving additional bug fixes and enhancements. Thank you to Mehmet Bektas for your continuing work to improve JupyterLab Desktop!

Extension authors should consult the Extension Migration Guide, which lists deprecations and changes to the public API.

Custom CSS

JupyterLab now supports automatic loading of custom CSS. Themes are the recommended way for customizing the JupyterLab look and feel, while custom CSS is intended for minor personal adjustments.

To opt in, start JupyterLab with the — custom-css flag. The location of the custom.css file is documented in the section on customizing the user interface. Please note that the CSS selectors may vary between versions and applications (JupyterLab vs Notebook).

Diagrams in Markdown

Matching GitHub-Flavoured Markdown, JupyterLab and Notebook now support Mermaid diagrams. To create a Mermaid diagram, use the mermaid language specifier for a code block in a markdown cell or document, for example:

```mermaid
flowchart LR

A[Hard] -->|Text| B(Round)
B --> C{Decision}
C -->|One| D[Result 1]
C -->|Two| E[Result 2]
```

which renders as:

Inline code completion

JupyterLab and Notebook now support automatic code (and text) completion presented as ghost text in the cell and file editors, allowing generative AI models to provide multi-line completions. The suggestions are provided by plugins implementing the IInlineCompletionProvider API. By default a single provider using the user’s kernel history is available.

The suggestions can be invoked as-you-type or manually using a configurable shortcut (by default Alt + ). The default keyboard shortcuts are displayed in the small widget shown when hovering over the ghost suggestion.

To enable the inline suggestions based on the kernel history, go to Settings → Settings Editor → Inline Completer → History provider → check the “enabled” checkbox.

In addition to the built-in history suggestions, additional inline completion providers can be installed. For example, the jupyter-ai extension, version 2.10.0 and newer, provides suggestions from compatible large language models.

The Inline Completer API is still considered experimental and may be subject to change. Please share your feedback!

Numerous improvements to keyboard navigation with focus on accessibility and usability are included in this release:

the notebook cells now retain focus
the focus can now be moved beyond the active notebook
the toolbars can now be navigated using arrow keys

For more details, see the post on the Jupyter Blog about keyboard navigation improvements.

Execution history in notebook

The code from previously executed cells can be used to populate empty cells, letting users iterate on code from previous cells or even previous sessions, depending on how a specific kernel stores its history.

To cycle between history items, press Alt + Arrow Up and Alt + Arrow Down.

To enable execution history, go to Settings Editor → Notebook → check the “Kernel history access” checkbox.

This feature was already available in the console in previous releases; it only works with kernels supporting execution history requests. To clear the execution history, consult the documentation of the kernel you are using (e.g., IPython/ipykernel).

Opening files from tracebacks

Paths to code files detected in error tracebacks are now turned into links. These links will open the corresponding file for editing, if it is in the Jupyter root directory, or they will open a read-only preview if the file is outside of the root directory and the active kernel supports the debugger.

Error indicator in the table of contents

When a cell fails during execution, an error indicator will be displayed by the corresponding heading, increasing awareness of the notebook state and enabling users to quickly navigate to the cell which requires attention.

Plugin Manager

Individual plugins can now be disabled or enabled from a new Plugin Manager user interface. While the existing extension manager can enable/disable entire extensions, each extension is composed of one or more plugins (and plugins form the basis of JupyterLab itself) thus the plugin manager enables more extensive customization of the JupyterLab experience in addition to the previously available extension manager.

This feature is intended for advanced users and is documented in depth in the documentation.

Administrators may want to lock specific plugins if they are required for any reason; this will prevent users from disabling the plugins via Plugin Manager and remote API calls. The Plugin Manager itself can be disabled using the CLI.

Virtual scrollbar for notebook in windowed mode

The windowed notebook now has an optional scrollbar that shows the active cell and selected cells. Users can jump to a specific cell.

To enable the virtual scrollbar, go to Settings → Notebook → Windowing mode, choose “full”, and click on the hamburger icon (≡) which appears in the notebook’s toolbar.

Virtual scrollbar is an experimental feature. Please share your feedback!

Notifications

JupyterLab 3.6 added a notification center which so far was only used for announcements and version update notifications (both opt-in). JupyterLab 4.1 adds two notifications to guide users in potentially confusing situations:

when a user attempts to save a read-only document, a transient notification suggesting using “save as” is displayed
when a user attempts to execute a cell before a slow-starting kernel has initialized, a notification is shown to indicate that the cell cannot be yet executed (this is opt-in and needs to be enabled in settings)

Full notebook windowing mode improvements

Notebooks in the full windowing mode only render the visible cells, significantly improving the performance of the application. Numerous improvements for the full windowing mode behavior (such as scrolling, search, rendering, and navigation) are included in this release (see the list of issues in #15258 for details). Note: the windowing mode is still experimental and known issues remain to be solved.

Search improvements

The search box will now grow automatically to accommodate longer text
Search in selection can now be toggled using Alt + L and automatic search in selection can be configured in settings
Tooltips with shortcuts were added to the buttons in the search box to improve discoverability of the shortcuts

Acknowledgements

Special shout out to new code/documentation contributors (hope to see you again!):

JupyterLab: @alden-ilao @AllanChain @ashna1jain @brijsiyag @DcWire @DenisaCG @Deepali1211 @dhml @dolevf @eliaslma @emmanuel-ferdman @e4e @g547315 @jans-code @j264415 @kiliansinger @KiranmaiKalla @misterfads @mmichilot @mdengler @MFA-X-AI @m158261@nbowditch-einblick @nluetts @paolocarinci @pauky @paulkim3151 @phil-zxx @Rmarieta @RRosio @Sarthug99 @sinistersnare @t03857785 @Wh1isper
Notebook: @Dilip-Jain @haok1402 @akx

Thank you to the returning contributors (please do feel invited to review pull requests as well!):

JupyterLab: @afshin @akx @andrewfulton9 @andrii-i @bollwyvl @bikash30851 @brichet @davidbrochart @divyansshhh @dharmaquark @DonJayamanne @echarles @ericsnekbytes @fcollonval @firai @FoSuCloud @gabalafou @hbcarlos @JasonWeill @jtpio @krassowski @mctoohey @minrk @nishikantparmariam @parmentelat @skyetim @smacke @SylvainCorlay @telamonian @tibdex @timkpaine @trungleduc @yuvipanda
Notebook: @brichet @jtpio

and everyone who tested the pre-releases!

Additionally, we would like to thank our community triage leaders who helped sort issues for JupyterLab (@JasonWeill), Notebook (@RRosio) and JupyterLab Desktop during the course of weekly triage meetings.

Contributors to this blog post: @JasonWeill @krassowski @gabalafou @jtpio

JupyterLab 3 end of maintenance

2024-02-19T22:07:00+00:00

The JupyterLab Council has agreed to an important change to JupyterLab’s version lifecycle. Each major version of JupyterLab will now receive updates until one year after the following major version’s first release. JupyterLab 4.0.0 was released on May 15, 2023, so JupyterLab 3 will reach its end of maintenance date on May 15, 2024, anywhere on Earth. To help us make this transition, fixes for critical issues will still be backported until December 31, 2024. If you are still running JupyterLab 3, we strongly encourage you to upgrade to JupyterLab 4 as soon as possible.

This represents a change from JupyterLab’s previous policy, by which we supported two major versions of JupyterLab at a time, and which would have obligated us to continue supporting JupyterLab 3 until JupyterLab 5.0.0 became generally available. We decided to make this change to let developers, contributors, and users focus their attention on the newest major version, JupyterLab 4. Maintaining multiple major versions requires additional time and effort, which could instead be put towards making the current version better for all users. Recent releases on the 3.6.x branches have included mainly security fixes and maintenance fixes, not new features.

We recognize that there are many users still using JupyterLab 3, having downloaded it directly from package repositories or using it as distributed by a commercial vendor. We strongly encourage all users and vendors to upgrade to Lab 4 as soon as possible. If this is not possible, out of acknowledgement for the short notice of this announcement, we will consider pull requests addressing critical issues against the 3.6.x branch through December 31, 2024, anywhere on Earth, provided that they meet all of the following requirements:

The fix addresses a critical issue: a security vulnerability, data loss, or another issue of very high severity.
The fix includes tests, is reasonably small and low in complexity, and the author communicates actively with maintainers who review their work.
The fix is approved by a JupyterLab maintainer.

The JupyterLab team recognizes that a few regressions from JupyterLab 3 were present in JupyterLab 4.0.0; some of them are still open. Project Jupyter is driven by volunteers, community contributors, and support from individual and corporate users. We thank our community for their patience and we encourage our contributors to help us resolve bugs that block users from upgrading to the newer version. The JupyterLab maintainers are committing to review any pull requests submitted to address regressions as a priority over pull requests

We want to hear from you! If you have questions or comments about this new version lifecycle, please leave them below, or join the conversation on the Jupyter Community Forum. We also welcome discussion about the change at our weekly JupyterLab meetings, which are held every Wednesday at 09:00 US Pacific (17:00 UTC as of today, 16:00 UTC starting on March 10, 2024).

Thank you for using JupyterLab and for being a part of our great global community!

Announcing Jupyter Notebook 7

2023-07-26T16:08:00+00:00

Jupyter Notebook 7 is the most significant release of the Jupyter Notebook in years. Some highlights of this release include real-time collaboration, interactive debugging, table of contents, theming and dark mode, internationalization, improved accessibility, compact view on mobile devices.

Both Jupyter Notebook and JupyterLab are widely used across data science, machine learning, computational research, and education. With the release of JupyterLab 4 and Jupyter Notebook 7, the two sibling applications offer a unified, flexible, and integrated experience that allows you to get the best of both, in whatever combination that makes sense for you.

Jupyter Notebook 7 with a running Python 3 notebook

Since Notebook 7 is based on JupyterLab, it includes many of the new features and improvements that have been added to JupyterLab over the past few years.

Here is a small glimpse of what users can expect when they upgrade from Jupyter Notebook version 6 to version 7.

A Familiar Document-Oriented Experience

Starting with what does not change, Notebook 7 still focuses on the document-centric user experience that made the classic IPython and Jupyter Notebook application so popular.

It keeps the clean and lean interface that users love, and it enables you to create and edit the same Jupyter notebook .ipynb files that contain live code, equations, visualizations and narrative text.

Visual Debugger

Notebook 7 includes the interactive debugger from JupyterLab, which enables you to step through your code cell by cell. You can also set breakpoints and inspect variables.

Visual debugging in Jupyter Notebook 7

Real-Time Collaboration

Notebook 7 enables you to use the same real-time collaboration extension as JupyterLab so you can share your notebook with other users and edit it in real time. This even works across JupyterLab and Jupyter Notebook! To start using real-time collaboration, you will need to install the jupyter-collaboration extension:

pip install jupyter-collaboration

A side-by-side animated example of real-time collaboration in Jupyter Notebook 7

Theming and Dark Mode

A dark theme is now available in the Jupyter Notebook by default.

Jupyter Notebook 7 with JupyterLab Dark theme

You can also install many other JupyterLab themes. For example to install the JupyterLab night theme:

pip install jupyterlab-night

Jupyter Notebook 7 with JupyterLab Night theme

Improved integration between JupyterLab and Notebook

We have built Notebook 7 and JupyterLab 4 to work well together. When you run either application using jupyter lab or jupyter notebook, we automatically detect if the other application is installed and enable its user experience as well. This is possible as both JupyterLab and Notebook use the same underlying server and extension system. From a user experience perspective, this allows you to easily open a notebook in the other application using the “JupyterLab” and “Notebook” buttons as the top of each notebook. This makes it seamless to move back and forth between the two applications to best match your work.

More features

You can find a list of the new features in the Jupyter Notebook documentation.

Why a new version?

Following feedback from the community, we decided in late 2021 to continue developing the Jupyter Notebook application and sunrise it as Notebook 7.

The major change is building the Jupyter Notebook 7 interface with JupyterLab components so that the two applications share a common codebase and extension system. We have worked hard to ensure that the experience users know and love from Jupyter Notebook 6 is preserved, even as we have added many new features to Notebook 7. Let’s dive into those new features!

You can find more details about the rationale behind this new release in Jupyter Enhancement Proposal 79.

Migrating to Notebook 7

The Jupyter Notebook Team has been working to make the transition from Notebook 6 to Notebook 7 as smooth as possible. The Notebook 7 release is a good opportunity to try out the new features and report any issues you may encounter.

Because the architecture of Notebook 7 is rebuilt from the ground up, we recognize that some existing users might need a medium-term option for backward-compatibility with Notebook 6 using NbClassic, which delivers the same user experience and can be run on the same server as JupyterLab and Notebook 7. This means that the server hosting your Notebook can deliver those 3 difference user interfaces at the same time.

There is also a migration guide to help you upgrade to the new version.

Try it on Binder

You can try Notebook 7 on Binder using this link.

Acknowledgements

The work on Notebook 7 by Jeremy Tuloup was supported by QuantStack.

Anaconda supported work on Notebook 6 and 7, NbClassic, documentation and maintenance.

Get Involved

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

Make your own extensions. You can also help the community by porting Classic Notebook extensions to Notebook 7.
Contribute to the development, documentation, and design of Jupyter Notebook 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 Discourse. If you find a bug, have questions, or want to provide feedback, please join the conversation!

JupyterLab 4.0 is Here

2023-06-05T20:04:00+00:00

The Jupyter contributor community is proud to announce JupyterLab 4.0, the next major release of our full-featured development environment. The package is now available on PyPI and conda-forge. You can upgrade by running pip install --upgrade jupyterlab or conda install -c conda-forge jupyterlab. We have updated our JupyterLab Documentation for this new version.

Here are some of the major new features in JupyterLab 4.0, excerpted from our changelog:

JupyterLab is now faster, thanks to improvements such as CSS rules optimization, CodeMirror 6, MathJax 3, and notebook windowing. By rendering only the parts of a notebook that fit in the web browser viewport, JupyterLab 4 is much more efficient than JupyterLab 3 was when working with large notebooks.

There are additional performance improvements available via opt-in settings. You can help test them out by enabling them in your settings:

Faster tab-switching on Chromium browsers:
“Settings” → “JupyterLab Shell” → switch “Hidden mode” to “contentVisibility”
Better performance with long notebooks:
“Settings” → “Notebook” → switch “Windowing mode” to “full”

An upgraded text editor. CodeMirror, the text editor used for cells and file editors, has been updated to CodeMirror 6. This brings important accessibility and performance improvements as well as better customization capabilities. We have also improved the editor settings to be more powerful and more flexible.

We have moved real-time collaboration (RTC) into a separate package, jupyter_collaboration, version 1.0.0 of which is now available. Highlights include support for displaying multiple cursors and selections, and support for registration of new shared model types. If you’d like to use RTC in JupyterLab 4, please install the jupyter_collaboration package.

A new extension manager. In JupyterLab 4, the Extension Manager includes both prebuilt Python extensions and extensions from pypi.org. Installing from PyPI removes the need to build when installing an extension using the Extension Manager. Developers can provide an alternative package repository to display their own set of extensions.

Improved document search. The Search and Replace functionality has been improved with new features when searching in a notebook, including highlighting matches in rendered markdown cells, searching in the current selection, multi-line search, replacement using regular expression capture-group references, and replacement while preserving case.

UI improvements, including a reworked running kernels section, an “Add a new cell” button at the bottom of a notebook, a dialog to display keyboard shortcuts as in the Classic Notebook (use Ctrl + Shift + H), and displaying the first line of collapsed cell inputs and outputs.

Accessibility improvements, including improved focus and keyboard navigation in the file browser, more ARIA roles and labels for UI elements, and the main menu collapsing to a hamburger menu if there is not enough space to display all items.

Development tool updates to TypeScript v5, Yarn v3, React v18, and Lumino v2. We recommend using Node.js v18 or newer, to ensure that you’re using a version that will continue to receive updates through at least the end of 2023.

Bug fixes. More than 100 bugs have been addressed and resolved, enhancing JupyterLab’s stability and performance. You can find a full list of bug fixes on GitHub.

In addition, a few features in JupyterLab 4 have also been backported to JupyterLab 3.6, but if you’re upgrading from 3.5 or earlier, they will also be new to you:

The dual-mode settings editor now offers a JSON editor and a new, user-friendly interactive mode, built with React JSON Schema. This intuitive interface makes customization accessible to users of all skill levels.

The cell toolbar, a graphical interface for quick cell manipulation (copy, move, insert, delete), provides an alternative to hotkeys or dropdown menu editing. The cell toolbar appears in the current cell as long as there is room for it.

Notifications come from extensions and from JupyterLab itself, for real-time announcements, alerts, and updates. This enhances JupyterLab’s responsiveness and provides a way to stay informed about ongoing processes. Announcements from the JupyterLab team, including new version notifications, can be disabled; see the documentation for instructions.

Thank you to all the users, contributors, extension developers, and community members who helped make this major new release possible. We encourage everyone to try this new version out. If you notice anything unexpected, please file an issue on GitHub or ask us about it on Discourse.

Author’s note: This article is published on behalf of Project Jupyter. I appreciate the contributions of the JupyterLab developers who contributed to it.

Jupyter Server 2.0 is released!

2022-12-06T23:25:00+00:00

We are thrilled to announce the release of Jupyter Server 2.0!

Jupyter Server provides the core web server that powers JupyterLab and Jupyter Notebook.

This release brings many new features and lays groundwork for a more multi-user, (real-time) collaborative Jupyter experience.

Major Highlights

Below is a short list of highlights for everyone! 🚀

New Identity API

As Jupyter continues to innovate its real-time collaboration experience, identity is an important component. While we all love that mysterious “Anonymous Jovyan” appearing in our notebooks, we’d prefer to know who is editing/viewing our documents.

The new Identity API in Jupyter Server makes this possible. It is a configurable, pluggable API that provides a clear extension point to customize how Jupyter Server authenticates and identifies its users.

Deployers of Jupyter Server can configure Server’s default IdentityProvider or swap in their own IdentityProvider to authenticate users with any auth provider.

New Authorization API

Enabling collaboration on a notebook shouldn’t mean “allow everyone with access to my Jupyter Server to edit my notebooks”. What if I want to share my notebook with e.g. a subset of my teammates?

The new Jupyter Server Authorization API is a critical step towards making this type of “fine-grained” permission management possible.

It provides a clear, pluggable extension point where we can build authorization layers (e.g. RBAC) backed by any auth provider. Deployers of Jupyter Server can extend Jupyter Server’s new Authorizer API to control user access in a running Jupyter Server.

New Event System API

Looking ahead at Jupyter’s future, it became clear that there is a whole class of untapped features — like notebook commenting or notifications— that need a Jupyter “event system"; these features react to events happening in and around a running Server.

This led us to create jupyter_events—a package that provides a JSON-schema-based event-driven system to Jupyter Server and server extensions. Jupyter Server leverages this new system to emit events from the server. Keep an eye out for future development where we will define more “core” events (similar to the Contents Service Events) to enable better event-driven functionality in the Server.

Other major changes

Below is list of other major changes and features that impact folks who extend + customize the Jupyter Server experience. This section is a little more technical in nature, but offers some exciting updates for folks who customize Jupyter Server.

New Kernel Websocket API

Jupyter Server now provides a configurable, pluggable layer between the kernel’s ZMQ sockets and websocket, called the KernelWebsocketConnection. This enables folks to innovate in the space between kernels and the server’s clients.

Server ships its own Kernel Manager

Jupyter Server now provides its own kernel manager class, ServerKernelManager. This enables us to innovate the kernel management layer to specifically fit the needs of Jupyter Server and add features like kernel-based events, persistence, and other kernel lifecycle-related functionality

This affects folks who have extended the default KernelManager with custom functionality — they will need to derive from this new class in order to take advantage of new server-specific functionality.

Terminals Service is now a Server Extension

Jupyter Server now ships the “Terminals Service” as an extension (installed and enabled by default) rather than a core Jupyter Service.

Most users will not notice this change, but this enables terminals to be optionally disabled. For more sensitive deployment environments, this is a big win!

pytest-jupyter, a pytest plugin for Jupyter

As we worked to increase our test coverage to ~80% (major “thank you” to Steve Silvester!), we built a handy set of pytest fixtures that can benefit Jupyter developers and extension authors.

This led us to release pytest-jupyter, a packaged pytest plugin for testing Jupyter core libraries and extensions.

Changelog

This post was only an overview of what’s new in 2.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.

Installation

To install Jupyter Server with pip:

pip install jupyter_server

or with conda:

conda install -c conda-forge jupyter_server=2.0.0

Documentation

Find our full documentation here.

We are still catching up! Please have patience with us as we continue to update our documentation. If this is something you’d be interested in helping us improve, we’d love your help!

Acknowledgements

Massive “thank you” to the whole Jupyter Server Team. The Jupyter Server project is largely shepherded by the amazing folks listed here.

We’re also incredibly grateful to the large list of contributors outside the team. Y’all are the best! Thank you for helping us make Jupyter Server better each day!

If you’re interested in meeting or getting involved with the team, stop by one of our weekly community meetings, or better yet, join our Contributing Hour!

About the author

Zach Sailer is a Senior Software Engineer at Apple, where he is the Jupyter Open Source Champion. He is a Jupyter Distinguished Contributor and the Jupyter Server Steering Council Representative.

Jupyter Notebook 6.5.0 Release Candidate

2022-09-15T15:01:00+00:00

We’d like to announce the Notebook 6.5.0 release candidate which is available on PyPI.

Notebook 6.5.0rc0 on PyPI

Notebook 6 vs Notebook 7

Jupyter Notebook is a longstanding project that has been loved by many for years. Even with the 2018 release of JupyterLab, a feature-full user interface with a more modern codebase, many people have continued to use Jupyter Notebook. In an effort to continue providing updates to the UI that people know and love, many developers have been working on Jupyter Notebook 7. This transition was outlined in the Jupyter Enhancement Proposal or JEP 79, which highlights the motivation behind an updated codebase and the plans that are currently being carried out. Notebook 7 uses components from JupyterLab and the Jupyter Server package as does JupyterLab, and the UI provides an experience much like the classic user interface that Jupyter Notebook users are familiar with. There are various new features which will be readily available, and improvements are to be made in Jupyter Notebook 7.

Due to this upcoming release, there were some necessary changes that had to be made to Jupyter Notebook 6. Jupyter Notebook 6 has lived in the jupyter/notebook repository whose main branch reflects Notebook 7. Notebook 6 uses the same Python Tornado server architecture, and the NotebookApp class that has been present all through previous Notebook releases. However, as of Notebook 6.5 the static HTML/CSS/JS assets that constitute the user interface have been moved to a different repository, the jupyter/nbclassic repository. Notebook 6.5 aims to be end of life in a reasonable timeframe. With this in mind, Notebook 6.5 will focus on security and bug fixes rather than new features.

NbClassic

With the more sustainable Notebook 7 in the horizon, and Notebook 6.5 being EOL, the NbClassic project is the repository through which enhancements and new features can be offered. NbClassic is a forked version of the 6.5.x branch of Notebook, refactored as a Jupyter Server extension. Through this, users can benefit from the updates to other parts of the ecosystem such as Jupyter Server. While the classic user interface will be available through both Notebook 6 and NbClassic, immediate updates to the classic Notebook UI will be provided through NbClassic.

Since as of Notebook 6.5, the static assets for the UI have been removed from the Notebook repository and are made available to Notebook 6.5 through NbClassic, and the NbClassic repository is also where issues with the classic user interface should be reported. The NbClassic project aims to provide intermediary support to those users of Notebook 6 who for various reasons may not yet be able to upgrade to Notebook 7. As NbClassic can be seen as a drop-in replacement to Notebook 6, its support and lifecycle will follow the one defined for the Notebook 6 product line. For more details on the maintenance of Notebook projects please have a look at the Maintained versions section in the readme.

As from version 0.4.0, NbClassic is a Jupyter Server extension that is backwards compatible with most extensions built for Notebook for version 6. If your extension does not work on NbClassic, we invite you to open an issue on the NbClassic GitHub repository so we can help you resolve it.

Some Use Cases

One reason a user might not be able to update may be due to a user toolset that incorporates an extension that has not yet been ported to Notebook 7 and JupyterLab. In these cases, it will be important for extension developers to place an upper bound in their Notebook dependencies so that only versions below Notebook 7 will be installed. There may also be users who have both JupyterLab extensions and Notebook extensions as a part of their toolset.

Another scenario may include DevOps Engineers who may provide Notebook 6 or 7, NbClassic, and JupyterLab to users to account for the different needs of many teams. In that scenario, the user can choose his user interface that runs on the same server port. For example if both Notebook 7 and NbClassic are installed, the default interface will be Notebook 7 under /tree URL while the NbClassic interface will be available under nbclassic/tree URL

Compatibility

For the various use cases, we aim to foster the coexistence of these projects while users and developers begin adapting to Notebook 7. Jupyter Notebook 7, JupyterLab and NbClassic share the same server architecture, allowing users to more feasibly use them interchangeably. On the other hand, Jupyter Notebook 6 will only be tied to NbClassic for the static assets that it will use. Extensions that work with Notebook 6 will be compatible with NbClassic while extensions developed for JupyterLab will work with Notebook 7. If users wish to use the upcoming Notebook 7 but have the ability to occasionally work with extensions that have not been ported, NbClassic will provide this. You can use NbClassic with the CLI command jupyter nbclassic .

DevOps Engineers will have to use a slightly different command to enable the notebook extension on NbClassic. For example, they will have to use jupyter nbclassic-extension instead of jupyter nbextension. We are working on updating the documentation to reflect those changes.

Next Steps

With the release of Jupyter Notebook 6.5.0rc0, we hope to reach those who continue to use Notebook 6 and hear about your experience. The Jupyter Notebook 6.5.0 release candidate can be installed with pip: pip install notebook==6.5.0rc0. For those who wish to continue using a user interface much like the classic Notebook that is familiar, Notebook 7 has an alpha release and will provide a well supported and evolving user interface. Alongside working to release Notebook 6.5 and the upcoming Notebook 7 release, we will be continuing to work on preparing NbClassic to be used with the various other Jupyter projects and gearing up for the first major release.

We would be happy to hear about your experience using Notebook 6.5.0rc0. For any questions, feedback, or bug reports, we invite you to open an issue in the NbClassic repository.

Sincerely,

Project Jupyter

About the Author
Rosio Reyes is a Software Engineer at Anaconda working as a part of the OSS Jupyter team. She is a Jupyter Notebook Steering Council Member and contributes to the Notebook and NbClassic projects.

Thank You to Contributors to this blog
Eric Charles is a Software Engineer at Anaconda, Datalayer and Quansight working as a Tech Lead on the OSS Jupyter team. He is a Jupyter contributor and a member of the Jupyter Notebook Steering Council. He contributes to many Jupyter Projects and provided an outline for the blog as well as many edits and additions.

Eric Gentry, a Software Engineer at Anaconda working on the OSS Jupyter team. He is a Jupyter Notebook Steering Council Member and contributes to the Notebook and NbClassic projects. He also provided many edits for the blog.

Special thanks to the Jupyter Notebook Meeting Group for their feedback.

Release of IPython 8.0

2022-01-12T13:37:00+00:00

IPython is a powerful Python REPL that gives you tab completion, better tracebacks, multiline editing, and several useful features on top of pure Python Scripts. It is also the library that powers the Jupyter Kernel via the IPykernel.

Today I am pleased to announce the release of IPython 8.0, which has been long in the making and arrived a bit over three years after the 7.0 release.

I also suggest to read the companion blog post on Quansight-Labs site that goes into some technical details on how we removed some old code.

EDIT: You can also ask questions/comments on the jupyter discourse, or read the discussion on HN

Many new features

This major release comes with many improvements to the existing codebase and several new features. These new features are code reformatting with Black in the CLI, ghost suggestions, and better tracebacks which highlight the error node, thus making complex expressions easier to debug (see below).

Tracebacks now highlight in which AST node the error occurs. In complex code, this helps to quickly narrow down what causes an error. Here we also turn on xmode verbose to see values of local variables (xmode verbose is disabled by default for security reasons as it could leak secrets, but is highly recommended)

But really, if you want to read about all the new features in-depth, we recommend you spend some time reading the what’s new and the list of features in 7.x.

Moving forward by shedding weight

While IPython 8.0 has many new features described in the what’s new section, the majority of changes that demanded a bump in major version numbers are removals.

IPython was created more than two decades ago by Fernando Pérez while procrastinating on his graduation. Even if a few lines from this period remain, it was time to remove a large number of deprecated and unused code in the IPython code base and drop old dependencies (like nose) in favor of more recent ones (pytest).

Thanks to NumFOCUS Small Developer Grant, we hired Nikita Kniazev (@Kojoley) to help us with some of the heavy lifting. Nikita did a fantastic job updating our codebase, migrating to pytest, enhancing our coverage, and fixing numerous bugs. I highly recommend contacting them if you need help with C++ and Python projects.

Some of Nikita’s most notable contributions are:

IPython is no longer reliant on Nose, which has been unmaintained for many years.
Significantly increased IPython coverage.
Considerable refactor of areas that were calling into deprecated features.

On top of this, IPython 8.0 also comes with the following capabilities:

Remove most of the deprecated functions and parameters that were marked as such between IPython 1.0 and 5.0
Bumped the minimal required Python version to 3.8 (following NEP 29). This means that we now use the native Python top-level async instead of crazy hacks. And we can start to use def fun(a,/,b=None): syntax for positional only arguments.

Nikita also went well beyond the scope of work we gave them by suggesting more robust and often simpler code patterns.

In total, this allowed us, despite all the added features, added type annotations and added tests, to decrease the size of the codebase from 37 500 LOC across 348 files to 36 100 across 294 files. We hope that this reduction in the codebase size combined with work on speeding the startup of the CLI will make IPython easier to use and contribute to.

Some advice on how to do that same are on the companion blog post and the Quansight-Labs site.

Moving toward pyproject.toml

Another place in IPython that has seen many changes in the build process. We now use pyproject.tomlto have a declarative build. We still require setuptools and have setup.py files right now, but we are working towards removing/simplifying them soon.

IPython’s wheels and sdist can now be built with python -m build instead of invoking setup.py directly.

Our process still needs manual setup of SOURCE_DATE_EPOCH and repacking of the sdist wheel to obtain reproducible builds. We encourage you to get the git repository, build it yourself, and get a byte-for-byte identical artifacts.

Monthly Release and following NEP 29

We strongly believe that predictability is key to adoption and trust in IPython. In particular, in business settings, it is critical to plan ahead while rapidly receiving bug fixes. This is why for IPython 8.0 we’ll continue to do minor monthly releases on the last Friday of each month as long at it’s reasonable and does not impact maintainers life too much.

We’ll still publish a few 7.x releases with critical bug fixes, but starting last Friday of this month, you will start to see stable releases of 8.x.
All releases are announced in this subcategory in discourse, to which you can get subscribed to get notifications.

We also now follow NEP 29, meaning that IPython 8.0 is not only compatible with NumPy 1.19+ and Python 3.8+. But our future Python support schedule is predictably aligned with all other libraries following NEP 29.
We believe the new NEP 29 is critical. It gives the core Scientific Python Ecosystem a clear schedule of available features and the removal of deprecated features.

Looking forward to your contributions

Don’t think IPython is too hard to contribute to or has no missing features. We try to keep a list of beginner-friendly issues, but we really want your feedback and your ideas. In the meantime, have fun with this new release that you can install with :

pip install ipython ipykernel --upgrade

conda update ipython ipykernel

(updating ipykernel may not be necessary for you, but we recommend it).

Thanks

Thanks to Tania Allard and Eric Charles for review , Quansight Labs and Quansight (my employer) for all the open-source work I can do. Of course, thanks to all the contributors to the IPython and Jupyter community, and in particular MrMino who recently joined as an IPython core dev…

CVE-2021–32797 and CVE-2021–32798 Remote Code execution in JupyterLab and Jupyter Notebook

2021-08-09T20:05:00+00:00

TL:DR; All recent JupyterLab and Notebook versions are susceptible to a attack where a maliciously crafted notebook can trigger arbitrary code execution when a user views these malicious files.

We strongly advise all users to deploy the new version of JupyterLab and Jupyter Notebook.

Jupyter Notebook 6.4.1 or above, 5.7.11 or above.

Jupyter Lab 3.1.4 or above, 3.0.17 or above, 2.3.2 or above, 2.2.10 or above , 1.2.21 or above

This blog post will be updated with links to the various patches, exploit and disclosure later once the final links are available.

Jupyter Security Model

Jupyter Notebook act as a REPL (Read Eval Print Loop) in a browser, our main goal is to expose as many functionalities to our users, with the least restrictions. We also want users to be able to share their results with other, and let everyone be capable of reproducing the result.

When receiving an untrusted notebook from a potentially malicious source we still want users to be able to inspect a notebook without risks, our approach is that an untrusted notebook has restrictive capabilities until all cells have been manually inspected and explicitly run by a user, or the notebook is explicitly marked as trusted. If one finds a way to bypass this trust mechanism, a notebook might be able to execute code in the browser at at a time where a user is not expecting execution to occur.

This is what happen in these particular CVEs, where some content of a notebook were improperly handled.

[This part of the blog post will be updated with links to actual reports, and proof of concept once the patched version have reached enough package repositories]

CVE Timeline

We want to thanks Guillaume Jeanne (Google), and Timo Schmid (Google) for the vulnerability report and helping us through the fixing process.

Thursday, 15 Jul 2021 07:11:13 -0700 (PDT): Initial question about security issue disclosure on security@ipython.org (no specific on the vulnerability)
Tuesday, 20 Jul 2021 05:52:09 -0700 (PDT): Actual Vulnerability Report.
Tuesday, 20 Jul 2021 : Open relevant GitHub security advisory on Notebook and JupyterLab Repositories
Thursday, 5 August 2021 : First releases with patched version on PyPI.
Monday, 9 August : publication of this blog post and publish security advisory on GitHub.
[Further item may be added to list publication by downstream repositories, like conda, conda-forge, debian…, contact us to add an item]

What we learned

Dealing with Security vulnerability in Jupyter and more generally in Open-Source is far from easy. We initially thought about treating the Notebook and Lab CVE separately but they are/were too similar and the cross discussion too revealing to treat both independently.

As Jupyter is mostly a volunteer based organisation, there is often no contributor responsible to replying to security issues, and when someone steps up they might not be a expert, nor available all the time. I want to give special thanks to Steve Silvester (Apple) , Afshin Darian (Two Sigma), and Zach Sailer (Apple), and Matthias Bussonnier (Quansight) for writing the fixes, planning through the release and notifying stakeholders.

Advance notice to stakeholder is complicated, we know of a few large deployment and have personal connections to a couple organisation, and were able to reached out to let them know critical release would be published. There is an inherent tension between publicly warning our user base that security release would be published, which might push malicious actor to closely survey the codebase changes and re-derive the attack vectors, and publishing the release first, with the details later. Especially since we are trying to be transparent in our communication, security fixes are the opposite of our normal communication workflow.

Our communication process is imperfect. We have 2 mailing list for security-related discussion. The first one – security@ipython.org – has only a couple of members all core contributors and can receive email from the outside, it is used for triage. It receive a high number of spam as this is public email. As it has only a few members and we are all busy, mail can slip through. The second mailing list is slightly larger, and used for internal announcement for stakeholder. It has a fairly open membership model, (ask a Jupyter developer if you can be on it, and the reason why and we’ll likely add you), though it’s content seem to be ignored (it even lands on my spam folder, not sure why).

What we’ll do better

In order to attempt to better react and be proactive with respect to security we are attempting to form and new security-focused subproject/workgroup to educate and have procedure for everything security related. We welcome your involvement and feedback in how to improve Jupyter security and how to better involve the community.

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!

BinderHub is out of Beta!

2019-04-26T16:49:00+00:00

Nearly two years ago, the Binder Project released the beta version
of BinderHub, the technology behind mybinder.org. Since then, mybinder.org has grown to serve nearly 90,000 launches each week and hit the two million launches in a year milestone last year. Over these two years BinderHub has matured as technology and community. Several new organizations now run their own BinderHubs and have joined the community of maintainers.

A year of Binder sessions served from mybinder.org. Darker colors show users in countries that have launched more Binder sessions. The pins show the approximate locations of public BinderHubs that we know of. Where is mybinder.org? It is a global effort so there is no one location associated with it or the team that runs it.

Today we are proud to announce that we’ve removed the “beta” label from all pages served by BinderHub. BinderHub is now a tool with a track record of working well in production (both at mybinder.org and in other deployments), its general features and API have stabilized, and JupyterHub, the underlying technology that BinderHub uses, is close to its 1.0 release.

A big thank you to all those who have used, commented, advocated, advertised, contributed, maintained and funded this journey. The deployment at mybinder.org is funded with grants from the Moore Foundation and the Google Cloud Platform.

Who else has deployed a BinderHub?

A goal of Project Binder is to build modular, open-source tools that
others can deploy for their own communities. BinderHub, the core technology behind mybinder.org, runs on Kubernetes this means it can be deployed on many cloud providers or even on your own hardware. Over the years, we have seen many new organizations deploy their own BinderHubs. Here are our highlights of other organizations who have joined the BinderHub community.

GESIS were the first to deploy a public BinderHub that is operated independently of mybinder.org. The GESIS BinderHub instance went live
in December 2017 and has been running ever since. They are frequent
contributors to the upstream project. Their BinderHub runs on a bare metal
Kubernetes cluster.

The Pangeo Project instance was the next to come online, launching their
public BinderHub instance in September 2018 (more details in their blog post). They provide additional compute resources and have customized their setup to provide on-demand dask clusters to users. Try out one
of their examples using ocean data. The Pangeo cluster is hosted on Google Kubernetes Engine.

Recently, the Turing Way project has been working on deploying a BinderHub at the Turing Institute in the UK. This BinderHub will serve both internal and external users with the goal of making it easier to share data science projects. They have run several workshops including one that teaches scientists and research software engineers how to deploy their own BinderHub instance. Recently they led a workshop in which ten academics and IT staff deployed their own BinderHub on the Microsoft Azure cloud! Sarah Gibson from their team has recently joined the team that operates mybinder.org.

Finally, the Pacific Institute for the Mathematical Sciences (PIMS) runs a service called Syzygy. It deploys several JupyterHubs and BinderHubs for scientific organizations around Canada. A Binder team recently held a tutorial on deploying Binder and JupyterHub at the PEARC (you can find slides for the talk here). They have also provided a script for deploying JupyterHub (and Binder) on Terraform.

What’s next?

Now that BinderHub is not in beta anymore, what is next? As Project Binder we will focus on adoption, training, and growing the Binder community. This means growing the creation of Binder-ready repositories (repositories that have the necessary structure for Binder to create the environment needed to run the repository’s code). We will increase our outreach and marketing efforts to make sure a diverse audience everywhere around the world knows about Binder.

We will also work on making it easier to setup and operate a public BinderHub no matter what cloud vendor you are using. We are excited to see more organizations deploy their own BinderHubs for their communities. In the coming months, our goal is to create a federation of public BinderHubs
that operate in unison to serve the global user base of mybinder.org.

If this caught your attention consider joining the Binder community, or contributing to Project Binder! A good place to start is the Jupyter Community Forum or dive straight into the code on GitHub.

IPython 7.0, Async REPL

2018-09-27T17:41:00+00:00

Today we are pleased to announce the release of IPython 7.0, the powerful Python interactive shell that goes above and beyond the default Python REPL with advanced tab completion, syntactic coloration, and more. It’s the jupyter kernel for python used by millions of users, hopefully including you. This is the second major release of IPython since we stopped support for Python 2.

Not having to support Python 2 allowed us to make full use of new Python 3 features and bring never before seen capability in a Python Console. We are still encouraging library authors and users to look at the Python 3 Statement to learn about the end of life of Python 2 and how to stop support for Python 2 without breaking installation for Python 2 end users.

As developers and maintainers of IPython, it was a large gain of time to be able to only develop for a single version of python. Avoiding the use of conditional imports, being able to rely on type annotations, and make use of the newly available Python APIs were some of the advantages that made us more productive. Especially as most of the work on IPython is done by volunteers who work on nights and weekends, with only a couple of minutes here and there, this often made the difference between a patch reaching completion, or the contributor moving on to other pastures.

One of the core features we focused on for this release is the ability to (ab)use the async and await syntax available in Python 3.5+. There are of course many other improvements in this release you can read about in the what’s new.

Demo of awaiting coroutine in IPython 7.0

TL;DR: You can now use async/await at the top level in the IPython terminal and in the notebook, it should — in most of the cases — “just work”. Update IPython to version 7+, IPykernel to version 5+, and you’re off to the races.

See how to install IPython by reading the “what’s new”.

The recipes are currently building on conda-forge and should be available soon. For the time being you can install it via pip:

$ pip install ipython ipykernel --upgrade

A Primer on concurrency

You may have heard about async/await, threads, concurrency, preemptive scheduling and cooperative scheduling without really understanding what all this is about. If you are not familiar will all the above terms, all the hype may be confusing so let’s talk about concurrency in a really high level way.

Typically when your computer needs to execute many tasks, it will switch between them really fast, so from the human point of view it looks like everything is being processed at the same time. There are two main ways of doing so under the hood: Preemptive Scheduling, and Cooperative Scheduling.

With preemptive scheduling changing tasks can happen at any time. For example, while writing this blog post, I could stop in the middle of a word to start writing an email, which will itself be interrupted to check Gitter/Slack, before coming back, writing 5 words and stopping to get dinner.

TL;DR: Concurrency (from Geek And Poke, 2009)

With cooperative scheduling, the task switches can happen only at agreed spots. The term co-operative comes from the fact that tasks need to co-operate for the whole process to function. If a task decides to never take a break to let you to do something else, the illusion of many tasks being completed at once disappears.

Each approach has its own advantages and drawbacks, and we will not focus on these. Let’s just say that with co-operative scheduling async/await let you mark the areas where interruption is allowed to occur.

Moreover, async/await syntax allows cooperative scheduling in Python in a way that lets you write code that looks synchronous (without task switches), while actually being able to be interrupted, from the point of view of the computer. It also keeps the programmers from having to worry about global state changing under their feet, as this can occur only at the proximity of await keywords.

When going to a restaurant, social conventions (and common sense) tell us when and how these interactions can or cannot be interrupted, but programming languages need markers when using cooperative scheduling. These are asyncandawaitkeywords in Python.Asyncmarks a function that *may* be interrupted,awaitis required to call async-functions (akacoroutine`) and marks a point were task can be switched.

If you want to learn more we strongly recommend reading the Trio Tutorial Primer on async programming.

Async in the Python world

In the current Python ecosystem, packages tend to standardize around AsyncIO, provided in the Python standard library. AsyncIO can sometimes be judged as complex even by well known developers; this is in part due to the necessity of supporting other older asynchronous projects like twisted or tornado, but it’s also what makes a lots of its power: One event loop to rule them all.

Running a single async task requires you to learn about AsyncIO, write a non negligible amount of boilerplate code in order to fetch a single result. This can be especially cumbersome when doing interactive exploration, and likely will keep users from experimenting with AsyncIO code.

How to run a single async task in Python repl without async integration.

As Raymond Hettinger would says (slamming hand on podium): “There must be a better way”.

IPython AsyncIO Integration

Thanks to a multiple month effort (actually this work started close to 2 years ago), and the work of many talented people, you can now directly await code in the REPL and IPython will do “the right thing”.

Awaiting AsyncIO code should now automagically work.

With the new integration, you don’t have to import or learn about asyncio, deal with the loop yourself, or wrap your task in its own function. You are now able to just focus on the business logic and move along.

The only thing you need to remember is: If it is an async function you need to await it.

We hope that this will free users to experiment and play with asynchronous programming. Of course this will not magically make your code faster, or run in parallel, simply easier to write and reason about.

Other Async Libraries (aka: curio and trio integration)

The addition of async and await keyword in Python did not only simplify the use of asynchronous programing and the standardization around asyncio; it also allowed experimentation with new paradigms for asynchronous libraries. David Beazley created Curio, and Nathaniel Smith Trio, which both explore new ways to write asynchronous programs and explore how async, await and coroutines could be used when starting from a blank slate. The Trio documentation introduction and which problems it attempt to solve [1, 2, 3, 4, 5, 6] are highly recommended reading with varying level of technicality.

Interactive uses of libraries is key to getting insight and intuition on how a system works, intuition is critical to rapid prototyping, development and creation of higher levels of abstraction. It was natural for us to build support for Curio, Trio, (and potentially new other async libraries) into IPython.

You can setup IPython to run async code via Curio, or Trio and experiment or write production code using these libraries. To do so use the %autoawait magic, and tell it which library to use.

Defining an asynchronous function and spawning multiple concurrent task in IPython using Trio.

As you can see code looks really natural, and it is easy to forget that the above snippet is usually a syntax error in Python or older version of IPython. The astute reader and IPython expert will have suggested to use the %%time cell magic instead of doing it manually, though a couple of magics still need updates to properly handle async code. We look forward to your contribution on this front, and are excited to see what you can come up with.

Async in Notebooks (and other Jupyter Clients)

If you are a Jupyter user, you most likely use a Notebook interface, and interact with IPython via the ipykernel package.

Using AsyncIO in nteract desktop works out of the box with newer IPython and IPykernel

We’ve been working hard on making async code work in a notebook when using ipykernel. While most of the heavy lifting was done in IPython, the work in IPykernel was non-negligible, and required the accommodation of a number of use cases, which are not working. You now have to update both IPython to 7.0+ and ipykernel to version 5.0+ for async to be available. If you are using pip: $ pip install IPython ipykernel --update. As for conda, the packages should be available on conda-forge soon. With these new releases, async will work with all the frontends that support the Jupyter Protocol, including the classic Notebook, JupyterLab, Hydrogen, nteract desktop, and nteract web. The default code will run in the existing asyncio/tornado loop that runs the kernel. Integration with Trio and Curio is still available, but tasks will not be interleaved with the asyncio one — at least not yet. We welcome work on this front.

Submitting background tasks still requires you to access the asyncio event loop, and we are still be looking for contributions on this front as well, to make it even easier to run async code.

There are still some question on how to handle nested asyncio eventloop. It is indeed usually impossible to run nested eventloop, in the case of asyncio, trying to do so raises a RuntimeError the kernel already ran in and asyncio eventloop, calling directly or indirectly loop.run_until_complete and alike is not possible. There are discussions to use libraries like nest_asyncio as pointed out on this comment, but until those are more battle tested we do not want to commit a default solution in the core of IPython and let the ecosystem develop.

Future improvements

As far as we know, this is the first Async-aware Python REPL, and libraries like Trio/Curio are still young, thus there are still a number of use-cases we have not yet even thought about! We are encouraging you to come forward to talk about your use cases, what you tried and what did not work. There is also a number of new features to implement (making magics work with async, tab completion, background tasks) on which we would welcome new contributors.

Jupyter Blog - releases

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

JupyterLab 4.6 and Notebook 7.6 are out!

Enhancements shared by JupyterLab and Notebook

Notebook improvements

File browser: new column, editable breadcrumbs, open in terminal

Debugger: kernel sources filter, floating overlay

Keyboard navigation and accessibility

Keyboard shortcuts

Internationalization

Terminal enhancements

Inline completion enhancements

JupyterLab-specific enhancements

Layout and interface customization

Performance

Notebook-specific enhancements

Scratchpad console

Confirmation dialog when closing and shutting down a notebook

Miscellaneous

For extension authors

As large as minor releases go

Acknowledgements

Further reading

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

Support for collaboration without `RTC:` drive