What you're installing and why

A Jupyter pre-release is an early version of Jupyter Notebook or JupyterLab that includes new features before the official release. Installing it means replacing your current stable version with code that is still being tested. Cursor is a code editor that works alongside Jupyter, letting you write and edit code files that you then run in Jupyter notebooks.

You would install a pre-release if you need a specific new feature, want to test upcoming changes, or are helping the Jupyter team find bugs. Pre-releases are not recommended for production work — they may have unfixed problems that break your notebooks or lose your work.

This guide covers installing a Jupyter pre-release on Windows, macOS, or Linux, and configuring Cursor to work with it. You will need Python already installed on your machine, and familiarity with opening a terminal or command prompt.

Key Takeaways

  • Pre-release versions are unstable and may contain bugs, so install them in a separate Python environment rather than replacing your main Jupyter installation.
  • You install pre-releases using pip with the --pre flag, which tells pip to fetch versions that are not yet officially released.
  • Cursor connects to Jupyter through a kernel — the pre-release version will work with Cursor as long as the kernel is registered in the same Python environment.
  • Testing a pre-release means keeping notes on what breaks, so you can report problems to the Jupyter team if you find them.

Setting up a separate Python environment

Before you install a pre-release, create a new Python environment so that your main Jupyter installation stays unchanged. This way, if the pre-release has problems, you can switch back to your stable version without reinstalling anything.

Open your terminal (macOS or Linux) or Command Prompt (Windows). Type the command for your Python version:

python3 -m venv jupyter-prerelease

This creates a folder called jupyter-prerelease in your current directory. Now set up that environment. On macOS or Linux, type:

source jupyter-prerelease/bin/set up

On Windows, type:

jupyter-prerelease\Scripts\set up

Your terminal prompt will change to show the environment name in parentheses, like (jupyter-prerelease). You are now working inside the isolated environment.

Installing the pre-release with pip

With your environment activated, upgrade pip first to make sure you have the latest version:

pip install --upgrade pip

Now install the Jupyter pre-release. The --pre flag tells pip to include pre-release versions in its search:

pip install --pre jupyter

If you want JupyterLab specifically (the newer interface) instead of Jupyter Notebook, use:

pip install --pre jupyterlab

Pip will read and install the latest pre-release version and all its dependencies. This may take a few minutes. When it finishes, you will see a message saying the installation succeeded.

Verifying the pre-release installed correctly

Check which version you installed by typing:

jupyter --version

The output will show a version number with "rc" (release candidate) or "a" (alpha) or "b" (beta) in it — for example, 7.0.0rc1. This confirms you have a pre-release, not a stable version.

Start Jupyter to make sure it runs:

jupyter notebook

or

jupyter lab

Your browser should open with Jupyter running. Create a new notebook and run a straightforward command like print("test") to confirm the kernel works. Close Jupyter when you are done.

Connecting Cursor to the pre-release

Cursor is a code editor, not a notebook interface. It lets you write Python files that you can run in your Jupyter kernel. To connect Cursor to your pre-release environment, you need to tell Cursor where to find the Python interpreter in that environment.

Open Cursor and go to Settings (Ctrl+, on Windows or Linux; Cmd+, on macOS). Search for "Python: Default Interpreter Path". Paste the full path to the Python executable in your pre-release environment.

On macOS or Linux, the path looks like:

/path/to/jupyter-prerelease/bin/python

On Windows, it looks like:

C:\path\to\jupyter-prerelease\Scripts\python.exe

Replace /path/to or C:\path\to with the actual location where you created the environment. After you paste the path, Cursor will use the pre-release Python and its packages whenever you run code.

Running code between Cursor and Jupyter

With Cursor pointed at your pre-release environment, you can write code in Cursor and run it in Jupyter. Create a new Python file in Cursor, write your code, and save it. Then open a terminal, set up your pre-release environment again, and run the file with:

python filename.py

Alternatively, you can copy code from Cursor, paste it into a Jupyter notebook cell, and run it there. Both approaches use the same pre-release kernel, so the behavior will be identical.

If you want to test Jupyter features directly, keep a notebook open in your browser while you work in Cursor. Switch between them as you develop — Cursor for writing and editing, Jupyter for interactive testing.

Switching back to your stable version

When you are done testing the pre-release, deactivate the environment by typing:

deactivate

Your terminal prompt will return to normal. Now when you run jupyter notebook or jupyter lab, it will use your original stable installation, not the pre-release.

The pre-release environment stays on your computer in the jupyter-prerelease folder. You can set up it again anytime to test further, or delete the folder entirely if you no longer need it. Deleting the folder does not affect your main Jupyter installation.

Frequently Asked Questions

What is the difference between a pre-release and a stable version?

A stable version has been tested and released officially. A pre-release is still being developed and may have bugs or incomplete features. Pre-releases are labeled with "rc" (release candidate), "a" (alpha), or "b" (beta) in the version number.

Can I use the pre-release for real work or should I only test it?

Pre-releases are for testing only. They may lose data, crash without warning, or behave unpredictably. Use your stable Jupyter installation for any work you need to keep or share.

What do I do if the pre-release breaks my notebooks?

Deactivate the pre-release environment and switch back to your stable version. Your notebooks will still open normally in the stable version. If you found a real bug, report it on the Jupyter GitHub repository with details about what went wrong.

Do I need to uninstall my old Jupyter before installing the pre-release?

No. Creating a separate environment keeps both versions on your computer at the same time. You switch between them by activating or deactivating the environment, not by uninstalling.

Can I install both Cursor and Jupyter in the same environment?

Cursor is an editor that runs on your computer separately from Jupyter. You do not install Cursor inside a Python environment. Instead, you point Cursor to the Python environment where Jupyter is installed, and Cursor uses that Python to run code.