Overview

Jupyter Notebook is an open-source web application that enables users to create and share documents containing live code, equations, visualizations, and narrative text. Originally developed from the IPython project, it supports over 40 programming languages through a kernel-based architecture, with Python being the most common. Jupyter Notebook is widely used in data science, scientific computing, education, and exploratory programming, allowing iterative development and reproducible research within a single, interactive interface.

1 History and Development

1.1 Origins in IPython

Jupyter Notebook traces its roots to the IPython project, initiated in 2001 by Fernando Pérez. IPython began as an enhanced interactive Python shell, offering features such as tab completion, introspection, and history management. Over time, IPython evolved into a broader interactive computing environment, and in 2011 the IPython Notebook was released—a web-based interface that combined live code, rich text, and visualizations. This notebook interface was built upon the ZeroMQ messaging library and a client‑server architecture.

1.2 Project Jupyter and the name

In 2014, the IPython team announced Project Jupyter, a spin‑off that aimed to support multiple programming languages beyond Python. The name “Jupyter” is a portmanteau of the three core languages initially supported: Julia, Python, and R. This transition separated the language‑agnostic notebook interface (Jupyter) from the Python‑specific kernel (IPython). The project’s logo, a stylized atom, reflects its scientific computing roots.

1.3 Major version milestones

1.3.1 Classic Notebook vs JupyterLab

The original Jupyter Notebook interface, now often called the “Classic Notebook,” was the default for many years. In 2018, Project Jupyter introduced JupyterLab, a next‑generation interface that offered a more integrated, modular workspace with drag‑and‑drop panels, a file browser, and a built‑in terminal. While the Classic Notebook remains available, JupyterLab has become the recommended environment for new users.

1.3.2 Jupyter Notebook 7 and beyond

Jupyter Notebook version 7, released in 2023, represented a significant architectural shift. Built on the same foundations as JupyterLab, Notebook 7 moved away from the older Classic Notebook codebase, adopting a more maintainable and extensible framework. This version introduced improved accessibility, performance enhancements, and a refreshed user interface, while maintaining backward compatibility with existing .ipynb files.

2 Architecture and Core Concepts

2.1 Client–server model

Jupyter Notebook operates on a client‑server architecture. The notebook server runs as a process on a local machine or remote server, managing kernel sessions and serving the user interface. The client (typically a web browser) connects to the server via HTTP or WebSocket, rendering the notebook document and handling user interactions.

2.1.1 Web browser interface

The web browser acts as the primary client, rendering HTML, CSS, and JavaScript. It provides an interactive editing environment where users can write code, enter markdown, view outputs, and manage kernel connections. The browser communicates with the server using the Jupyter Notebook REST API and WebSocket channels for real‑time kernel communication.

2.1.2 Notebook server

The notebook server is responsible for authenticating users, managing kernel processes, and storing notebook files. It can be configured to listen on specific ports, use SSL encryption, and support multiple users (e.g., via JupyterHub). The server also provides a dashboard for browsing and opening notebooks, terminals, and other resources.

2.2 Kernels

A kernel is a language‑specific process that executes code sent from the notebook interface and sends outputs back. Each notebook is associated with a single kernel, which persists in memory until the kernel is interrupted or restarted. Kernels communicate with the server using the Jupyter Messaging Protocol.

2.2.1 Communication protocol (Jupyter Messaging Protocol)

The Jupyter Messaging Protocol (JMP) defines the format of messages exchanged between the notebook server and kernels. Messages are serialized as JSON and transmitted over ZeroMQ sockets (or WebSocket tunnels). The protocol specifies message types such as execute_request, execute_reply, stream, display_data, and error, enabling rich, interactive output.

2.2.2 Supported language kernels

2.2.2.1 IPython kernel

The IPython kernel is the default kernel for Jupyter Notebook, providing support for Python (versions 2.7 and 3.x). It inherits all the features of IPython, including magic commands (e.g., %matplotlib, %timeit), tab completion, and syntax highlighting. The IPython kernel is maintained by Project Jupyter and is the most widely used kernel.

2.2.2.2 Third‑party kernels (R, Julia, etc.)

Jupyter’s open kernel architecture allows anyone to create a kernel for any language. Notable third‑party kernels include IRkernel for R, IJulia for Julia, xeus-cling for C++, and jupyter-scala for Scala. A community‑maintained list of available kernels is hosted on the Jupyter Wiki, with over 40 languages supported as of 2025.

2.3 Notebook file format (.ipynb)

Jupyter Notebooks are saved as files with the .ipynb extension. The format is a JSON document that stores the notebook’s content, metadata, and execution history.

2.3.1 JSON structure

An .ipynb file is a JSON object with the following top‑level keys: nbformat (version number), nbformat_minor, metadata (e.g., kernel info, language), and cells (an array of cell objects). Each cell object contains its type, source code, outputs, and metadata. This plain‑text format facilitates version control and programmatic manipulation.

2.3.2 Cells: code, markdown, raw

A notebook is composed of cells, which come in three types:

  • Code cells: Contain executable code (e.g., Python, R). When run, the kernel executes the code and produces outputs (text, images, etc.).
  • Markdown cells: Contain text formatted using Markdown. They can include headings, lists, links, images, and even LaTeX equations (via MathJax).
  • Raw cells: Contain unformatted text that is not executed or rendered. They are useful for including content that should bypass the notebook’s rendering pipeline.

2.4 Execution model

2.4.1 Cell execution order

Cells can be executed in any order by the user. Each execution sends the cell’s code to the kernel and displays the result immediately below the cell. This non‑linear execution model allows exploratory workflows but can lead to dependencies on earlier cells that may not be obvious if cells are re‑run out of order.

2.4.2 State persistence and global namespace

The kernel maintains a persistent global namespace across all code cells in the same notebook. Variables, functions, and imports defined in one cell remain available in subsequent cells (until the kernel is restarted). This behavior is essential for iterative analysis but requires careful management to avoid unexpected side effects.

3 User Interface and Features

3.1 Classic Notebook interface

3.1.1 Menu bar, toolbar, and cell toolbox

The Classic Notebook interface consists of a menu bar (File, Edit, View, Insert, Cell, Kernel, Help), a toolbar with icons for common actions (save, add cell, run, interrupt kernel), and a cell toolbox that appears when a cell is selected. The toolbox allows quick changes to cell type (Code, Markdown, Raw) and provides drag‑and‑drop cell reordering.

3.1.2 Kernel indicator and notebook dashboard

A kernel indicator in the upper‑right corner shows the kernel’s status: “Idle” (ready), “Busy” (executing), or a circle icon indicating the kernel is disconnected. The Notebook Dashboard (shown at startup) lists files in the server’s directory and allows users to create, rename, and delete notebooks.

3.2 JupyterLab

3.2.1 Modular workspace with panels

JupyterLab provides a flexible, modular interface where users can arrange panels (notebooks, text editors, terminals, file browser, etc.) in a single window. Panels can be resized, moved, and split into multiple tabs, enabling complex workflows such as side‑by‑side code and documentation editing.

3.2.2 File browser, terminal, and extensions

JupyterLab includes a built‑in file browser for navigating the file system, a terminal for command‑line operations, and an extension manager for adding new features. Extensions can customize themes, add new language support, or provide additional widgets (e.g., a variable inspector, a Git interface).

3.3 Interactive widgets (ipywidgets)

The ipywidgets library allows users to create interactive GUI elements—such as sliders, buttons, dropdown menus, and text boxes—directly in the notebook. These widgets can be linked to code cells, enabling real‑time parameter exploration and interactive visualizations without writing complex JavaScript.

3.4 Rich output display

3.4.1 Matplotlib, plotly, and other visualizations

Jupyter Notebook can display a wide variety of static and interactive visualizations. Matplotlib plots are rendered inline by default (using %matplotlib inline or %matplotlib notebook). Plotly, Bokeh, and Altair produce interactive charts that can include hover tooltips, zooming, and animations.

3.4.2 HTML, LaTeX, and multimedia

Code cells can output rich media, including HTML tables, LaTeX equations (via MathJax), images (PNG, SVG, JPEG), audio files, and video. This is achieved by the kernel sending display data with appropriate MIME types. The notebook interface then renders the media in the output area.

4 Workflow and Use Cases

4.1 Data exploration and cleaning

Jupyter Notebook is a popular tool for exploratory data analysis (EDA). Data scientists can load datasets, inspect their structure, handle missing values, and transform variables—all while viewing intermediate results and visualizations in the same document. This iterative process speeds up understanding of data and detection of anomalies.

4.2 Scientific research and reproducible analyses

Researchers use notebooks to combine code, equations, explanations, and results in a single document, facilitating reproducible research. By sharing the .ipynb file (or a rendered HTML/PDF version), others can rerun the analysis exactly. Tools like Binder allow anyone to launch a live notebook from a repository, ensuring computational reproducibility.

4.3 Education and tutorials

Educators and tutorial creators leverage notebooks to teach programming, data science, and domain‑specific topics. Markdown cells provide explanations, while code cells offer live examples that students can run and modify. Many online courses (e.g., on Coursera, edX) distribute assignments as Jupyter Notebooks.

4.4 Collaborative development

4.4.1 Version control with nbconvert and Jupytext

Notebooks pose challenges for version‑control systems like Git because the JSON format includes output and metadata. Tools like nbconvert can strip outputs before committing, and Jupytext converts notebooks to plain‑text representations (e.g., .py or .md files) that are easier to diff and merge.

4.4.2 Sharing via nbviewer and Binder

nbviewer (nbviewer.jupyter.org) renders static HTML versions of any public .ipynb file, allowing sharing without requiring a running server. Binder creates a live, executable environment from a GitHub repository, letting users interact with notebooks instantly in the cloud—no local installation needed.

5 Extensions and Ecosystem

5.1 Official extensions (Jupyter Notebook Extensions)

Project Jupyter maintains a set of official extensions for the Classic Notebook, collectively known as Jupyter Notebook Extensions (formerly jupyter_contrib_nbextensions). These include the “Table of Contents” generator, “Autoscroll” for outputs, “ExecuteTime” (shows cell execution duration), and “Collapsible Headings”. Extensions can be enabled or disabled via a dedicated dashboard.

5.2.1 Variable inspector

The variable inspector extension adds a panel that lists all variables defined in the kernel, along with their type, size, and value. This is especially helpful for debugging and understanding the current state of the workspace.

5.2.2 Table of contents

This extension automatically generates a floating table of contents in the notebook based on markdown headings, allowing quick navigation in long documents. It is also available as a built‑in feature in JupyterLab.

5.2.3 Code folding

Code folding enables collapsing and expanding sections of code cells, reducing visual clutter and making it easier to focus on relevant parts of a large notebook.

5.3 Integration with cloud platforms

5.3.1 Google Colab

Google Colaboratory (Colab) is a free cloud‑based Jupyter Notebook environment hosted by Google. It provides GPU and TPU access, seamless integration with Google Drive, and pre‑installed libraries for machine learning. Colab notebooks are saved in Google Drive and can be shared and collaborated on in real time.

5.3.2 Kaggle Notebooks

Kaggle, a data‑science competition platform, offers its own hosted Jupyter Notebook environment. Kaggle Notebooks come with pre‑loaded datasets, free GPU access, and an active community of users sharing scripts and analysis. They are seamlessly integrated with Kaggle competitions and datasets.

5.3.3 Azure Notebooks (now retired)

Microsoft’s Azure Notebooks was a cloud service offering hosted Jupyter environments. Launched in 2015, it was retired in 2021, with users encouraged to migrate to alternatives such as Azure Machine Learning notebooks or Visual Studio Code with the Jupyter extension.

6.1 Comparison with IPython console and IDEs

The IPython console (terminal‑based) offers a similar interactive experience but lacks rich visual outputs and narrative text. Traditional IDEs like PyCharm, VS Code, and Spyder provide robust debugging and project management but have a different workflow. Jupyter Notebook fills a niche between pure consoles and full‑featured IDEs, prioritizing exploratory, literate programming.

6.2 Notable alternatives

6.2.1 R Markdown and RStudio

R Markdown is a document format that combines R code, prose, and output (similar to Jupyter). It is deeply integrated into the RStudio IDE. While R Markdown excels at producing reproducible reports and publications in formats like PDF and Word, Jupyter is more language‑agnostic and web‑centric.

6.2.2 Apache Zeppelin

Apache Zeppelin is a web‑based notebook that supports interactive data analytics and visualization. It is built for big‑data environments (Spark, Flink) and features a built‑in interpreter framework. Zeppelin’s paragraph‑based UI resembles Jupyter but is oriented toward enterprise data pipelines.

6.2.3 Observable notebooks

Observable is a proprietary, hosted notebook platform that uses JavaScript (or a reactive variant) instead of kernels. Observable notebooks are collaborative, reactive, and optimized for data visualization. They do not use the .ipynb format and are not open‑source, but they offer a different approach to literate programming.

7 Security and Best Practices

7.1 Server security and authentication

When running a Jupyter Notebook server on a network (especially the internet), it is critical to enable authentication. Default configurations often use token‑based authentication; stronger setups can include password authentication, SSL/TLS encryption, and reverse‑proxy access through tools like Nginx. JupyterHub adds multi‑user support with authentication backends (e.g., OAuth, LDAP).

7.2 Trusting notebooks and code execution

Executing code from untrusted notebooks poses security risks, as code cells can run arbitrary commands. Users should verify the source of notebooks before running them. Jupyter includes a “trust” mechanism based on a digital signature of the notebook’s code cells; notebooks from unknown sources should be treated as untrusted and reviewed carefully.

7.3 Avoiding common pitfalls

7.3.1 Non‑deterministic cell ordering

Executing cells out of order can lead to a notebook that works on the author’s machine but fails when rerun from scratch. Best practice is to periodically restart the kernel and run all cells in order (using “Run All” from the menu). This ensures that the notebook reflects a valid, linear execution path.

7.3.2 Large outputs and memory management

In‑notebook outputs (e.g., large tables, heavy plots) can bloat the .ipynb file and slow down the interface. Users should clear outputs before committing to version control. For memory management, it is advisable to delete unused variables (del) and avoid keeping large datasets in the kernel’s global namespace for extended periods.