# Jupyter Notebooks, a computational laboratory within your reach

> Jupyter Notebook is Project Jupyter's interactive Python software. Learn how to install it with uv on Ubuntu and Fedora and try it out
> By José Maldonado · Technology · 2026-09-07

Jupyter Notebook is a well-known Python software for interactive computing that was born in 2014 as an evolution of IPython, the interpreter Fernando Pérez created in 2001. In this guide you will learn how to install it with uv, Astral's package manager, on Ubuntu and Fedora, and you will put it to the test with two graphical examples that will give you an idea of its full power.

The plan is simple: first we install uv, then JupyterLab, and finally we open a notebook to run two real examples with numpy, pandas and matplotlib. You don't need prior Python knowledge to keep up, although some background always helps.

## What is Jupyter and why is it called that?

To understand what Jupyter is, you have to go back a quarter of a century. In 2001, Fernando Pérez was a physics PhD student at the University of Colorado in Boulder, frustrated with Python's interactive interpreter, which he compared to "a crippled toy" next to the Mathematica notebooks he used in his research. That summer he wrote a small 259-line startup file to improve his experience in the terminal. That was the seed of [**IPython**](https://ipython.org/).

The project grew slowly but with direction. Brian Granger joined in 2004 and in 2011 the team released the first version of the IPython Notebook, a web document that combined executable code, text and graphical results. The definitive leap came in 2014, when the project announced at the SciPy conference its split from IPython under a new name, [**Project Jupyter**](https://jupyter.org/), driven by seven founding members.

That was the origin of the tool you have in front of you.

**[The end of ownership, why Apple and Sony impose renting](https://observatorioblockchain.com/en/technology/apple-sony-alquiler-fin-propiedad-tecnologica/)**

### A double tribute

The name is a double tribute. On the one hand, it recalls the three data science languages that inspired the architecture, Julia, Python and R, not as an acronym but as recognition that all of them are first-class citizens.

On the other, it pays tribute to Galileo's notebooks, the manuscripts where the astronomer recorded in 1610 the discovery of Jupiter's moons and which are considered the first example of documented open science. Jupyter wanted to be, in essence, the digital laboratory notebook of the 21st century.

Financial support explains much of its success. The Alfred P. Sloan Foundation funded with 1.15 million dollars in 2013 and 2014 the first components such as nbconvert, the interactive widgets and the prototype of [**JupyterHub**](https://jupyter.org/hub).

A year later, in 2015, a joint six-million-dollar grant from the Helmsley, Moore and Sloan foundations made it possible to build JupyterLab, the modern interface we all know today.

Its first stable version arrived in February 2018.

### Free software for the world

But community recognition came even earlier. In 2017, the project's committee received the ACM Software System Award, one of the most prestigious in free software. It is worth remembering a distinction that causes confusion: Jupyter is the project and the ecosystem, while IPython still exists as the Python kernel, the engine that runs the code inside Jupyter.

The language-independent part moved to Jupyter, which today supports more than a hundred third-party kernels, from R to Julia, from Haskell to Ruby. The most recent stable version, JupyterLab 4.6, was published on June 18, 2026, less than three months ago, and the classic Notebook 7.6 shared the release because it is built on the same base.

## What exactly is a notebook? The beginning of everything

A notebook is a document that mixes executable code, formatted text, equations and results in cells organized from top to bottom. Each cell can be code or rich text, and you can run them in any order, which turns data exploration into a fluid conversation with your own machine. It is the digital equivalent of the laboratory notebook where you note, calculate and correct at the same time.

The architecture separates two worlds. The frontend, which you see in the browser, is JupyterLab or the classic Notebook. The kernel is a separate process that receives the code, runs it and returns the results, which can be text, tables, charts or even interactive widgets. That separation is what allows the same notebook to work with different languages: you just change the kernel. When you install Jupyter with Python, the kernel is ipykernel, the modern version of the old IPython.

**[Nvidia buys Hugging Face for almost 13 billion dollars](https://observatorioblockchain.com/en/ai/nvidia-compra-hugging-face/)**

### Main goal of the project

The project's main goal, as defined by its creators, is interactive computing and the creation of reproducible "computational narratives." The core idea is that the result of a research project or an analysis is not only the final chart, but the entire process that generates it, documented step by step in the document itself. If you change a data point, you rerun the cell and the whole analysis updates in a chain. For data journalism, financial analysis or science, that traceability is worth gold.

Jupyter also provides a handful of shortcuts we call magics. The most useful one for this guide is `%pip`, which allows you to install packages inside the notebook itself without leaving the browser. Other popular ones are `%timeit`, to measure execution times, or `%matplotlib inline`, which embeds the charts in the document instead of opening them in separate windows. The native format is `.ipynb`, a JSON file you can version with git, share and export to HTML, PDF or even Python scripts with a single command.

That working model explains its expansion. Reproducible scientific papers, treasury and fund analyses, data journalism reports and even many modern textbooks are distributed as notebooks, because the reader sees the code, the data and the results in the same document. Git treats them as plain text and services like GitHub render them in the browser, which makes it easier to review any other team's work.

### Installing Jupyter with uv

For years, installing Jupyter was synonymous with `pip install jupyter`, with its retinue of problems: environments that polluted the system Python, versions that clashed with each other and dependency resolutions that could take minutes. The mess had a name and a solution.

That is where [**uv**](https://docs.astral.sh/uv/), the package and project manager written in Rust by Astral, the company behind the Ruff linter, comes in.

uv was born in 2023 with an ambitious promise: to replace tools like pip, pipx, poetry, pyenv, virtualenv and twine in one fell swoop, and to do so 10 to 100 times faster than pip thanks to its concurrent resolution and downloading, with a global disk cache that deduplicates dependencies across projects. In 2026, with the 0.12 series, all of this is no longer a promise: it is one of the most widely adopted Python tools in the ecosystem.

The advantage that matters most to you here is isolation. When you install JupyterLab as a "tool" with uv, it creates its own virtual environment, separate from the system Python and from your projects. The `jupyter-lab` executable becomes available in your PATH, but it lives in a little isolated box that breaks nothing. If you want to uninstall it, a single command removes it without a trace. It is exactly the management model that avoids the dependency hells that have haunted Python for two decades.

Installation method

What you get

When to choose it

`uv tool install jupyterlab`

Global JupyterLab, isolated in its own environment

Occasional use; does not touch the system Python

`uv tool run jupyter lab`

Ephemeral environment that is created and discarded when finished

Trying Jupyter without installing anything permanent

Project with `uv add` and `uv run`

Reproducible per-project environment with a lockfile

Serious analyses you want to share or version

We already explored this spirit of free software that simplifies life in Observatorio with [the guide to turning a USB drive into a permanent multiboot with Ventoy](https://observatorioblockchain.com/en/technology/convierte-usb-multiboot-permanente-ventoy/), and uv responds to the same philosophy: a single, fast executable that solves a real pain point.

### Prerequisites to get started

Before writing the first command, check that you have what you need. The table summarizes what each distribution requires.

Requirement

Ubuntu

Fedora

Distribution

22.04, 24.04 or 26.04 LTS

Fedora 41 and later

Terminal

Bash or any compatible shell

Same

`curl`

Required, installed with apt

Optional, already installed

System Python

Not needed, uv manages its own

Not needed

Disk space

About 2 GB between environment and cache

Same

The key to this guide is that you don't need a manually installed Python. uv downloads and manages its own interpreter on demand, so you can start on a practically freshly installed system. That simplifies the process and avoids conflicts with your distribution's Python, which is sometimes tied to the system's own tools and is best left alone.

**[The Linux kernel: 35 years of the heart that dominates the tech world](https://observatorioblockchain.com/en/technology/el-kernel-de-linux-35-anos-del-corazon-que-domina-el-mundo-tech/)**

### How to install uv on Ubuntu?

On Ubuntu the situation is peculiar: uv is not packaged in the official repositories in 2026, so `sudo apt install uv` fails with a package-not-found message. The route recommended by Astral is its standalone installer, which downloads the updated binary directly from the project's page.

First make sure you have `curl` installed and the package index updated:

```
sudo apt update && sudo apt install -y curl
```

Then run the official installer. The command downloads a script and runs it with the shell, so check the installation page first if you are one of those who distrusts that pattern:

```
curl -LsSf https://astral.sh/uv/install.sh | sh
```

The installer places `uv` and `uvx` in `~/.local/bin` and adds that directory to your PATH. Close and reopen the terminal, or run `uv ensure-path` so the setting applies without restarting. Verify the installation:

```
uv --version
```

You should see a version from the 0.12 series, which is the current one in September 2026. If the command is not found, check that `~/.local/bin` is in your PATH variable and add it to `~/.bashrc` if necessary. As an alternative, you can also install uv with pipx (`pipx install uv`) or with the official snap `astral-uv`, but the standalone installer is the one that receives updates first.

### How to install uv on Fedora?

Fedora has the advantage that uv has been in its official repositories for several versions, so the installation is the classic one for any system package. Open a terminal and run:

```
sudo dnf install uv
```

When it finishes, check the version with the usual command:

```
uv --version
```

The package in Fedora's repositories is usually one or two versions behind the official installer, but for this guide it makes no difference at all. One detail worth knowing: when uv is installed with the distribution's package manager, self-updating is disabled by design, so to update it you will use `sudo dnf upgrade uv` instead of `uv self update`. If you prefer to always have the latest version, Astral's standalone installer works the same on Fedora and coexists without problems with the official route.

### How to install JupyterLab with uv?

With uv installed on your system, the next step is identical on Ubuntu and Fedora. The most direct way is to install it as a global tool, isolated from the rest of the system:

```
uv tool install jupyterlab --with pip
```

Note the `--with pip`. It is a detail that seems minor and turns out to be essential: the isolated environment uv creates does not include pip by default, and without it the `%pip` magic in the notebook fails with a "no module named pip" error. Simon Willison documented this same problem when he started experimenting with uv in 2025, and the official solution in the JupyterLab documentation is exactly that modifier.

![](https://content.observatorioblockchain.com/wp-content/uploads/2026/09/jupyterlab-uv.webp)

The command finishes in a few seconds and tells you the installed executables: `jupyter-lab`, along with its extension companions. A naming nuance that will save you a scare: the command is `jupyter-lab` with a hyphen, not `jupyter lab`. Many old guides use the second form, but with the tool installation only the first exists.

To start the server:

```
jupyter-lab
```

Your browser will open at `http://localhost:8888/lab` with the JupyterLab interface. The first run may take a little longer because it builds the font cache for matplotlib and the interface components; this is normal and does not happen again.

![](https://content.observatorioblockchain.com/wp-content/uploads/2026/09/jupyterlab-run-scaled.webp)

There is a second, more formal route aimed at reproducible projects. Create a directory for your analysis, initialize a project and add the dependencies:

```
mkdir mi-proyecto && cd mi-proyecto uv init uv add jupyterlab numpy pandas matplotlib
```

With this uv generates a `pyproject.toml` and a `uv.lock`, and creates its own virtual environment in `.venv`. To open that project's notebook:

```
uv run jupyter-lab
```

This option is recommended if you plan to share the analysis: anyone who clones your repository can reproduce the exact environment with `uv sync`. For this guide, the quick global tool route is more than enough.

**[Solana turns its logo into a billboard and raises 167,000 dollars for Nepal](https://observatorioblockchain.com/en/blockchain/solana-publicidad-logo-167000-dolares-nepal/)**

### Starting the server and creating your first notebook

When JupyterLab opens you will see three areas: the toolbar, the central launcher and the file panel on the left. In the launcher there is a Notebook section with a Python 3 icon. Click it and an `Untitled.ipynb` will be created with a code cell ready to type in.

The Python 3 kernel comes included, because JupyterLab pulls in ipykernel as a dependency and uv manages its own interpreter. In fact, in the tool environment we installed, uv downloaded Python 3.13, so you don't depend on your distribution's version.

JupyterLab is also multitasking. Alongside the notebook you can open a terminal embedded in the browser, a text editor for your auxiliary scripts or a data viewer, all in tabs you can reorder by dragging. The left panel acts as a file manager: if you create folders there, the server creates them on your disk, and you can upload data by dragging it from the desktop.

The workflow is circular: you write code in a cell, press Shift + Enter to run it, and the result appears below. If you just want to move on without running, you can press Enter to type in a new cell. The keys you will use most are Shift + Enter (run), B (new cell below) and M (convert the cell to text). JupyterLab's menus show you the rest of the shortcuts with Ctrl + Shift + P.

Before the first example, install the scientific libraries inside the notebook itself with the `%pip`magic, taking advantage of the fact that we included pip in the installation:

```
%pip install numpy pandas matplotlib
```

You will see the download progress directly in the cell output. On a recent system, numpy, pandas and matplotlib install in less than a minute. Check that everything works with a welcome cell:

```
import numpy as np import pandas as pd import matplotlib print("Todo listo. Versión de pandas:", pd.__version__)
```

The text `Todo listo` confirms that the kernel is alive and that the three libraries we will use in the examples are available.

### Example 1, a first chart with numpy and matplotlib

The first example is the classic matplotlib introduction: plotting trigonometric functions. It serves to check that the whole cycle works, from importing libraries to seeing the chart embedded in the notebook.

Create a new cell and write this code:

```
import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 2 * np.pi, 200) y_sin = np.sin(x) y_cos = np.cos(x) print("Primeros 5 valores de x:", x[:5]) print("Primeros 5 valores de sin(x):", np.round(y_sin[:5], 4)) fig, ax = plt.subplots(figsize=(8, 4)) ax.plot(x, y_sin, label="sin(x)", linewidth=2) ax.plot(x, y_cos, label="cos(x)", linewidth=2) ax.set_title("Funciones trigonométricas con numpy y matplotlib") ax.set_xlabel("x (radianes)") ax.set_ylabel("y") ax.legend() ax.grid(alpha=0.3) plt.show()
```

Let's break down what each line does. `np.linspace(0, 2 * np.pi, 200)` generates 200 evenly spaced points between 0 and 2π, the full period of both functions. `np.sin` and `np.cos` calculate the sine and cosine of each of those points. Then, `plt.subplots` creates the figure and the axis where we draw, `ax.plot` traces each curve with its label and `ax.legend()` places the legend. The finishing touch, `plt.show()`, embeds the result in the notebook.

The result is a chart with two curves: the sine in blue, which starts at 0 and rises to its maximum at π/2, and the cosine in orange, which starts at 1 and crosses the sine at π/4. On the same axis you will see both labels in the upper corner and a faint grid that makes the values easier to read. If something doesn't work, the most likely cause is a missing library: rerun the `%pip install` cell and try again.

![](https://content.observatorioblockchain.com/wp-content/uploads/2026/09/ejemplo1-seno-coseno.png)

This example contains matplotlib's fundamental logic: a figure is created, data is plotted on an axis and the axes are decorated with titles and legends. Everything you do afterward, however complex, is a variation on this same skeleton. Save the notebook with Ctrl + S; the `.ipynb` file is ready to share.

**[Google removes uBlock Origin from Chrome: here's how you can keep browsing without ads](https://observatorioblockchain.com/en/technology/google-elimina-ublock-origin-chrome-publicidad/)**

### Example 2, moving averages of a price series with pandas

The second example goes up a notch and connects directly with the world we cover in Observatorio: analyzing a time series of prices. We are going to simulate 120 days of quotes for a cryptocurrency and draw two moving averages over them, one of 20 days and another of 50, the kind of indicator many traders use to detect trends.

```
import numpy as np import pandas as pd import matplotlib.pyplot as plt rng = np.random.default_rng(42) precios = 25000 * np.cumprod(1 + rng.normal(0.0008, 0.03, 120)) fechas = pd.date_range("2026-01-01", periods=120, freq="D") serie = pd.Series(precios, index=fechas) sma20 = serie.rolling(20).mean() sma50 = serie.rolling(50).mean() fig, ax = plt.subplots(figsize=(8, 4)) ax.plot(serie.index, serie, label="Precio diario", linewidth=1.5) ax.plot(serie.index, sma20, label="Media móvil 20 días", linewidth=1.5) ax.plot(serie.index, sma50, label="Media móvil 50 días", linewidth=1.5) ax.set_title("Precio diario con medias móviles de 20 y 50 días") ax.set_xlabel("Fecha") ax.set_ylabel("Precio (USD)") ax.legend() ax.grid(alpha=0.3) plt.show()
```

The data part mixes two pieces. `rng.normal` generates 120 daily variations with a slight positive drift, and `np.cumprod` chains them together to build a price series that starts at 25,000 dollars. `pd.date_range` creates the calendar for the 120 days from January 1, 2026, and `pd.Series` joins both, prices with dates, into pandas' star data structure.

The indicators part is the most elegant. `serie.rolling(20).mean()` calculates the simple 20-day moving average: for each date, the average of the previous 20 prices. Since the calculation needs 20 observations to start, the curve leaves the initial stretch without data, and the same happens with the 50-day one, which starts even later. That is the visual signal you look for when you look at the chart: the long moving average does not begin until past a third of the period.

The result is a chart where the daily price in green winds along with volatility, while the 20-day average in blue follows it more smoothly and the 50-day one in red barely reacts to short-term swings. When the price stays above both averages, the usual reading is a bullish bias; when it breaks below, many analysts interpret it as a trend change. None of this is an investment recommendation, but as a pandas exercise it is impeccable.

![](https://content.observatorioblockchain.com/wp-content/uploads/2026/09/ejemplo2-medias-moviles.png)

The beauty of doing this in a notebook, compared with a loose script, is that you can change the random seed or the period of the averages with a single edit and rerun the cell to instantly see how the result changes. That rapid iteration is, in one sentence, Jupyter's reason for being.

**[The €400 robot duck with which Hugging Face wants to conquer Christmas](https://observatorioblockchain.com/en/ai/pato-robot-hugging-face-microduck-navidad/)**

## Common problems and how to solve them

No guide is complete without the troubleshooting section. These are the ones you are most likely to run into when combining Jupyter and uv.

*   **`jupyter: command not found` when starting up.** Most likely you typed `jupyter lab`. With the tool installation, the executable is `jupyter-lab`, with a hyphen. If that doesn't work either, check that uv's binaries directory is in your PATH.
*   **`%pip` responds "No module named pip".** It means you installed JupyterLab without the `--with pip`modifier. You can reinstall it with `uv tool install --force jupyterlab --with pip` and the problem disappears.
*   **`uv: command not found` right after installing it.** The installer adds `~/.local/bin` to your PATH, but the open terminal has not reloaded it. Run `uv ensure-path` or restart the shell.
*   **The Python 3 kernel does not appear in the launcher.** Delete the tool environment and reinstall it. The command `uv tool install --force jupyterlab --with pip` solves almost every case of a half-finished installation.
*   **Port 8888 is already in use.** Start the server on another port with `jupyter-lab --port 8899` or with `--no-browser` and paste the link with its token into the browser.
*   **On Fedora, uv stayed on an old version.** Remember that with the dnf installation self-updating is disabled; run `sudo dnf upgrade uv`.
*   **A warning about the matplotlib font cache at startup.** It is harmless. The first run builds the cache and it won't bother you again.

If a notebook hangs or the kernel restarts, don't lose your work: changes to text and code cells are saved in the `.ipynb`file, and you can reopen the server and continue where you left off.

## Jupyter, a quarter century of interactive computing

When Fernando Pérez wrote those 259 lines in 2001, he was looking for a Python interpreter that didn't feel like a toy. Twenty-five years later, his project is invisible infrastructure for data science, research and much of the planet's financial analysis, and tools like uv make it more accessible than ever to anyone with a Linux machine in front of them.

The combination you have set up in this guide, a modern manager and an interactive notebook with matplotlib, pandas and numpy, is the foundation on which a huge part of today's analytical work rests. And the ecosystem does not stop: in June 2026, JupyterLab 4.6 arrived with accessibility, debugger and navigation shortcut improvements, while the project is already exploring assisted chart generation and integration with generative AI.

If you take one thing away from this read, let it be this: installing Jupyter with uv takes less than two minutes, but it completely changes the way you work with data. Save the notebook from the second example, change the seed or the period of the averages, and watch how an altered data point propagates its effect through the entire analysis. That immediacy, impossible in a traditional script, is exactly what Jupyter has been pursuing for twenty-five years.

**[Windows on ARM scales to Tier 1: what does it mean for your next laptop?](https://observatorioblockchain.com/en/technology/windows-arm-tier-1-proximo-portatil/)**
