jupyterlab.readthedocs.io

The JupyterLab Documentation site (jupyterlab.readthedocs.io) is the official documentation for JupyterLab, a highly extensible, feature-rich notebook authoring application and editing environment. It is part of Project Jupyter, an umbrella project that provides tools and standards for interactive computing with computational notebooks. The site is the reference point for anyone who wants to install JupyterLab, learn its interface, extend it with plugins, or contribute to its development.

What JupyterLab itself is

According to the documentation, a computational notebook is a shareable document that combines:

• computer code
• plain language descriptions
• data
• rich visualizations such as 3D models, charts, graphs, and figures
• interactive controls

A notebook plus an editor like JupyterLab gives you a fast interactive environment for prototyping and explaining code, exploring and visualizing data, and sharing ideas with others. JupyterLab is described as a sibling to other notebook authoring applications under Project Jupyter, such as Jupyter Notebook and Jupyter Desktop, and it offers a more advanced, feature-rich, customizable experience compared to Jupyter Notebook.

What the documentation site covers

The documentation is organized around three broad directions: using JupyterLab, extending it, and contributing to it.

Using JupyterLab

The User Guide section includes:

• Get Started
• The JupyterLab Interface
• JupyterLab URLs
• Working with Files
• Text Editor
• Notebooks
• Code Consoles
• Completer
• Terminals
• Managing Kernels and Terminals
• Commands and Commands in Markdown
• Output and Files
• Documents and Kernels
• File and Output Formats
• Debugger
• Table Of Contents
• Extensions
• Workspaces
• JupyterLab on JupyterHub
• Exporting Notebooks
• Localization and language
• Real Time Collaboration
• Language Server Protocol support
• Interface Customization, Applying Custom CSS, Settings Editor, and Plugin Filtering

There is also an Advanced Usage section covering JupyterLab on Binder.

Extending JupyterLab

The Develop Extensions area covers:

• Common Extension Points
• Reusing JupyterLab UI
• Using JupyterLab components
• Documents, Notebook, React User Interface Helpers
• Internationalization and Localization
• Identity, Design Patterns, and CSS Patterns
• Extension Tutorial
• Targeting Multiple Applications
• Extension Migration Guide

Additional extension resources include an Overview of Extensions, Plugins, Source Extensions, Prebuilt Extensions, a development workflow for source extensions, and testing your extension.

Contributing

The Contribute section covers:

• General Guidelines for Contributing
• Languages, Tools and Processes
• Submitting a Pull Request
• Contributing from within the browser
• Setting up a local development environment
• Installing JupyterLab
• Internationalization

When to use this site

Use the JupyterLab Documentation when you need to:

• confirm what JupyterLab is and how it relates to Jupyter Notebook and Jupyter Desktop
• look up installation and setup instructions
• understand the interface, files, notebooks, kernels, terminals, or the debugger
• customize the interface, settings, or CSS
• build or migrate an extension
• find contribution guidelines and local development setup

The documentation also notes that JupyterLab follows the Jupyter Community Guides, and it points to Binder if you want to try JupyterLab without a local install.

The JupyterLab documentation site (jupyterlab.readthedocs.io) organizes its content into four top-level sections: Get Started, User Guide, Develop Extensions, and Contribute. You can reach any of them from the top-level links on the homepage or from the section list in the page body. Use Get Started if you are installing or opening JupyterLab for the first time, User Guide if you already have it running and want to learn a feature, Develop Extensions if you are writing an extension, and Contribute if you want to work on JupyterLab itself.

Get Started

This is the entry point for installation and first run. It covers installing JupyterLab and the initial setup steps. If you have never launched JupyterLab, start here before moving to the User Guide.

User Guide

The User Guide is the largest section and covers day-to-day use. Its topics include:

• The JupyterLab Interface — the overall layout and how the pieces fit together
• JupyterLab URLs — how the URL structure maps to the interface
• Working with Files — file browsing and management
• Text Editor — editing plain text files
• Notebooks — creating and running notebooks
• Code Consoles — interactive code execution outside a notebook
• Completer — code completion
• Terminals — running a terminal inside JupyterLab
• Managing Kernels and Terminals — starting, stopping, and switching kernels
• Commands and Commands in Markdown — the command system and how to invoke commands
• Output and Files, Documents and Kernels, File and Output Formats — how documents, kernels, and outputs relate
• Debugger — debugging support
• Table Of Contents — navigating long documents
• Extensions and Workspaces — managing extensions and saved layouts
• JupyterLab on JupyterHub — running JupyterLab in a shared environment
• Exporting Notebooks — exporting notebook content
• Localization and language — interface language settings
• Real Time Collaboration — collaborative editing
• Language Server Protocol support — LSP-based features
• Interface Customization, Applying Custom CSS, Settings Editor, Plugin Filtering — tailoring the interface and settings

If your question is "how do I do X in the interface," it is almost certainly answered somewhere in this section.

Develop Extensions

This section is for developers building on top of JupyterLab. It includes:

• Common Extension Points — where extensions hook into the application
• Reusing JupyterLab UI and Using JupyterLab components — building on existing UI pieces
• Documents, Notebook, React User Interface Helpers — APIs for documents and UI
• Internationalization and Localization — making extensions translatable
• Identity, Design Patterns, CSS Patterns — conventions to follow
• Extension Tutorial — a guided build
• Targeting Multiple Applications — supporting more than one Jupyter application
• Extension Migration Guide — moving an extension between versions
• Other resources: Overview of Extensions, Plugins, Source Extensions, Prebuilt Extensions, Development workflow for source extensions, Testing your extension

Choose this section if you are writing or maintaining an extension rather than using JupyterLab.

Contribute

This section is for people contributing to JupyterLab itself, not just using or extending it. It covers:

• General Guidelines for Contributing
• Languages, Tools and Processes
• Submitting a Pull Request
• Contribution, Contributing from within the browser
• Setting up a local development environment
• Installing JupyterLab
• Internationalization

How to Navigate

Two routes work for most lookups:

1. Top-level links — the homepage lists the main sections at the top; use these when you know roughly which category your question falls into.
2. In-page section list — the homepage body also lists the sections and their sub-topics, which is useful when you know the feature name but not which section owns it.

The documentation is for JupyterLab 4.7.0a2, so version-specific behavior may differ from older releases. JupyterLab is described as a highly extensible notebook authoring and editing environment within Project Jupyter, and it is positioned as a more advanced, feature-rich, customizable experience compared to Jupyter Notebook. If you want to try it without installing anything, the documentation points to Binder.

You can try JupyterLab without installing anything by launching it on Binder, which the JupyterLab documentation links to directly from its home page ("Try JupyterLab on Binder"). This gives you a hosted JupyterLab session in your browser, so it is the fastest way to explore the interface before committing to a local install. The trade-off is that a Binder session is temporary and intended for trying things out, not for ongoing work.

Launch JupyterLab on Binder

1. Open the JupyterLab documentation site and find the Try JupyterLab on Binder link on the landing page.
2. Follow the link. Binder builds and starts a JupyterLab environment for you and opens it in a new browser tab.
3. Wait for the build/launch to finish. The first launch can take a while because the environment is being prepared; later launches of the same build are usually faster.
4. When the JupyterLab interface appears, you are in a working session — you can open notebooks, run code, and explore the UI.

Expected result: a running JupyterLab interface in your browser, with no software installed on your own machine.

What to do once it opens

Use the documentation's Get Started section as your guide while the session is running. It covers the basics you will want to test first:

• The JupyterLab Interface — how the main work area, tabs, and side panels are arranged.
• Notebooks — creating and running a computational notebook, which the docs describe as a shareable document combining code, text, data, and visualizations.
• Working with Files — the file browser and basic file operations.
• Code Consoles and Terminals — other ways to run code and commands alongside notebooks.
• Managing Kernels and Terminals — how running processes are tracked and controlled.

Trying these in a Binder session is a low-risk way to see whether JupyterLab's layout and workflow suit you.

Things to keep in mind

• Sessions are not permanent. Treat a Binder session as a trial environment; do not rely on it to store work you need to keep.
• It is a shared, hosted setup. You are not configuring your own machine, so settings and installed packages may differ from a local installation.
• It is the same application. The docs present Binder as a way to try JupyterLab itself, so the interface you see is the real thing, not a demo mock-up.

When you are ready to move beyond trying it

Once you have decided JupyterLab fits your needs, the documentation's Installing JupyterLab page is the next stop. That page covers setting it up on your own system, which is what you want for persistent projects, your own files, and control over the environment.

A computational notebook is a shareable document that combines computer code, plain-language descriptions, data, and rich visualizations in one place. In JupyterLab, that document becomes an interactive workspace: you can write and run code, see the output immediately, and mix it with explanatory text, charts, 3D models, and interactive controls. This format is useful whenever you need to prototype code, explore and visualize data, or explain an idea to someone else without switching between separate tools.

What a computational notebook contains

According to the JupyterLab documentation, a notebook can hold several kinds of content side by side:

• Computer code that you can execute
• Plain language descriptions that explain what the code does
• Data used by the code
• Rich visualizations, including 3D models, charts, graphs, and figures
• Interactive controls that let you adjust what you see

Because these elements live in the same document, the notebook works as both a working environment and a record of what you did.

What JupyterLab adds

JupyterLab is the editing environment that opens and runs these notebooks. The documentation describes it as a highly extensible, feature-rich notebook authoring application and editing environment, part of Project Jupyter. Within that project, JupyterLab sits alongside other notebook authoring applications such as Jupyter Notebook and Jupyter Desktop.

The documentation notes that JupyterLab offers a more advanced, feature-rich, and customizable experience compared to Jupyter Notebook. So the notebook is the document format, and JupyterLab is one of the interfaces you can use to work with it.

What you can do with one

The documentation frames the notebook-plus-editor combination as a fast interactive environment for:

• Prototyping and explaining code — write a piece of code, run it, and describe it in the same file
• Exploring and visualizing data — load data and produce charts or figures next to the code that generated them
• Sharing ideas with others — hand over a single document that contains the code, the explanation, and the results

Where to go next

If you want to try it without installing anything, the documentation points to running JupyterLab on Binder. For learning the interface and day-to-day tasks, the documentation's main sections include Get Started, User Guide, and the JupyterLab Interface, with further topics such as Notebooks, Working with Files, and Extensions.

JupyterLab, Jupyter Notebook, and Jupyter Desktop are all notebook authoring applications under the same Project Jupyter umbrella, but they are not the same product. The key difference: JupyterLab is positioned as a more advanced, feature-rich, and customizable environment than Jupyter Notebook, while Jupyter Desktop is a separate sibling application rather than a newer version of either. If you want the most extensible editing environment, JupyterLab is the intended choice; if you want the simpler classic experience, Jupyter Notebook remains available.

The shared foundation

All three sit under Project Jupyter, whose stated goal is providing tools and standards for interactive computing with computational notebooks. A computational notebook is a shareable document that combines:

• computer code
• plain language descriptions
• data
• rich visualizations such as 3D models, charts, graphs, and figures
• interactive controls

A notebook plus an editor like JupyterLab gives you a fast interactive environment for prototyping and explaining code, exploring and visualizing data, and sharing ideas.

How the three relate

The documentation explicitly frames JupyterLab as "a sibling to other notebook authoring applications under the Project Jupyter umbrella, like Jupyter Notebook and Jupyter Desktop." That means none of these is simply the successor of another in the docs' wording — they coexist.

What "more advanced" means in practice

The documentation's own comparison is directional rather than a feature-by-feature table: JupyterLab offers a more advanced, feature-rich, customizable experience compared to Jupyter Notebook. The User Guide sections hint at the scope of that environment, including:

• The JupyterLab Interface
• Notebooks, Code Consoles, Text Editor, Terminals
• Managing Kernels and Terminals
• Debugger and Table of Contents
• Extensions and Workspaces
• Interface Customization, Applying Custom CSS, Settings Editor
• Real Time Collaboration and Language Server Protocol support

If your work depends on any of those capabilities — extensions, deep interface customization, or collaborative editing — that is the signal to choose JupyterLab over Jupyter Notebook.

Choosing between them

• Choose JupyterLab when you need extensibility, a richer interface, and customization options.
• Choose Jupyter Notebook when you want the classic, simpler notebook experience.
• Consider Jupyter Desktop as a distinct sibling application if a desktop form factor matters to you.

You can try JupyterLab without a local install via Binder, which the documentation links directly from its welcome page.

A note on the Classic Notebook

The documentation includes a "What will happen to the Classic Notebook?" entry in its Get Started section, indicating that the relationship between JupyterLab and the classic Notebook is an actively documented topic. If you are deciding between them, that page is the place to check for the current status rather than relying on assumptions about replacement.