jupyter/notebook

Jupyter Interactive Notebook

13,043 stars Jupyter Notebook 10 components 2 connections

Jupyter Notebook v7 frontend - modern TypeScript rebuild using JupyterLab components

User interactions flow through JupyterLab's command system, triggering plugins that either modify the current shell or open new browser tabs for different notebook/console views.

Under the hood, the system uses 2 feedback loops, 2 data pools, 2 control points to manage its runtime behavior.

Structural Verdict

A 10-component fullstack with 2 connections. 84 files analyzed. Minimal connections — components operate mostly in isolation.

How Data Flows Through the System

User interactions flow through JupyterLab's command system, triggering plugins that either modify the current shell or open new browser tabs for different notebook/console views.

User Action — User clicks menu items, toolbar buttons, or navigates to URLs
Command Dispatch — JupyterLab command system routes actions to appropriate plugin handlers
Plugin Processing — Extension plugins process commands and determine routing (same tab vs new tab)
Shell Update or Navigation — Either update current NotebookShell widgets or open new browser tabs with different URLs
Document/Session Management — Load documents, start kernels, or create console sessions based on the target interface

System Behavior

How the system actually operates at runtime — where data accumulates, what loops, what waits, and what controls what.

Data Pools

Document Registry (state-store)
JupyterLab's document registry stores file type mappings and widget factories

Command Registry (state-store)
Central command registry where all plugins register their executable commands

Feedback Loops

Kernel Status Polling (polling, balancing) — Trigger: Notebook opens or kernel state changes. Action: Poll kernel connection status and update UI indicators. Exit: Notebook closes or kernel shuts down.
Search Provider Detection (registry, balancing) — Trigger: Widget becomes active or search registry changes. Action: Check if current widget has search provider and update CSS classes. Exit: Widget becomes inactive.

Delays & Async Processing

Document Save Before Navigation (async-processing, ~varies by document size) — New tab opens only after current notebook is saved to preserve kernel info
Extension Loading (async-processing, ~varies by extension count) — Module federation loads JupyterLab extensions dynamically on startup

Control Points

userLayoutArea (runtime-toggle) — Controls: Whether widgets open in current tab vs new tab based on user layout settings
expose_app_in_browser (feature-flag) — Controls: Whether Jupyter apps are exposed in browser environment. Default: true

Package Structure

This monorepo contains 15 packages:

app (app)
Main application bundle configuration and build setup for the Jupyter Notebook frontend.

buildutils (tooling)
Development utilities for building, versioning, and setting up the repository in development mode.

metapackage (library)
Aggregate package that imports all Jupyter Notebook extensions and components.

application (library)
Core NotebookApp class and shell architecture that extends JupyterLab's application framework.

application-extension (library)
Main application plugins for menu, toolbar, routing, and core notebook functionality.

console-extension (library)
Plugin for opening and managing Jupyter console sessions in new tabs.

docmanager-extension (library)
Document opening and management plugin that handles routing to notebook/edit views.

documentsearch-extension (library)
Plugin that adds search functionality to notebook documents and applies searchable styling.

help-extension (library)
Help menu plugin providing links to Jupyter documentation and resources.

lab-extension (library)
Interface switcher plugin allowing navigation between Notebook, JupyterLab, and NbClassic views.

notebook-extension (library)
Core notebook functionality plugin including kernel status, debugging, and notebook-specific features.

terminal-extension (library)
Plugin for opening terminal sessions in new browser tabs.

tree (library)
File browser tree component for navigating and managing notebook files.

tree-extension (library)
Plugin that provides file browser functionality and tree view routing.

ui-components (library)
Shared UI components and styling specific to Jupyter Notebook interface.

Technology Stack

TypeScript (framework)
Primary language for all packages

JupyterLab (framework)
Core application framework and component library

Rspack (build)
Module bundler with federation support

Lumino (framework)
Widget toolkit for UI components

Handlebars (build)
Template engine for build-time HTML generation

Lerna (build)
Monorepo management and versioning

React (library)
Used for specific UI components like help dialogs

Key Components

NotebookApp (class) — Main application class extending JupyterFrontEnd with NotebookShell and custom info packages/application/src/app.ts
NotebookShell (class) — Custom shell implementation for notebook-specific layout and widget management packages/application/src/shell.ts
rspack.config.js (config) — Module federation and bundling configuration using Rspack and Handlebars templates app/rspack.config.js
opener (docmanager) (plugin) — Handles document opening by routing to appropriate notebook/edit URLs in new tabs packages/docmanager-extension/src/index.ts
interfaceSwitcher (plugin) — Provides toolbar buttons to switch between Notebook, JupyterLab, and NbClassic interfaces packages/lab-extension/src/index.ts
kernelStatus (plugin) — Displays kernel connection status with error/warning/info styling in the notebook toolbar packages/notebook-extension/src/index.ts
develop.ts (cli-command) — Sets up repository for development mode by linking notebook schemas to Python environment buildutils/src/develop.ts
console opener (plugin) — Routes console URLs and creates console sessions with kernel paths packages/console-extension/src/index.ts
notebookShellWidgetListener (plugin) — Applies searchable styling to widgets based on search provider availability packages/documentsearch-extension/src/index.ts
help open plugin (plugin) — Provides help menu commands to open external Jupyter documentation and resources packages/help-extension/src/index.tsx

Configuration

jupyter_config.json (json)

LabApp.expose_app_in_browser (boolean, unknown) — default: true
JupyterNotebookApp.expose_app_in_browser (boolean, unknown) — default: true

lerna.json (json)

$schema (string, unknown) — default: node_modules/lerna/schemas/lerna-schema.json
version (string, unknown) — default: independent

nx.json (json)

$schema (string, unknown) — default: ./node_modules/nx/schemas/nx-schema.json
tasksRunnerOptions.default.runner (string, unknown) — default: nx/tasks-runners/default
tasksRunnerOptions.default.options.cacheableOperations (array, unknown) — default: build,build:prod,build:lib,build:labextension:dev,build:labextension
namedInputs.default (array, unknown) — default: {projectRoot}/**/*
targetDefaults.build:lib.dependsOn (array, unknown) — default: ^build:lib
targetDefaults.build:lib.inputs (array, unknown) — default: default,^default
targetDefaults.build:lib.outputs (array, unknown) — default: {projectRoot}/lib
targetDefaults.build.dependsOn (array, unknown) — default: ^build
+3 more parameters

Explore the interactive analysis

See the full architecture map, data flow, and code patterns visualization.

Analyze on CodeSea

Related Fullstack Repositories

Frequently Asked Questions

What is notebook used for?

Jupyter Notebook v7 frontend - modern TypeScript rebuild using JupyterLab components jupyter/notebook is a 10-component fullstack written in Jupyter Notebook. Minimal connections — components operate mostly in isolation. The codebase contains 84 files.

How is notebook architected?

notebook is organized into 4 architecture layers: Application Layer, Extension Layer, Component Layer, Build Layer. Minimal connections — components operate mostly in isolation. This layered structure keeps concerns separated and modules independent.

How does data flow through notebook?

Data moves through 5 stages: User Action → Command Dispatch → Plugin Processing → Shell Update or Navigation → Document/Session Management. User interactions flow through JupyterLab's command system, triggering plugins that either modify the current shell or open new browser tabs for different notebook/console views. This pipeline design reflects a complex multi-stage processing system.

What technologies does notebook use?

The core stack includes TypeScript (Primary language for all packages), JupyterLab (Core application framework and component library), Rspack (Module bundler with federation support), Lumino (Widget toolkit for UI components), Handlebars (Template engine for build-time HTML generation), Lerna (Monorepo management and versioning), and 1 more. A focused set of dependencies that keeps the build manageable.

What system dynamics does notebook have?

notebook exhibits 2 data pools (Document Registry, Command Registry), 2 feedback loops, 2 control points, 2 delays. The feedback loops handle polling and registry. These runtime behaviors shape how the system responds to load, failures, and configuration changes.

What design patterns does notebook use?

4 design patterns detected: JupyterLab Plugin Architecture, Module Federation, Path-based Routing, New Tab Navigation.

Analyzed on March 31, 2026 by CodeSea. Written by Karolina Sarna.