# napari: a Python-native n-dimensional image viewer for microscopy and array work

> napari is a Qt and vispy desktop viewer that treats NumPy arrays as first-class data. It is built for scientists who already work in Python and want to inspect, annotate and script large multi-dimensional images without leaving the interpreter.

**napari/napari** — napari: a fast, interactive, multi-dimensional image viewer for python

- Repository: https://github.com/napari/napari
- Website: https://napari.org
- Stars: 2,762 · Forks: 538
- Language: Python
- License: BSD-3-Clause
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/napari-napari

## What problem napari solves, and for whom

Scientific imaging produces arrays that are too large and too dimensional for a general image viewer. A fluorescence stack might be three spatial axes plus a channel axis plus time, and the person looking at it is usually the same person who wrote the analysis code. napari targets that person. The README describes it as "a fast, interactive, multi-dimensional image viewer for Python", designed for "browsing, annotating, and analyzing large multi-dimensional images".

The intended audience is visible in the packaging metadata. The classifiers list Scientific/Research, Education, Bio-Informatics and Visualization, and the layer types map onto scientific data rather than photographs. If your data is already a NumPy array, napari accepts it directly. If your data is a TIFF you open with imageio or a Dask array you never fully load, the same path applies. The tool is not aimed at photographers, designers, or anyone who wants a viewer that is not attached to an interpreter.

## The layer model and how data reaches the screen

napari's architecture is a stack of layers over a rendering backend. The README states that the viewer supports six layer types, Image, Labels, Points, Vectors, Shapes and Surface, each tied to a different data type and interaction model. You add several layers of different types to one viewer and then adjust their properties. Every layer type accepts n-dimensional data, and the viewer browses 2D or 3D slices of it.

Underneath, the GUI is Qt and rendering is vispy, which the README describes as GPU-based. The scientific Python stack sits below that: numpy, scipy, dask, pandas, magicgui, pydantic and psygnal all appear in the dependency list in pyproject.toml. That dependency set explains both the strengths and the weight of the install. Communication runs in both directions between the viewer and the Python kernel, which the README calls out as useful when launching from Jupyter notebooks or from the built-in console. In practice this means you can click on a layer and query it, or change the array from the console and watch the display update.

One detail worth noting from the repository layout: the project pins its plugin interface through npe2, declared as a dependency, and there is a separate napari-plugin-engine package. Plugin authors work against that interface rather than against the viewer internals.

## Installing napari and opening your first viewer

The fastest path in the README does not require a permanent install. Install uv, then run napari straight from the package index with the all extra, which pulls in the Qt binding and the rest of the optional GUI dependencies.

```bash
uvx "napari[all]"
```

A window should open. In the File menu, select Open Sample and pick a sample image to confirm the viewer works before you point it at your own data.

For a real working setup, the README recommends a virtual environment. The documented sequence creates a conda environment on Python 3.13 and installs napari with pip.

```bash
conda create -y -n napari-env -c conda-forge python=3.13
conda activate napari-env
python -m pip install "napari[all]"
```

If you would rather keep everything in conda, the README gives the alternative of running conda install -c conda-forge napari pyqt6 in place of the pip line. Note the Python floor: pyproject.toml sets requires-python to >=3.11 and lists classifiers through 3.14, so an older interpreter will not install the current release.

With the environment active, the README's simple example opens a viewer from an IPython shell using a sample from scikit-image. The channel_axis argument tells napari which axis holds channels, and ndisplay=3 requests a 3D view.

```python
from skimage import data
import napari

viewer, layers = napari.imshow(data.cells3d(), channel_axis=1, ndisplay=3)
```

Run the same thing from a plain script and the process exits immediately unless you hand control to the event loop. The README shows the fix: call napari.run() after imshow.

```python
from skimage import data
import napari

viewer, layers = napari.imshow(data.cells3d(), channel_axis=1, ndisplay=3)
napari.run()
```

That distinction between the interactive shell and the script is the first thing that trips people up, and it is documented rather than hidden.

## Where napari is the wrong tool

The project classifies itself as Beta in pyproject.toml, and the release history matches that label: v0.9.2rc1 and v0.9.2a1 both landed in September 2026 alongside the stable v0.9.1. Pre-release tags in the default flow mean the API you write against today can move. If you are building a long-lived pipeline that must not break on upgrade, that is a real cost, not a formality.

The install itself is the second constraint. A Qt desktop application with vispy, dask, pandas, pydantic and magicgui in its dependency tree is not a lightweight dependency for a headless server. If your job is to render images on a machine with no display, napari is the wrong layer. The same applies if you need a viewer for a non-Python team: nothing in the README describes a standalone binary or a web deployment, only installation through pip or conda.

Finally, the documentation is a moving target. The README says the tutorials are "still a work in progress" and that they will be updated regularly. That is an honest statement, and it means you should expect to read source and examples rather than a finished manual. The examples folder is substantial, with files covering 3D rendering, paths, vectors, kymographs, multiscale images and points with features, so the examples partly compensate. But a reader who wants a complete reference will not find one in the README.

## napari compared with Fiji and with plain matplotlib

The closest comparison for a life-sciences reader is Fiji/ImageJ. Fiji is a self-contained Java application with a large installed base and a plugin ecosystem built around ImageJ macros and scripts. It runs without a Python environment, which is exactly the property napari lacks. The difference in approach is where the data lives. In Fiji, the image lives inside the application and you script the application. In napari, the array lives in your Python process and the viewer is a window onto it. If your analysis is already NumPy and scikit-image, napari removes the export step. If your lab's workflow is recorded as ImageJ macros and your colleagues do not write Python, Fiji remains the better fit and napari adds a language barrier.

The other comparison is matplotlib or another static plotting library. Those produce a figure and stop. napari is interactive by construction: you scroll through the third dimension, toggle layers, and read values back from the console. For a publication figure, a static plot is cheaper and more reproducible. For exploration of a stack where you do not yet know what you are looking for, the interactive viewer is the point.

## Maintenance, releases and what the licence permits

The repository is not archived, and the last push was on 2026-09-24, days before the most recent release candidate. Development is ongoing and the cadence is fast enough that pre-releases appear in the same month as stable ones. The versioning scheme is declared as EffVer in the README badges, which signals that the project thinks about the cost of upgrades rather than promising strict semantic versioning.

The licence is BSD-3-Clause, declared in pyproject.toml and shipped as a LICENSE file at the repository root. The repository also contains an EULA.md at the top level, which is worth reading rather than assuming it is boilerplate. A permissive licence means you can redistribute and modify napari and embed it in commercial work, subject to the conditions in the licence text itself. This is a description of what the repository states, not legal advice; if you are shipping napari inside a product, have counsel read LICENSE and EULA.md together.

Upgrade cost concentrates in two places. Qt bindings change with platform packaging, and the plugin interface is versioned through npe2, so a plugin written for an older interface may need attention. The project provides a settings-schema target in the Makefile that regenerates the settings schema, which is a hint that configuration shape is a maintained artifact rather than an afterthought.

## Conclusion

Adopt napari if your data already lives in NumPy arrays and you want a viewer you can drive from Python, especially for 3D or multi-channel microscopy stacks. Do not adopt it if you need a pure point-and-click application on a machine without a Python environment, or if you expect a stable API, because the project classifies itself as Beta and ships pre-releases such as v0.9.2rc1. Before committing, verify that your Python version is 3.11 or newer, that a Qt binding installs cleanly on your platform, and that the plugins you depend on are published under the npe2 plugin interface.

## FAQ

### What is napari used for?

It is a multi-dimensional image viewer for Python, used for browsing, annotating and analyzing large multi-dimensional images. Its six layer types, Image, Labels, Points, Vectors, Shapes and Surface, cover scientific image data and annotations.

### How do I install napari?

The README recommends a virtual environment: create a conda environment on Python 3.13, activate it, then run python -m pip install "napari[all]". If you prefer conda throughout, the README gives conda install -c conda-forge napari pyqt6 instead.

### How do I install napari in Python?

Install it as a Python package into an environment running Python 3.11 or newer, since pyproject.toml sets requires-python to >=3.11. The README's command is python -m pip install "napari[all]" inside an activated environment.

### Is napari free and open source?

Yes. The repository states the licence as BSD-3-Clause, with a LICENSE file at the root, and the source is published on GitHub. The README also links to a NumFOCUS donation page for the project.

### What is napari python?

napari is a Python package, described in pyproject.toml as an n-dimensional array viewer in Python, and it is imported as napari. The README's examples call napari.imshow to open a viewer and napari.run to start the event loop.

### How do I use napari?

Pass an array to napari.imshow, optionally with channel_axis to mark the channel dimension and ndisplay=3 for a 3D view, then call napari.run from a script or continue working in an IPython shell. In the GUI, the File menu's Open Sample entry loads a sample image.

## Sources

- [License: BSD-3-Clause](https://github.com/napari/napari/blob/main/LICENSE)
- [napari/napari on GitHub](https://github.com/napari/napari)
- [Project website](https://napari.org)
- [README](https://github.com/napari/napari/blob/main/README.md)
- [Releases](https://github.com/napari/napari/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/napari-napari