Jupyter Blog - releases

JupyterHub 6.0

2026-09-11T08:54:00+00:00

JupyterHub is a collection of tools that provides standardized, user-friendly computing environments for education and research. Today, we’re pleased to announce the release of JupyterHub 6.0. This is a substantial release with several new features. The breaking changes ought to be minimal, and should affect very few deployments. There is a small database schema upgrade, so make sure to backup your database prior to upgrading, as usual.

Some changes to highlight:

Stricter named server rules: Named servers now have stricter rules on their names, and a new less-restricted “display name” field. This might be the most significant change affecting you! See the documentation for more details.
Python 3.10 and database upgrade: JupyterHub 6.0 now requires Python 3.10 and includes a database schema upgrade. Make sure to back up your database before upgrading.
Updates to metrics: The old StatsD metrics have been removed, in favor of the Prometheus metrics that most people are already using. For Spawner (and spawn hook) authors, JupyterHub 6.0 also introduces SpawnException, which provides more granular information for classifying spawn failures in metrics, to help deployments separate errors from rejections.
Internal communication changes: JupyterHub now uses aiohttp for internal HTTP requests, which may require tuning for large deployments since internal HTTP requests. This update has facilitated using unix sockets for internal communication on single-node deployments.
Improved granularity in API access: JupyterHub provides new API endpoints for working with single servers, along with more flexible ways to define permissions, such as start:servers scope and extra_user_scopes.
See the documentation for more information.

Beyond these main changes, there have been lots of other improvements and bugfixes. You can find more details in the upgrading documentation and changelog.

Thank you to our contributors

The following people contributed discussions, new ideas, code and documentation contributions, and review: agoose77, anny0811, ateucher, betatim, bl-aire, clhedrick, consideRatio, dometto, dragz, erawn, ericvd-ucb, jezwilkinson, jnywong, jrdnbradford, kellyrowland, kreuzert, LUC4R4T0R, manics, mayli, milliams, minrk, mynkyu, nsychev, Paul2708, Rameshkumar31595, rgaiacs, shaneknapp, sixonenines, tbizouerne, Tech-Abhang, wilkinvr, willingc, yuvipanda

JupyterGIS 0.16: New visualization capabilities, collaborative Story Maps, and more

2026-08-24T16:09:00+00:00

Read this article in Notebook.link, as a live story-map! https://notebook.link/@martinRenou/jupytergis-announcement

Earlier this year, we introduced STAC browsing and Story Maps in JupyterGIS, making it easier to discover geospatial datasets and communicate results without leaving Jupyter.

JupyterGIS 0.16 continues in the same direction. This release adds support for new geospatial formats, tighter integration with the scientific Python ecosystem, a redesigned Story Map editor, and a more expressive way to style geographic data.

Story Maps are getting a new look!

Story Maps in JupyterGIS let you build a scrollable presentation around your map. A Story Map is made up of a sequence of segments that can combine Markdown content with map views, so you can guide the reader through a geographic story as they scroll.

Each segment can define its own map state, including the current map location, visible layers, and layer styling. This means that the map can change as the reader moves through the story: layers can appear or disappear, the view can move to a new location, and symbology can change to highlight different aspects of the data.

Story Maps have received a significant update in this release.

Read this article in Notebook.link, as a live story-map! https://notebook.link/@martinRenou/jupytergis-announcement

The Story-map associated to this release annoucement. It contains Text, images, and map views with associated layer states.

A better Story Maps editing experience

We’ve also made substantial improvements to the Story Map editing experience.

The editor has been redesigned around Jupyter’s real-time collaboration infrastructure, allowing multiple people to edit the same Story Map simultaneously. Changes appear immediately for everyone, making it much easier to prepare presentations, reports, or educational material as a team.

Collaboratively edit the Story Map markdown.

The editor now gives you a much better sense of what the final story will look like while you are working on it. Markdown sections can be previewed directly in the editor, and a new Story Map preview makes it possible to see the complete presentation without leaving the editing workflow. This makes it easier to write, arrange, and refine a story while keeping an eye on the final result. We’ve also introduced a new layout that is better suited for long-form content. In addition to guided geographic narratives, Story Maps can now be used to create richer articles combining text, maps, images, and other interactive content.

New Story Map editor: Set story segment viewport, preview markdown, set layers properties for the story segment.

OpenEO layers

More and more geospatial workflows rely on remote processing instead of downloading datasets locally. openEO provides a common API to describe these processing pipelines as process graphs that are executed by a backend.

JupyterGIS can now display openEO process graphs directly as map layers. Instead of exporting intermediate results before visualizing them, you can connect an openEO backend and inspect the output of your processing pipeline directly in the map.

The visualization is tile-based and lazy: JupyterGIS only requests the data needed for the current map view and zoom level. This makes it possible to explore large remote sensing workflows interactively, without materializing the full result locally.

JupyterGIS can make use of any openEO server that supports tiling, such as titiler-openeo

import openeo
from jupytergis import GISDocument
from openeo.processes import process

connection = openeo.connect(SERVER_URL)
connection.authenticate_basic(username=BASIC_AUTH, password=BASIC_AUTH)

cube = connection.load_collection(
    "sentinel-2-global-mosaics",
    bands=["B03", "B08"],
    temporal_extent=["2022-04-15", "2022-12-31"],
)

cube = cube.reduce_dimension(
    dimension="t",
    reducer="first",
)

cube = cube / 10000.0

# NDWI = (GREEN - NIR) / (GREEN + NIR)
ndwi = cube.ndvi(nir="0", red="1")

ndwi_vis = (ndwi + 1) / 2

ndwi_png = ndwi_vis.linear_scale_range(
    input_min=0,
    input_max=1,
    output_min=0,
    output_max=255,
)

result = ndwi_png.save_result(format="PNG")

doc = GISDocument(latitude=40.75, longitude=-73.95, zoom=12)
await doc.ready()
doc.add_openeo_tile_layer(result)
doc

Define a process graph to compute a NDWI, using the Python API of OpenEO and JupyterGIS. It is then lazily evaluated on a per-tile basis while the user pans/zooms on the map.

In addition to defining openEO process graphs from the scripting Python API, JupyterGIS provides an advanced openEO process graph editor, allowing you to:

connect to an openEO tile server
define the graph graphically, with boxes and arrows
load data collections and define processes with a drag-and-drop UI
directly edit the JSON content

Editing an openEO process graph from the JupyterGIS front-end

Another interesting aspect of openEO is that process graphs have a well-defined, declarative JSON representation. Because of this structured format, they are a natural target for LLM-assisted workflows. Users can describe the analysis they want in natural language, have an LLM generate or refine the corresponding process graph (e.g. using jupyterlite-ai), and immediately visualize the result in JupyterGIS. Combined with the lazy, tile-based rendering, this makes it possible to quickly iterate on processing pipelines without waiting for complete datasets to be exported or downloaded.

Lazy visualization of Xarray datasets with jupyter-tiler

JupyterGIS now integrates with the new jupyter-tiler package, making it straightforward to visualize Xarray datasets from Python.

Datasets can come from anywhere: they may already exist in your notebook, or they can be loaded on demand from a STAC catalog using stackstac. Once you have an Xarray object, JupyterGIS can display it in the map without requiring an export to another format.

Rendering happens lazily, generating only the tiles needed for the current view. This makes it possible to explore datasets that are much larger than memory while keeping navigation responsive.

The result is a smoother workflow from data loading, to analysis, to visualization, all within the same notebook.

await doc.add_data_array_layer(
    name="NDSI Layer",
    data_array=ndsi,
    colormap_name="viridis",
    colormap_range=(-1, 1),
)

Visualizing an Xarray dataset in JupyterGIS.

This feature requires the optional dependency jupyter-tiler to be installed.

pip install jupyter-tiler

A more expressive symbology model

Styling geographic data often requires combining multiple visual properties to communicate patterns effectively.

JupyterGIS 0.16 introduces a new symbology model inspired by the Grammar of Graphics. Instead of relying on a fixed set of styling options, visual properties such as color, size, and opacity can be defined in a more flexible and composable way.

This makes it easier to build everything from simple thematic maps to more advanced visualizations while keeping styling definitions consistent and reproducible.

A symbology example: apply a Viridis color map to the circle colors, a linear scale to the radius of circles, and a fixed stroke color.

GeoZarr and GeoPackage support

This release also expands the range of formats that JupyterGIS can open directly.

Support for GeoZarr makes it possible to work with cloud-native multidimensional geospatial datasets, while GeoPackage support improves interoperability with existing GIS software and common data exchange workflows.

New Collaborative Editing Capabilities

JupyterGIS 0.16 also brings collaborative editing to vector layers. When working on a shared JupyterGIS document, multiple users can now edit the same vector data at the same time.

Features can be created, moved, and edited collaboratively, with changes synchronized in real time between users. This makes it possible to work together on tasks such as digitizing features, annotating a map, or refining a dataset without having to exchange files or manually merge changes.

Combined with the collaborative Story Map editor, this makes collaboration a more integral part of JupyterGIS: users can work together on the data itself, and then use the same shared document to explore and communicate their results.

A new R API

JupyterGIS 0.16 also introduces an R client, bringing JupyterGIS to R users through the new r-jupytergis package. The R client provides bindings for interacting with JupyterGIS widgets from an R notebook, using the same JavaScript front-end as the Python client.

The main interface is the GISDocument widget, which can be used to create and manipulate JupyterGIS documents directly from R. This makes it possible to build geospatial workflows in R while using the same interactive map interface available to Python users.

The R client also uses the same underlying collaborative infrastructure as the Python client, including the Yrs CRDT library. This means that R users can participate in the same collaborative JupyterGIS workflows rather than working in a separate environment.

doc <- GISDocument$new("france_hiking.jGIS")
layer <- doc$add_raster_layer(
    url = "https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}",
    name = "Google Satellite",
    attribution = "Google",
    opacity = 0.6
)

Bug fixes and performance improvements

As usual, this release also includes many smaller improvements throughout the project.

We’ve fixed a number of bugs, improved performance in several parts of the application, and continued polishing both the user interface and the Python API.

JupyterGIS continues to evolve as a collaborative GIS environment that fits naturally within the Jupyter ecosystem. Whether your workflow starts from a notebook, a STAC catalog, an openEO backend, or a local dataset, the goal remains the same: make it easier to move between analysis, visualization, and communication without switching tools.

Acknowledgements

This work on JupyterGIS by QuantStack was funded by the European Space Agency (ESA) for the Story-maps development, the R API, openEO layers support and the collaborative labelling. Additionally, QuantStack was funded by the French National Centre for Space Studies (CNES) for the lazy visualization of xarray datasets.

Contributors to this release

By order of number of contributions:

Arjun Verma is a Developer at QuantStack. He worked on the server-side geoprocessing infrastructure and on the openEO editor in the JupyterGIS front-end.

Martin Renou is a Technical Director at QuantStack and a maintainer of JupyterGIS. For this release, Martin coordinated and guided much of the development, and worked on the integration of openEO layers.

Gregory Mooney is a Developer at QuantStack and a long-time contributor to JupyterGIS. He led much of the work on the new Story Map editor and its collaborative editing capabilities.

Matthias Meschede is Chief Operating Officer at QuantStack. He introduced the new Grammar of Graphics-inspired symbology model, bringing a more expressive and composable approach to styling geographic data.

Matt Fisher is the Community Manager of GeoJupyter. He contributed to many of the discussions around the release and helped shape several of the design decisions across the project.

Nakul Verma is an open-source contributor to JupyterGIS. He contributed numerous bug fixes and improvements throughout the release, and introduced support for Vega expressions in the new symbology system.

Antoine Prouvost is a Developer at QuantStack. He led the initial work on the R API for JupyterGIS, building its first skeleton and establishing the foundations for the r-jupytergis package.

Sandrine Pataut is a Developer at QuantStack. She worked on bringing many of JupyterGIS’s features to the R API, helping make the new client more complete and useful for R users.

We are grateful to everyone who contributed code, reviews, ideas, discussions, and feedback to this release. JupyterGIS continues to benefit from an increasingly diverse community of contributors, and we look forward to seeing what comes next!

JupyterLite 0.8 is released! 🎉

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

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

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

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

Refreshed Loading Screen

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

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

File System Reliability Improvements

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

JupyterLab 4.6 and Notebook 7.6

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

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

A Terminal in the Browser

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

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

Running terminal commands in the browser

More Kernels with jupyterlite-xeus

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

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

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

Python 3.14 with the Pyodide Kernel

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

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

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

Pyodide 314 in JupyterLite

JavaScript Kernel Improvements

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

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

Jupyter Widgets and dynamic imports with the JavaScript kernel

Try it in your browser

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

Acknowledgments

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

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

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

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

JupyterLab 4.6 and Notebook 7.6 are out!

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

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

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

Overview of some user interface enhancements visible in JupyterLab UI

Enhancements shared by JupyterLab and Notebook

Notebook improvements

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

Clicking the highlighted button will jump to a previously edited cell

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

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

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

Dialog shown when deleting a cell from cell tollbar

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

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

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

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

New date created column in file browser

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

Editable breadcrumbs

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

Opening terminal for a specific directory is now easier.

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

Debugger: kernel sources filter, floating overlay

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

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

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

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

Keyboard navigation has been improved across several components:

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

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

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

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

Keyboard shortcuts

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

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

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

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

Internationalization

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

Terminal enhancements

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

Inline completion enhancements

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

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

JupyterLab-specific enhancements

Layout and interface customization

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

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

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

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

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

Performance

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

Notebook-specific enhancements

Scratchpad console

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

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

Confirmation dialog when closing and shutting down a notebook

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

Miscellaneous

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

For extension authors

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

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

As large as minor releases go

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

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

Acknowledgements

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

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

And thank you to returning contributors for their continued work!

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

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

What’s New in MyST Markdown 1.8.2

2026-03-26T15:10:00+00:00

The Jupyter Book team just released mystmd 1.8.2 and a new version of the MyST react theme! Below are a few things that stand out.

Interactive widgets with the `{anywidget}` directive

You can now embed JavaScript widgets in your MyST pages using the new {anywidget} directive. Widgets follow the anywidget specification, which gives plugin authors an extension point for embedding JS capabilities in their documents.

A widget is a JavaScript module that exports a render function. You pass it initial state as JSON in the directive body, and it renders an interactive element on the page. You could use this for interactive figures, explorable explanations, or custom visualizations without leaving MyST.

A little confetti demo that we use to show off embedding widgets in a MyST document with anywidget!

Note: Widget support is experimental. The interfaces may change as we learn more about usage patterns. Only load widgets from sources you trust, since they execute JavaScript in the reader’s browser!

Table of contents improvements

The {toc} directive now supports a children context option, which lets you display only the child pages of the current page rather than the full project table of contents. Use it on landing pages and index pages that introduce a section and link to its sub-pages. You can see an example in the Jupyter Book getting started guide.

Better link handling across multi-site projects

If your project spans multiple domains (e.g., a docs site and a blog), you can now configure a domain to be treated as “internal” for link styling. Links to that domain will look like in-site navigation instead of external links. Check out the Getting Started guide for an example.

Upgrade

To get the latest version of mystmd:

npm install -g mystmd

or for pip users:

pip install -U mystmd

The theme updates automatically. Delete your _build folder and mystmd will download the latest theme on your next build.

Changelogs

Find an ongoing list of releases in the Jupyter Book ecosystem here:

jupyterbook.org/releases

You can also read the original mystmd release notes and myst-theme release notes.

JupyterLite 0.7 is released! 🎉

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

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

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

Workspace Support

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

Workspaces are now supported in JupyterLite

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

Audio and Video Playback

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

Open audio and video files in JupyterLite

Basic Interrupt Functionality

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

The stop button now cancels the execution of scheduled cells

Basic Notebook Export

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

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

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

Basic notebook exports are now available

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

Download a notebook using the file menu entry

Enhanced Markdown Support

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

JupyterLab 4.5 and Notebook 7.5

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

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

Walkthrough video

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

Try it in your browser

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

Acknowledgments

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

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

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

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

JupyterLab 4.5 and Notebook 7.5 are available!

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

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

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

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

Performance and windowing

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

Notebook improvements

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

Open a notebook without a kernel

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

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

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

Debugger and Console improvements

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

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

JupyterLab 4.5 includes many improvements to the debugger

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

New search functionality inside terminals

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

Search is now compatible with terminals

Media and content support

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

Open audio and video files in JupyterLab

File browser enhancements

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

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

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

JupyterLab 4.5 includes many improvements to the file browser

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

Keyboard shortcuts and commands

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

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

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

Settings

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

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

User interface and accessibility

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

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

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

Update from JupyterCon

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

Acknowledgements

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

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

And thank you to returning contributors for their continued work!

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

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

JupyterLite 0.6.0 is released! 🎉

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

JupyterLite 0.6.0 includes a number of new features, bug fixes, and enhancements and significant improvements to the user interface.

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

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

Interactive Input Support

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

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

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

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

New REPL Options

The REPL exposes new options as URL parameters:

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

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

A single executable cell in JupyterLite

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

Execute code
Restart the kernel
Clear the cells
Switch the kernel

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

Kernel Indicator and Logs

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

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

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

Kernel logs can help troubleshoot JupyterLite issues

Clear Browser Data

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

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

The confirmation dialog for clearing browser data

Loading indicator

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

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

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

Settings import and export

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

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

The new export and import buttons in the Settings Editor

Plugin Manager

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

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

The plugin manager lists active plugins in a JupyterLite deployment

Improved Multi-site Contents Management

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

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

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

Multi-Tab File System Access

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

Extension system

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

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

JupyterLab 4.4 and Notebook 7.4

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

Kernel and other updates

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

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

Closing the gap with JupyterLab

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

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

Using in-browser and regular kernels together

⚠️ This is still very experimental!

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

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

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

Promoting in-browser as regular kernels

Migrating to 0.6.0

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

Walkthrough video

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

Try it in your browser

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

Acknowledgments

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

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

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

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

JupyterLab 4.4 and Notebook 7.4 are available!

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

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

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

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

Code console improvements

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

Execute code
Restart the kernel
Clear the cells
Switch the kernel

Changing the position of the prompt cell in JupyterLab code consoles

Additional settings for console behavior have been added:

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

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

The code console configured as a single executable cell

Settings import and export

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

Import and export settings from the Settings Editor

Workspace indicator

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

The workspace indicator

Support for collaboration without `RTC:` drive

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

Kernel subshells support

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

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

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

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

Creating a new subshell console for a notebook in JupyterLab 4.4

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

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

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

Slimmer status bar

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

Walkthrough video

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

Acknowledgements

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

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

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

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

Announcing JupyterCAD 3.0

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

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

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

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

What’s new in JupyterCAD 3.0?

Color customization

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

Embedded Python console

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

UX improvements

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

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

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

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

Mouse-based 3D controls

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

Suggestions support

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

Try it!

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

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

Installing JupyterCAD

You can easily install JupyterCAD with pip or mamba:

pip install jupytercad

or:

mamba install -c conda-forge jupytercad

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

mamba install -c conda-forge freecad jupytercad-freecad

What’s next?

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

Upcoming Features

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

Features in Development

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

Acknowledgements

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

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

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

About the authors

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

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

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

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

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

JupyterLab 3 end of maintenance

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

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

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

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

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

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

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

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

Voilà 0.5.0: Homecoming

2023-09-25T14:54:00+00:00

Voilà turns Jupyter notebooks into standalone web applications and dashboards. It provides a simple way for Jupyter users to share their work. For a detailed introduction to Jupyter’s Voilà subproject, you can check out this earlier blog post.

Up until the previous version, Voilà relied on custom JavaScript code to load extension assets and handle kernel connection. However, this approach had drawbacks since it only supported the now outdated Jupyter Notebook 6 extensions.

Following the launch of Jupyter Notebook 7, it is now Voilà’s turn to join the JupyterLab family. In Version 0.5.0, the front-end of Voilà has been rebuilt from scratch using JupyterLab 4.0 components, just like in the case of Notebook 7. A JupyterLab plugin-based application replaces the current custom extension loader approach. This transition enables Voilà to leverage all the latest features and enhancements available upstream.

New features in Voilà 0.5.0

Extension loading system

As of Version 0.5.0, Voilà uses the same prebuilt extension system as JupyterLab. The extension assets are loaded from local paths rather than relying on a CDN, resulting in a significant enhancement to Voilà’s extension compatibility with the rest of the JupyterLab ecosystem. This change also avoids making requests for external services. Additionally, users can now develop extensions for Voilà using the same approach as for JupyterLab extensions.

A Voila dashboard with top bar extension and custom JupyterLab theme.

Mimetype rendering mechanism

In 0.5.0, the logic for rendering cell outputs containing mimetypes has been revised, moving away from relying on nbconvert and instead depending on JupyterLab mimetype renderers. This change adds support for a wide range of custom JupyterLab renderers such as jupyterlab-fasta, vega, jupyterlab-geojson, etc.

Rendering mimetypes data in Voila

New tree page

The default tree page in Voilà has transitioned into a JupyterLab-based application incorporating the file browser widget. While the Jinja-based tree page remains available, users must opt for it using either the --classic-tree CLI option or by appending ?classic-tree=True to the query string.

The new tree page in Voilà supports JupyterLab custom themes, whereas the classic tree page is limited to light and dark themes.

New tree page with a custom theme.

Token-based authentication system

Depending on the identity provider of jupyter-server 2, Voilà now supports token authentication but is disabled by default.

To start Voilà with auto-generated token:
```
voila --token ...
```
To start Voilà with a personalized token:
```
voila --token=my-secret-token ...
```

Installing Voilà

Voila is available on both PyPI and conda-forge:

# Install with pip
pip install voila

# Install with mamba
mamba install -c conda-forge voila

You can try Voilà online using this link.

Acknowledgments

The contributions to Voilà by QuantStack are supported by Bloomberg.

About the Contributors

Voilà is an official Jupyter subproject, it has resulted from the collective efforts of numerous contributors. Below, we highlight the primary contributors for this release:

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

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

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

Announcing Jupyter Notebook 7

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

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

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

Jupyter Notebook 7 with a running Python 3 notebook

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

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

A Familiar Document-Oriented Experience

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

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

Visual Debugger

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

Visual debugging in Jupyter Notebook 7

Real-Time Collaboration

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

pip install jupyter-collaboration

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

Theming and Dark Mode

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

Jupyter Notebook 7 with JupyterLab Dark theme

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

pip install jupyterlab-night

Jupyter Notebook 7 with JupyterLab Night theme

Improved integration between JupyterLab and Notebook

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

More features

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

Why a new version?

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

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

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

Migrating to Notebook 7

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

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

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

Try it on Binder

You can try Notebook 7 on Binder using this link.

Acknowledgements

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

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

Get Involved

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

Make your own extensions. You can also help the community by porting Classic Notebook extensions to Notebook 7.
Contribute to the development, documentation, and design of Jupyter Notebook on GitHub. To get started with development, please see the Contributing Guide and Code of Conduct. Many issues are ideal for new contributors and are tagged as “good first issue” or “help wanted”.
Connect with the community on GitHub or on Discourse. If you find a bug, have questions, or want to provide feedback, please join the conversation!

JupyterLab 4.0 is Here

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Jupyter Server 2.0 is released!

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

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

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

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

Major Highlights

Below is a short list of highlights for everyone! 🚀

New Identity API

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

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

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

New Authorization API

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

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

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

New Event System API

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

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

Other major changes

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

New Kernel Websocket API

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

Server ships its own Kernel Manager

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

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

Terminals Service is now a Server Extension

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

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

pytest-jupyter, a pytest plugin for Jupyter

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

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

Changelog

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

Installation

To install Jupyter Server with pip:

pip install jupyter_server

or with conda:

conda install -c conda-forge jupyter_server=2.0.0

Documentation

Find our full documentation here.

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

Acknowledgements

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

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

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

About the author

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

Jupyter Notebook 6.5.0 Release Candidate

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

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

Notebook 6.5.0rc0 on PyPI

Notebook 6 vs Notebook 7

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

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

NbClassic

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

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

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

Some Use Cases

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

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

Compatibility

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

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

Next Steps

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

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

Sincerely,

Project Jupyter

About the Author

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

Thank You to Contributors to this blog

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

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

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

Upgrading Nbgrader

2022-09-15T07:51:00+00:00

Project Jupyter provides a broad collection of open-source tools for interactive computing that has become ubiquitous in data science and scientific computing, and is very popular in educational contexts.

Nbgrader, started by Jessica Hamrick in 2014, is an extension for creating notebook-based assignments, online courses, and for auto-grading these assignments. It is central to many Jupyter-based services used by teaching institutions.

As a large part of the Jupyter user base has adopted the JupyterLab frontend, most of the popular extensions to the classic notebook UI now have an equivalent in the JupyterLab world. Unfortunately, the nbgrader extension was still outstanding as it had not yet been ported to the JupyterLab extension system. Resolving this has become critical as it was recently decided in a Jupyter Enhancement Proposal (JEP) that the next major version of the Notebook package (v7) will be based on JupyterLab components, and will rely on the JupyterLab extension mechanism. As part of this JEP, it was decided that the release of Notebook 7 should be contingent on porting certain popular classic notebook extensions to JupyterLab, including nbgrader.

Upgrading nbgrader is an important step for the advancement of the Jupyter project!

Nbgrader 0.8

The port of nbgrader to JupyterLab is a longstanding request of the community. A lot of work had already been done on this front by contributors to the ngshare project (Kevin Rong, Abigail Almanza, Lawrence Lee, and Eric Li) who developed a large part of the JupyterLab-based UI, but did not finalize the migration due to lack of time. Fortunately, they made their work available to the community for others to complete the upgrade. This includes the development of the remaining elements of the UI, the adaptation of the server-side extension, and adding tests on the JupyterLab extensions to improve the CI. The nbgrader 0.8 release also includes other significant work items such as the upgrade to nbconvert 6, the switch from the notebook server to jupyter-server, and the adoption of the jupyter releaser.

Today, we are pleased to announce the release of nbgrader 0.8.0, the first release of the extension to support the JupyterLab frontend.

Creating an assignment

Teachers can create assignments directly in the notebook UI by setting the proper information for each cell, such as the cell type (whether it is a locked cell, a manually graded answer, or an automatically graded answer) and the number of points the answer is worth.

The UI for creating an assignment in the notebook (teachers).

Managing assignments on the teacher side

Formgrader is the part of the nbgrader UI for the teachers to manage the assignments.

From this UI, teachers will be able to:

generate assignments from a Notebook file
share assignments with students
fetch assignments after student submission
grade assignments
provide feedback to students

The Formgrader UI to manage assignments (teachers).

Managing assignments on the student side

The assignments list UI is used by students to fetch assignments released by the teacher, submit their answers, and benefit from the feedback after the evaluation by teachers.

The assignments list UI to fetch and submit assignments (students).

What about the future?

Creating and grading assignments in nbgrader uses the metadata of individual notebook cells. The current release of nbgrader provides a widget to interact with the corresponding metadata.

As other extensions need a similar functionality, we are expanding the generic cell metadata editor to address this requirement in a more generic and pluggable way. The new metadata editor allows any extension to create a specific form to interact with the relevant part of the metadata, specified with a JSON schema and rendered with react-jsonschema-form.

Nbgrader could take advantage of this improvement in a future release.

Try it online

Installation

You can install the latest version of nbgrader using pip:

pip install nbgrader

The GitHub repository can be found here.

Acknowledgements

This work at QuantStack was partly funded by Université Paris Cité in the context of the PlasmaBio project.

We are grateful to Jessica Hamrick, Jeremy Tuloup, and Ian Stuart for their help and code reviews during the upgrade to nbgrader 0.8.0.

About the Author

Nicolas Brichet is a scientific software developer at QuantStack active in the Jupyter ecosystem. In the past few months, he has been working on the Nbgrader extension, as well as other developments in core JupyterLab such as an improved notebook metadata editor. Before joining QuantStack, Nicolas was a software engineer at INRAE.

Jupyter Blog - releases

JupyterHub 6.0

Thank you to our contributors

JupyterGIS 0.16: New visualization capabilities, collaborative Story Maps, and more

Story Maps are getting a new look!

A better Story Maps editing experience

OpenEO layers

Lazy visualization of Xarray datasets with jupyter-tiler

A more expressive symbology model

GeoZarr and GeoPackage support

New Collaborative Editing Capabilities

A new R API

Bug fixes and performance improvements

Acknowledgements

Contributors to this release

JupyterLite 0.8 is released! 🎉

Sharing a REPL

Refreshed Loading Screen

File System Reliability Improvements

JupyterLab 4.6 and Notebook 7.6

A Terminal in the Browser

More Kernels with jupyterlite-xeus

Python 3.14 with the Pyodide Kernel

JavaScript Kernel Improvements

Try it in your browser

Acknowledgments

JupyterLab 4.6 and Notebook 7.6 are out!

Enhancements shared by JupyterLab and Notebook

Notebook improvements

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

Debugger: kernel sources filter, floating overlay

Keyboard navigation and accessibility

Keyboard shortcuts

Internationalization

Terminal enhancements

Inline completion enhancements

JupyterLab-specific enhancements

Layout and interface customization

Performance

Notebook-specific enhancements

Scratchpad console

Confirmation dialog when closing and shutting down a notebook

Miscellaneous

For extension authors

As large as minor releases go

Acknowledgements

Further reading

What’s New in MyST Markdown 1.8.2

Interactive widgets with the {anywidget} directive

Table of contents improvements

Better link handling across multi-site projects

Upgrade

Changelogs

JupyterLite 0.7 is released! 🎉

Workspace Support

Audio and Video Playback

Basic Interrupt Functionality

Basic Notebook Export

File Menu Download Option

Enhanced Markdown Support

JupyterLab 4.5 and Notebook 7.5

Walkthrough video

Try it in your browser

Acknowledgments

JupyterLab 4.5 and Notebook 7.5 are available!

Performance and windowing

Notebook improvements

Debugger and Console improvements

New search functionality inside terminals

Media and content support

File browser enhancements

Keyboard shortcuts and commands

Settings

User interface and accessibility

Update from JupyterCon

Acknowledgements

JupyterLite 0.6.0 is released! 🎉

Interactive Input Support

New REPL Options

Kernel Indicator and Logs

Interactive widgets with the `{anywidget}` directive

Support for collaboration without `RTC:` drive