Jupyter

The open notebook standard and its tools: JupyterLab and Jupyter Notebook in the browser, a server that runs kernels for dozens of languages, the .ipynb file format and JupyterHub for many users.

Jupyter Foundation project

What it is: Data notebooks
Type: Open source
Made by: Project Jupyter
Foundation: Jupyter Foundation. Project Jupyter is hosted by LF Charities, which registers its trademarks, and governed by its own elected councils; the Jupyter Foundation funds it. Part of the Linux Foundation
License: BSD 3-Clause
Facts checked: 28 October 2026

What it is

Jupyter is a family of projects built around one protocol and one file format. You open JupyterLab, the full environment with tabs, a file browser, terminals and a debugger, or Jupyter Notebook, the simpler one-document interface; since Notebook 7 (July 2023) both are built from the same JupyterLab components and run on the same Jupyter Server, a Python web server that saves files and starts kernels. A kernel is a separate process that runs the code: IPython’s ipykernel for Python, IRkernel for R, IJulia for Julia and community kernels for dozens of other languages. The server and kernel talk over ZeroMQ using the Jupyter messaging protocol (version 5.5): one channel for execute requests, a broadcast channel for outputs, and separate ones for input prompts, interrupts and a heartbeat. Because a kernel keeps its variables between cells, you can load data once and explore it a step at a time.

A notebook file (.ipynb) is JSON in the nbformat schema: a list of Markdown and code cells, with each code cell’s outputs (text, tables, images, HTML) and its execution count saved alongside. That is why so many other tools read it: VS Code, Google Colab and most managed notebook services open the same files. Around the core sit JupyterHub, which signs users in and starts a separate server for each one, on one machine or on Kubernetes with the Zero to JupyterHub chart; nbconvert, which runs notebooks headless and exports them to HTML, PDF or scripts; ipywidgets for interactive controls; and jupyter-collaboration for real-time co-editing. In October 2026 the current releases were JupyterLab 4.6 and Notebook 7.6 (June 2026), with 4.7 in pre-release; all are BSD-licensed and installed with pip or conda.

Why teams pick it

The common format: .ipynb files open in JupyterLab, VS Code, Colab and most hosted notebook services, so work moves between them
Any language with a kernel: Python, R and Julia are maintained by the project, and community kernels cover dozens more
Outputs live in the document, so a notebook doubles as a record of an analysis, with charts and tables next to the code that made them
Free and self-hostable from one laptop to a university-wide JupyterHub on Kubernetes, with no vendor in the way

Watch out for

Hidden state: cells can run in any order and deleted cells leave their variables behind, so a saved notebook may not rerun top to bottom; JupyterLab is not reactive and won’t re-run dependent cells for you
Saved outputs and execution counts make the JSON noisy in Git: diffs and merges need tools such as nbdime or Jupytext, or outputs stripped before committing
Single-user by design: sharing a server means sharing its token and its kernels, so teams need JupyterHub for sign-in and separate servers, and real-time co-editing is an extension
Notebook 7 replaced the classic Notebook interface, so old classic extensions don’t load; NbClassic keeps the old interface running for those who still need it

Specs

Compare with alternatives →

Written in: Python (server, kernels) and TypeScript (JupyterLab and Notebook front ends)
Ways to run it: Local with pip or conda; multi-user with JupyterHub, on one host or on Kubernetes

Alternatives

What all data notebooks have in common →Compare side by side →

Apache ZeppelinOpen sourceA self-hosted web notebook where each paragraph runs through an interpreter: Spark, Flink, JDBC, Python and more. Maintained, but behind Jupyter and Databricks in reach.

HexCommercialA hosted SQL and Python notebook whose cells form a reactive graph and can be published as data apps. It now leads with AI agents that answer questions from semantic models and curated context.

DatabricksCommercialA managed lakehouse platform built on Apache Spark and Delta Lake, with Unity Catalog for governance, on AWS, Azure or Google Cloud.

How it fits with other technologies

What Jupyter uses

Start JupyterLab, add a kernel for a project environment and run a notebook headless · bash

pip install jupyterlab               # JupyterLab, Jupyter Server and the Python kernel (ipykernel)
jupyter lab                          # serve on localhost:8888 and open the browser

# make a project's virtual environment available as its own kernel
python -m ipykernel install --user --name orders --display-name "Python (orders)"
jupyter kernelspec list              # kernels this server can start

# run every cell top to bottom without a browser, then export the result
pip install nbconvert
jupyter nbconvert --to notebook --execute report.ipynb --output report.run.ipynb
jupyter nbconvert --to html report.run.ipynb

The main pieces#

Most people meet Jupyter as one of the two editors. These are the parts underneath, each its own subproject.

Project	What it does
JupyterLab	The full browser environment: notebooks, consoles, terminals, a file browser, a debugger and side-by-side tabs, extended with npm-built plugins
Jupyter Notebook	One document per browser tab, closer to the original IPython Notebook; since version 7 a set of JupyterLab components on the same server
Jupyter Server	The Python back end: serves the front ends, reads and writes files, and starts, interrupts and restarts kernels
Kernels	Processes that run the code and hold its state; `ipykernel` for Python, IRkernel for R, IJulia for Julia, Xeus-based and community kernels for others
JupyterHub	Signs users in (OAuth, LDAP and others) and starts a separate server for each, as local processes, containers or Kubernetes pods

See it in a real stack

No architecture uses Jupyter yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2011–2026

Jupyter grew out of IPython, an interactive Python shell. Its notebook, a browser front end that kept code, output and notes in one document, was released in 2011 by a team including Fernando Pérez, Brian Granger and Min Ragan-Kelley. Because the kernel protocol already worked for other languages, the language-independent parts (the notebook format, the protocol and the web application) were spun off in 2014 as Project Jupyter, named after Julia, Python and R, while IPython stayed as the Python kernel and shell. In 2017 its steering council received the ACM Software System Award.

JupyterLab, the next-generation interface, was announced ready for users on February 20, 2018, and JupyterLab 4.0 followed in May 2023. Two months later Notebook 7 rebuilt the classic interface from JupyterLab components, so the two share one server and one extension system, with NbClassic kept for the old one.

The organisation changed too. In January 2023 an elected Executive Council and a Software Steering Council replaced the founder-led model, and in 2024 the project moved from NumFOCUS to LF Charities, part of the Linux Foundation, which formed the Jupyter Foundation on November 19, 2024 to fund it.

Why it’s built this way

Separate the kernel from the front end: Running code in its own process, behind a documented message protocol, lets any language plug in as a kernel and any editor act as a front end, which is how Jupyter outgrew Python.
Save outputs inside the notebook: A notebook is meant to be read as a record of a computation, with its charts and tables, even by someone who can’t run it. The cost is JSON that is noisy under version control.
Rebuild Notebook on JupyterLab components: Maintaining two front ends with two extension systems split the community; Notebook 7 kept the simple single-document interface while sharing JupyterLab’s code and extensions.

Timeline

2011
The IPython Notebook is released
2014
Project Jupyter is spun off from IPython
2017
ACM Software System Award
2018
JupyterLab announced ready for users on February 20
2023
JupyterLab 4.0 in May; Notebook 7, built on JupyterLab components, in July
2024
Moves to LF Charities; Jupyter Foundation formed on November 19
2026
JupyterLab 4.6 and Notebook 7.6 in June

Sources14 · facts checked 28 October 2026

Improve this page on GitHub