Jupyter Blog - Jupyter Notebook

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.

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.

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.

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

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!

Jupyter Notebook format workshop outcomes

2023-04-12T17:40:00+00:00

Workshop Social Event challenging our senses

The Jupyter Community Workshop on the notebook file format took place at the Safran Campus near Paris from February 28th to March 2nd. It was a great opportunity to gather various Jupyter stakeholders from private and public affiliations to bootstrap new features for the Notebook file format.

Jupyter Community Workshops are a series of events designed to bring together small groups of Jupyter community members and core contributors for high-impact strategic work and community engagement on focused topics.

Community discussions

The community has lots of ideas to improve the Notebook format. So we split in three smaller groups with the aim of drafting Jupyter Enhancement Proposal (JEP): the markdown group, the text-format group and the cell types group.

The markdown group focused on backward compatible enhancement for the Markdown cells. The discussions focused on two subjects:

The specification of the Markdown flavor (pre-proposal): the goals are to specify which Markdown flavor (e.g. GitHub, CommonMark, MyST,…) is used for the cell source, how to store rendered output for easier cross-compatibility and what is the default Markdown flavor.
The persistence of user expression (pre-proposal): in order to display inline expressions within Markdown cells, the results obtained from the kernel should be stored in the notebook. This proposal aims to define the schema modification to store such information.

The text-format group lays out a specification for an official Jupyter notebook textual format. The discussion went on after the meeting to prepare that proposal.

Finally the cell-types group took the hypothesis of starting from the blank page to create the best Jupyter notebook format building on top of 10-years of experience. The discussion will take time to settle down on a new specification. So if you are interested, join the weekly discussion (see the meeting notes for all the details). In addition to the fully new specification, two backward compatible enhancements have been proposed:

Adding $schema to the notebook format and deprecate the nbformat version keys (see proposal).
Adding extraSchema to the notebook format to optionally extend the schema to specify in particular metadata (see pre-proposal).

Follow-up

Six JEP’s are foreseen from the workshop discussions. But as mentioned earlier, the community has lots of great other ideas (like SQL cells, low-/no-code cells for inputs or visualization). So we would like to encourage anyone interested by any Jupyter enhancement to open issue on the Jupyter Enhancement Proposals repository (see the guidelines for more information).

With the new Jupyter governance in place, the new Software Steering Council is responsible for ensuring those proposals get reviewed and go through the approval process.

Acknowledgements

I deeply want to thank all participants to the workshop that took the time (some of them despite time zone difference) to bring very constructive and thoughtful discussion.

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

We are also grateful to Safran Group for hosting this workshop and the NumFOCUS foundation for helping and mentoring this workshop organization.

Jupyter Community Workshop: The notebook file format

2022-12-08T16:09:00+00:00

We are excited to announce the next in-person Jupyter Community Workshop! It will focus on the Notebook file format.

Jupyter Community Workshops are a series of events designed to bring together small groups of Jupyter community members and core contributors for high-impact strategic work and community engagement on focused topics.

The Jupyter notebook file format has been around for 10 years. Its usage has grown in countless fields from teaching to data analysis in production pipelines. A great number of software applications and online services have added support for it.

We want this workshop to be an opportunity for various stakeholders to push forward the format while preserving its reusability in as many applications as possible. We could for example prototype a syntax for injecting variable values in Markdown cells, specify an alternative more textual format like RMarkdown, define the Markdown variant we support,… the boundary is our imagination. By the end of the workshop, we will submit those new specifications as Jupyter Enhancement Proposals to kick start the validation process for enhancing the official notebook format.

The workshop will last three days, with hands-on discussions, hacking sessions, and technical presentations. The goal of this event is to foster collaboration and the sharing of knowledge between maintainers of various platforms supporting the file format, downstream library authors and power users.

The workshop will be held at the Safran Campus in Paris suburb, France from February 28th to March 2nd, 2023. Travel funding assistance is available for attendees from academia and those from groups which are not well-represented within the Jupyter and wider tech community!

Application and all other details can be found in this form.

We are grateful to Safran Group for sponsoring this event. We are also grateful to the sponsors of the Jupyter Community Workshop series, Bloomberg and Amazon Web Services.

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.

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.

RetroLab — A JupyterLab distribution with a retro look and feel

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

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

RetroLab in action

Motivation

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

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

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

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

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

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

Notebooks, Files and Terminal

RetroLab supports Notebooks, Files and Terminals.

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

Working in a notebook with RetroLab

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

Creating a new Terminal

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

Open in a new Browser Tab by default

Zen Mode

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

Zen Mode

Support for existing JupyterLab prebuilt extensions

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

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

Installing a new JupyterLab extension and using it in RetroLab

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

Command Palette

RetroLab includes a command palette, just like in JupyterLab.

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

Using the command palette to restart the kernel

Themes

RetroLab also supports Dark Mode! 🕶️

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

Switching between the light and dark built-in themes

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

jupyter retro --retro-logo

The RetroLab logo with the JupyterLab Miami Nights Theme

Compact View on Mobile Devices

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

Compact layout by default on mobile devices

Next-gen JupyterLab features

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

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

Real Time Collaboration with RetroLab and JupyterLab

Installation

To install RetroLab with pip:

pip install retrolab

With mamba:

mamba install -c conda-forge retrolab

With conda:

conda install -c conda-forge retrolab

To try the prerelease with support for real time collaboration:

pip install --pre retrolab

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

Feedback, issues and pull requests are welcome!

Try it out on Binder

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

Next Steps

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

A couple of other initiatives have already started:

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

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

Prior Art

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

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

About the author

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

nbterm: Jupyter Notebooks in the terminal

2021-04-26T16:42:00+00:00

Jupyter notebooks are mostly known for their web-based user interface, such as JupyterLab or the Classic Notebook. They offer a great user experience, allow for rich output rendering, provide interactivity through e.g. widgets, and make possible working with remote kernels.

If just like me you tend to never leave the terminal in your workflow, you may be missing a tool to interact with Jupyter notebooks without switching to a web browser. While the Jupyter Console already allows you to interact with a Jupyter kernel in the terminal, it is more comparable to a shell than a notebook.

The notebook differs from the console in that it’s bound to a document, interleaving rich text and executable code. This makes the code representation more structured, while allowing for interactivity. Well, until recently this wasn’t possible in the terminal. But today, we are proud to announce nbterm!

Side-by-side comparison of the JupyterLab web notebook and nbterm.

Getting started with nbterm

Launching a notebook is as easy as entering:

$ nbterm my_notebook.ipynb

You can also create a new one if you don’t pass a notebook argument. Almost immediately, you will get a full-screen application that looks like this:

nbterm has other command line options:

$ nbterm --help
Usage: nbterm [OPTIONS] [NOTEBOOK_PATH]

Arguments:
  [NOTEBOOK_PATH]  Path to the notebook.  [default: ]

Options:
  --no-kernel                     Don't launch a kernel.
  --run                           Run the notebook.
  --save-path TEXT                Path to save the notebook.
  --version                       Show the version and exit.
  --help                          Show this message and exit.

For example, it is possible to run all cells of a notebook in batch mode, using:

$ nbterm --run my_notebook.ipynb

If you didn’t specify a new name with --save-path, a new notebook named my_notebook_run.ipynb will be created, with all cell outputs populated. This mode of execution is similar to the nbclient library, but accessible in the command line.

Embedding nbterm

It is also possible to use it as a library and embed it in your own application. Besides, all user interactions can be scripted. For instance, you can rearrange the cells and then run all cells like this:

import asyncio
from nbterm import Notebook

nb = Notebook("my_notebook.ipynb")
nb.cut_cell(3)
nb.paste_cell(1)
asyncio.run(nb.run_all())
nb.save()

A lightweight Jupyter stack

While you probably can’t tell the difference, nbterm doesn’t reuse the base Jupyter components such as jupyter-client and nbformat (respectively implementing the Jupyter kernel protocol and the Jupyter Notebook format). The reason is that nbterm was started as a toy project to see how hard it would be to have a minimalist notebook client.

As a Jupyter contributor, I am mostly involved in the maintenance and modernization of these packages. I wanted to experiment with a new project without the backward-compatibility constraints. This resulted in a rather lean code base, and its simplicity makes it suitable to serve as a reference for other language implementations.

The roadmap

While nbterm is obviously more limited than the Notebook, there are several potential improvement directions. Having rich(er) outputs is one of them. The terminal is pretty much limited to showing characters, but people have done great things with ASCII art. An attempt has been made a while ago with an ASCII back-end for matplotlib. And although it’s only on macOS for now, some terminals are capable of showing real pictures, and there exists a Matplotlib back-end for iTerm2.

Another nice feature would be to add some interactivity. In the Notebook, this is typically achieved using widgets, but they are inherently web-based, so this is not an option. Maybe we could imagine something similar to ipywidgets for the terminal, and have simple things like sliders, buttons, menus and such. I am keeping an eye on the awesome Rich library, with which you can already create dashboards, and GUI applications in the future.

Try it!

nbterm really has the look and feel of the Notebook you already know and love, with (almost) the same key bindings, so you won’t be lost. As coders, we love the terminal, and libraries like prompt-toolkit and Rich in Python, or cpp-terminal in C++, make it possible to build beautiful applications. You can install nbterm today using your favorite package manager:

$ pip install nbterm

or:

$ mamba install nbterm -c conda-forge

Be sure to update frequently, as it is improving every day. And if you want to contribute, please get in touch on the GitHub repository.

Acknowledgements

The development of nbterm is sponsored by QuantStack.

About the author

David Brochart is a scientific software developer at QuantStack. He is a contributor to several libraries in the Jupyter ecosystem, such as nbclient, jupyter-client, jupyter-server, ipykernel, and ipywidgets.

Open Redirect Vulnerability in Jupyter notebook, JupyterHub

2019-03-28T14:03:00+00:00

Update: notebook 5.7.7 and JupyterHub 0.9.5 contained incomplete fixes for this issue. 5.7.8 and 0.9.6 are released with more complete fixes.

JupyterHub ≤ 0.9.5 and Notebook ≤ 5.7.8 are affected. Versions 0.9.6 and 5.7.8 are released with fixes. Upgrade with pip or conda:

pip install --upgrade 'notebook>=5.7.8'
pip install --upgrade 'jupyterhub>=0.9.6'

conda install -c conda-forge 'notebook>=5.7.8'
conda install -c conda-forge 'jupyterhub>=0.9.6'

notebook 5.7.8 also fixes some compatibility issues and regressions introduced in 5.7.5 and 5.7.6, especially on some Windows systems. If you use the jupyterhub helm chart, version 0.8.2 upgrades JupyterHub to 0.9.6.

What is an Open Redirect Vulnerability?

Login pages tend to take a parameter for redirecting back to a page after successful login, e.g. /login?next=/notebooks/mynotebook.ipynb, so that you aren’t disrupted too much if you try to visit a page, but have to authenticate first. An Open Redirect Vulnerability is when a malicious person crafts a link pointing to the login page of a trusted site, but setting the “redirect after successful login” parameter to send the user to their own site, instead of a page on the authenticated site (the notebook or JupyterHub server), e.g. /login?next=http://badwebsite.biz. This doesn’t necessarily compromise anything immediately, but it enables phishing if users don’t notice that the domain has changed, e.g. by showing a fake “re-enter your password” page. Servers generally have to validate the redirect URL to avoid this. Both JupyterHub and Notebook already do this, but the validation didn’t take into account all possible ways to redirect to other sites, so some malicious URLs could still be crafted to redirect away from the server (the above example does not work in any recent version of either package). Only certain browsers (Chrome and Firefox, not Safari) could be redirected from the JupyterHub login page, but all browsers could be redirected away from a standalone notebook server.

This vulnerability has been assigned CVE-2019–10255. This post will be updated when it has been assigned. Thanks to Ronak Odhaviya for reporting the issue. You can report security issues by emailing ipython-security@googlegroups.com.

Jupyter notebook XSSI security fix

2019-03-09T20:46:00+00:00

We have just released Jupyter notebook 5.7.6 with a security fix for a cross-site inclusion (XSSI) vulnerability, where content from a Jupyter server could be included in another page if the visitor is logged in to the Jupyter server and the author of the page knows the URL of the server and the path within the server’s notebook directory that they would like to include. Further, it has been demonstrated with the Internet Explorer browser that some content from the accessed file can be retrieved by the attacking page. This has not yet been demonstrated with other browsers, however.

To upgrade:

pip install --upgrade 'notebook>=5.7.6'

or conda:

conda install 'notebook>=5.7.6'

This vulnerability was reported by the HackerOne hacker Abhishek Bundela, via Jonathan Kamens at Quantopian. The patch was developed by Min Ragan-Kelley with help from Devdatta Akhawe. Jupyter is grateful to Quantopian’s bug bounty program, which has found and reported this and other security flaws in Jupyter.

This vulnerability has been assigned CVE-2019–9644.

Jupyter Notebook security fixes

2018-11-19T22:20:00+00:00

Two security issues have been found and fixed this week, where untrusted javascript could be executed if malicious files could be delivered to the users system and the user takes specific actions with those malicious files.

The first allowed nbconvert endpoints (such as Print Preview) to render untrusted HTML and javascript with access to the notebook server. This is fixed in notebook 5.7.1. All notebook versions prior to 5.7.1 are affected. Thanks to Jonathan Kamens of Quantopian for reporting. This issue has been assigned CVE-2018–19351.

The second issue allowed maliciously crafted directory names to execute javascript when opened in the tree view. This is fixed in notebook 5.7.2. All versions of notebook from 5.3.0 to 5.7.1 are affected. Thanks to Marvin Solano Quesada for reporting. This issue has been assigned CVE-2018–19352.

You can check your version of the notebook package by issuing the following command:

jupyter notebook --version

Whether you are using classic notebook, JupyterLab or any other notebook server extensions, we recommend that you update the notebook package with :

pip install --upgrade notebook

or if you are using conda-forge

conda upgrade notebook

Thanks especially to Jonathan and Marvin for reporting these issues! If you find a security issue in a Jupyter project, please report it to security@ipython.org.

Security fix for Jupyter Notebook

2018-07-18T04:31:00+00:00

We have just released Jupyter Notebook 5.6.0. This release fixes a vulnerability that could allow a maliciously crafted notebook to execute JavaScript when it is opened, bypassing the trusted-notebook mechanism.

We recommend updating the notebook immediately, via pip:

pip install notebook>=5.6.0

or conda:

conda install notebook>=5.6.0

Affected versions: all releases prior to 5.6.0

JupyterLab users are affected, independent of the version of JupyterLab itself. Upgrading the notebook package to 5.6.0 resolves the issue for users of both JupyterLab and the classic notebook.

A CVE has been requested for the vulnerability. Release notes for 5.6.0 and this post will be updated as the CVE is assigned. More details of the vulnerability will be released in 30 days, on August 16, 2018.

Security reports for Jupyter are greatly appreciated. You can report security issues to security@ipython.org.

Thanks to Jonathan Kamens for reporting this issue to the security list.

[Update July 28] The vulnerability have been assigned number CVE-2018–1999024.

[Update August 16] MathJax versions prior to version 2.7.4 contains a Cross Site Scripting (XSS) vulnerability in the \unicode{} macro that can result in potentially untrusted Javascript running within a web browser, for example at notebook load. Notebook 5.6.0 ships with an updated mathjax version 2.7.4 which fixes this vulnerability.

Jupyter Notebook 5.5.0

2018-05-25T00:11:00+00:00

We are pleased to announce the release of Jupyter Notebook 5.5.0. This is a minor release that introduces some new features such as:

Dynamic Download as… menu for nbconvert exporters
Download as Reveal.js slides
Quit button for stopping the notebook server from the dashboard
File size for files in the dashboard

This release also includes many bug fixes and enhancements as well as improvements to our documentation and testing infrastructure.

You can install the new version of the notebook now using pip:

pip install --upgrade notebook

Or conda:

conda upgrade notebook

Changelog

New features:

The files list now shows file sizes (PR #3539)
Add a quit button in the dashboard (PR #3004)
Display hostname in the terminal when running remotely (PR #3356, PR #3593)
Add slides exportation/download to the menu (PR #3287)
Add any extra installed nbconvert exporters to the “Download as” menu (PR #3323)
Editor: warning when overwriting a file that is modified on disk (PR #2783)
Display a warning message if cookies are not enabled (PR #3511)
Basic __version__ reporting for extensions (PR #3541)
Add NotebookApp.terminals_enabled config option (PR #3478)
Make buffer time between last modified on disk and last modified on last save configurable (PR #3273)
Allow binding custom shortcuts for ‘close and halt’ (PR #3314)
Add description for ‘Trusted’ notification (PR #3386)
Add settings['activity_sources'] (PR #3401)
Add an output_updated.OutputArea event (PR #3560)

Bug fixes:

Fixes to improve web accessibility (PR #3507)
There is more to do on this! See #1801.
Fixed color contrast issue in tree.less (PR #3336)
Allow cancelling upload of large files (PR #3373)
Don’t clear login cookie on requests without cookie (PR #3380)
Don’t trash files on different device to home dir on Linux (PR #3304)
Clear waiting asterisks when restarting kernel (PR #3494)
Fix output prompt when execution_count missing (PR #3236)
Make the ‘changed on disk’ dialog work when displayed twice (PR #3589)
Fix going back to root directory with history in notebook list (PR #3411)
Allow defining keyboard shortcuts for missing actions (PR #3561)
Prevent default on pageup/pagedown when completer is active (PR #3500)
Prevent default event handling on new terminal (PR #3497)
ConfigManager should not write out default values found in the .d directory (PR #3485)
Fix leak of iopub object in activity monitoring (PR #3424)
Javascript lint in notebooklist.js (PR #3409)
Some Javascript syntax fixes (PR #3294)
Convert native for loop to Array.forEach() (PR #3477)
Disable cache when downloading nbconvert output (PR #3484)
Add missing digestmod arg to HMAC (PR #3399)
Log OSErrors failing to create less-critical files during startup (PR #3384)
Use powershell on Windows (PR #3379)
API spec improvements, API handler improvements (PR #3368)
Set notebook to dirty state after change to kernel metadata (PR #3350)
Use CSP header to treat served files as belonging to a separate origin (PR #3341)
Don’t install gettext into builtins (PR #3330)
Add missing import _ (PR #3316, PR #3326)
Write notebook.json file atomically (PR #3305)
Fix clicking with modifiers, page title updates (PR #3282)
Upgrade jQuery to version 2.2 (PR #3428)
Upgrade xterm.js to 3.1.0 (PR #3189)
Upgrade moment.js to 2.19.3 (PR #3562)
Upgrade CodeMirror to 5.35 (PR #3372)
“Require” pyzmq>=17 (PR #3586)

Documentation:

Documentation updates and organisation (PR #3584)
Add section in docs about privacy (PR #3571)
Add explanation on how to change the type of a cell to Markdown (PR #3377)
Update docs with confd implementation details (PR #3520)
Add more information for where jupyter_notebook_config.py is located (PR #3346)
Document options to enable nbextensions in specific sections (PR #3525)
jQuery attribute selector value MUST be surrounded by quotes (PR #3527)
Do not execute special notebooks with nbsphinx (PR #3360)
Other minor fixes in PR #3288, PR #3528, PR #3293, PR #3367

Testing:

Testing with Selenium & Sauce labs (PR #3321)
Selenium utils + markdown rendering tests (PR #3458)
Convert insert cell tests to Selenium (PR #3508)
Convert prompt numbers tests to Selenium (PR #3554)
Convert delete cells tests to Selenium (PR #3465)
Convert undelete cell tests to Selenium (PR #3475)
More selenium testing utilities (PR #3412)
Only check links when build is trigger by Travis Cron job (PR #3493)
Fix Appveyor build errors (PR #3430)
Undo patches in teardown before attempting to delete files (PR #3459)
Get tests running with tornado 5 (PR #3398)
Unpin ipykernel version on Travis (PR #3223)

Credits

This release has been a team effort and we would like to thank the following 36 people who contributed:

Arovit Narula (arovit)
Ashley Teoh (ashleytqy)
Nicholas Bollweg (bollwyvl)
Alex Rothberg (cancan101)
Celina Kilcrease (ckilcrease)
dabuside (dabuside)
Damian Avila (damianavila)
Dana Lee (danagilliann)
Dave Hirschfeld (dhirschfeld)
Heng GAO (ehengao)
Leo Gallucci (elgalu)
Evan Van Dam (evandam)
forbxy (forbxy)
Grant Nestor (gnestor)
Ethan T. Hendrix (hendrixet)
Miro Hrončok (hroncok)
Paul Ivanov (ivanov)
Darío Hereñú (kant)
Kevin Bates (kevin-bates)
Maarten Breddels (maartenbreddels)
Michael Droettboom (mdboom)
Min RK (minrk)
M Pacer (mpacer)
Peter Parente (parente)
Paul Masson (paulmasson)
Philipp Rudiger (philippjfr)
Mac Knight (Shels1909)
Hisham Elsheshtawy (Sheshtawy)
Simon Biggs (SimonBiggs)
Sunil Hari (sunilhari)
Thomas Kluyver (takluyver)
Tim Klever (tklever)
Gabriel Ruiz (unnamedplay-r)
Vaibhav Sagar (vaibhavsagar)
William Hosford (whosford)
Hong (xuhdev)

We look forward to your feedback and contributions!

Jupyter Notebook 5.3.0

2018-01-17T15:59:00+00:00

We are pleased to announce the release of Jupyter Notebook 5.3.0. This is a minor release that introduces some notable improvements, such as terminal support for Windows and support for operating system trash (files deleted from the notebook dashboard are moved to the trash vs. deleted permanently), as well as many bug fixes and enhancements

You can install the new version of the notebook now using pip:

pip install --upgrade notebook

Or conda (it may be a few days before packages are available):

conda upgrade notebook

Changelog

Add support for terminals on windows (#3087).
Add a “restart and run all” button to the toolbar (#2965).
Send files to os trash mechanism on delete (#1968).
Allow programmatic copy to clipboard (#3088).
Use DOM History API for navigating between directories in the file browser (#3115).
Add translated files to folder(docs-translations) (#3065).
Allow non empty dirs to be deleted (#3108).
Set cookie on base_url (#2959).
Allow token-authenticated requests cross-origin by default (#2920).
Change cull_idle_timeout_minimum to 1 from 300 (#2910).
Config option to shut down server after n seconds with no kernels (#2963).
Display a “close” button on load notebook error (#3176).
Add action to command pallette to run CodeMirror’s “indentAuto” on selection (#3175).
Add option to specify extra services (#3158).
Warn_bad_name should not use global name (#3160).
Avoid overflow of hidden form (#3148).
Fix shutdown trans loss (#3147).
Find available kernelspecs more efficiently (#3136).
Don’t try to translate missing help strings (#3122).
Frontend/extension-config: allow default json files in a .d directory (#3116).
Use requirejs vs. require (#3097).
Fixes some ui bugs in firefox #3044 (#3058).
Compare non-specific language code when choosing to use arabic numerals (#3055).
Fix save-script deprecation (#3053).
Include moment locales in package_data (#3051).
Fix moment locale loading in bidi support (#3048).
Tornado 5: periodiccallback loop arg will be removed (#3034).
Use /files prefix for pdf-like files (#3031).
Add folder for document translation (#3022).
When login-in via token, let a chance for user to set the password (#3008).
Switch to jupyter_core implementation of ensure_dir_exists (#3002).
Send http shutdown request on ‘stop’ subcommand (#3000).
Work on loading ui translations (#2969).
Fix ansi inverse (#2967).
Add send2trash to requirements for building docs (#2964).
I18n readme.md improvement (#2962).
Add ‘reason’ field to json error responses (#2958).
Add some padding for stream outputs (#3194).
Always use setuptools in setup.py (#3206).
Fix clearing cookies on logout when base_url is configured (#3207).

Credits

This release has been a team effort and we would like to thank the following 21 people who contributed:

bacboc (bacboc)
Steven Silvester (blink1073)
Matthias Bussonnier (Carreau)
ChungJooHo (ChungJooHo)
edida (edida)
Francesco Franchina (ferdas)
forbxy (forbxy)
Grant Nestor (gnestor)
Josh Barnes (jcb91)
JocelynDelalande (JocelynDelalande)
Karthik Balakrishnan (karthikb351)
Kevin Bates (kevin-bates)
Kirit Thadaka (kirit93)
Maarten Breddels (maartenbreddels)
Madhu94 (Madhu94)
Matthias Geier (mgeier)
Michael Heilman (mheilman)
Min RK (minrk)
PHaeJin (PHaeJin)
Sukneet (Sukneet)
Thomas Kluyver (takluyver)

We look forward to your feedback and contributions!

Public Notebooks and Security

2017-11-28T19:33:00+00:00

tl;dr: don’t disable notebook authentication!

Let’s chat a little bit about public Jupyter notebook servers and security. A lot of folks run notebook servers that are publicly accessible, whether they are the access point to a cloud server or remote access to their home or office computer. This is great! It is important to keep in mind that, since arbitrary code execution is the main point of IPython and Jupyter, running a publicly accessible server without authentication or encryption is a very bad idea indeed. Prior to notebook 4.3, this was the default behavior of Jupyter, which has led to a lot of insecure notebook servers running on cloud services. One aspect that may not be apparent is that people can find your public notebook server, especially if it is on one of the popular cloud providers. Systematic port scans will turn up notebook servers, especially for those running on the default port of 8888. And Jupyter has become popular enough (🎉) that we know people are doing this (😠). Running a publicly accessible notebook server without authentication is making your computing resources free for the world to use.

The highlights to keep in mind:

Always enable a password or token for publicly accessible notebook servers (this includes shared computers)
Use HTTPS for authenticated notebooks over the Internet
Unsecured public notebook servers are discoverable
Running on a cloud service should be treated as if it’s publicly accessible

The first two points shouldn’t be new information, and anyone following the documentation should be adding basic authentication when exposing a server to the public. If you are already accessing a notebook server over https with a password or token, you have nothing to worry about. However, if you are running unsecured notebook servers on the Internet, please stop and enable a password. The latter points are important and may not be obvious, but the gist is: don’t disable notebook authentication, even if you think your bases are covered via other means.

In notebook 4.3, a token is enabled by default, making it a little bit more inconvenient to run a totally insecure notebook server. We can’t feasibly require HTTPS by default, but free, trusted HTTPS has never been easier, thanks to LetsEncrypt. If you can’t assign a domain name to your server, self-signed certificates can be used, with some caveats (notably: Safari requires self-signed certificates be trusted at the system level before it will allow websocket connections). For shared deployments, you can also use JupyterHub, which allows you to authenticate notebooks via the system (PAM) or OAuth providers such as GitHub, Google, etc.

Be safe out there.

Jupyter Blog - Jupyter Notebook

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

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

JupyterLab 4.4 and Notebook 7.4 are available!

Code console improvements

Settings import and export

Workspace indicator

Support for collaboration without RTC: drive

Kernel subshells support

Context menu opt-out

Slimmer status bar

Walkthrough video

Acknowledgements

JupyterLab 4.3 and Notebook 7.3 are available!

Minimap

Fullscreen mode

File browser enhancements

Server-side execution and collaboration

Improved kernel and server interactions

Full Width Notebook

JupyterLab 3 end of maintenance

Acknowledgements

JupyterLab 4.2 and Notebook 7.2 are available!

Easier Workspaces Management with GUI

Recently opened/closed files

Full notebook windowing mode by default

Improved Shortcuts Editor

Dark High Contrast Theme

Keyboard Shortcuts

Acknowledgements

JupyterLab 4.1 and Notebook 7.1 are here 🎉

Custom CSS

Diagrams in Markdown

Inline code completion

Keyboard navigation improvements

Execution history in notebook

Opening files from tracebacks

Error indicator in the table of contents

Plugin Manager

Virtual scrollbar for notebook in windowed mode

Notifications

Full notebook windowing mode improvements

Search improvements

Acknowledgements

Announcing Jupyter Notebook 7

A Familiar Document-Oriented Experience

Visual Debugger

Real-Time Collaboration

Theming and Dark Mode

Support for collaboration without `RTC:` drive