Cellpose is a free, open-source model that segments cells and nuclei in microscopy images out of the box, with a drag-and-drop GUI so you never have to write code to get a first result. Pick it for standard cell or nucleus segmentation. Pick something else if you need a full pathology workflow with tissue classification, not just outlines.
Other good fits
Fixing the handful of images the base model gets wrong using human-in-the-loop retraining, instead of accepting bad outlines.
Running segmentation as a script over hundreds of images once the GUI has confirmed the model works on your data.
+ Pros
Read pros
Cellpose is an open-source, BSD-3-Clause licensed model for segmenting cells and nuclei in microscopy images. The current Cellpose-SAM model is a generalist: it was trained to handle noise, blur and contrast inversions across many imaging modalities without per-experiment retraining, and it segments both 2D and 3D data. It ships as a Python package with a drag-and-drop GUI, so a first test does not require writing code.
Pick it when
You have a folder of microscopy images and need cell or nucleus outlines without building a training set first.
You want to try segmentation interactively in the GUI before deciding whether to script it over a larger dataset.
A handful of images consistently segment badly and you want to retrain the model on just those, rather than start over.
− Cons
Read cons
Cellpose only produces cell and nucleus outlines; it has no built-in viewer beyond its basic GUI and no tissue-level classification, so it is not a replacement for a full digital pathology workflow. Its GUI is meant for testing and correction, not for managing a large annotated dataset. Without a GPU, segmenting many large images is slow enough that it becomes the bottleneck in a pipeline.
Pick something else when
You need whole-slide image handling and tissue or tumor classification, not just cell outlines: use QuPath.
You need a general-purpose viewer for large multi-dimensional datasets with annotation layers alongside segmentation: use napari, which Cellpose's own masks feed into directly.
You need scripted sequence or structure analysis rather than image segmentation: that is a different kind of tool, such as Biopython.
Avoid if
You have no GPU and need to process many large images quickly; CPU-only segmentation is workable but slow.
You need a general-purpose n-dimensional image viewer with annotation layers rather than a segmentation model; pair Cellpose with napari for that.
Requirements
Cellpose installs with pip install cellpose (add [gui] for the graphical interface) and supports Python 3.9, 3.11 or 3.12. It runs on CPU or GPU; GPU acceleration via CUDA is optional but recommended once you are processing more than a handful of images, since CPU-only inference is markedly slower.
First run
Documentation-based suggestion — not run here.
Read first run
Segment a folder of nuclei images and confirm the outlines are usable before scripting the rest of your dataset. The book From microscopy image to cell counts walks through this.
Install Cellpose with the GUI extra and open a handful of representative images.
Run the default Cellpose-SAM model and look at the outlines it draws.
Pick two or three images where it clearly gets cells wrong, and use the GUI's human-in-the-loop retraining to correct them.
Re-run the corrected model on the same images and compare.
Once the outlines look right, write a short script that loops the model over the rest of the image folder.
Integration
Cellpose's Python API returns masks you can feed directly into napari for visualization and annotation, or into a pandas/numpy pipeline for downstream measurements. The GUI is meant for a first check and for human-in-the-loop retraining, not for batch production runs; once a model works, call it from a script to process a full dataset unattended.
Check the result
Overlay the predicted masks on the original image and check by eye that cell boundaries follow real cell edges, not noise or debris; count a few images by hand and compare to the model's count before trusting it on the full dataset.
Links & evidence
Documentation-based · not hands-on · Sep 23, 2026
Rests on the Cellpose product page and the MouseLand/cellpose GitHub repository (README and install instructions), both read on 2026-09-23, for licence, installation and the Cellpose-SAM model description. Nothing was installed or run for this review; the first project is a suggested exercise.
Cellpose product page · Sep 23, 2026 — Generalist cellular segmentation algorithm; Cellpose-SAM is the current release; web upload demo and HuggingFace space for quick testing.
Cellpose GitHub repository · Sep 23, 2026 — BSD-3-Clause licence; pip install cellpose (Python 3.9/3.11/3.12); GUI via cellpose[gui]; CPU or GPU (CUDA) inference; human-in-the-loop retraining; 3D support.
Cellpose installation guide · Sep 23, 2026 — GPU acceleration also covers Apple Silicon (MPS) and AMD ROCm on Linux, in addition to CUDA; Windows 10 and Ubuntu 18.04 are the well-tested platforms.
Further review notes & alternatives
Costs and operating effort
Cellpose is free and open source under the BSD-3-Clause licence, with no paid tier. There is nothing to buy: the only real cost is compute, and a GPU speeds up large batches considerably over CPU-only inference. The running effort is periodically checking new data against the model, since a new imaging setup, stain or magnification can shift how well the generalist model performs, and re-running human-in-the-loop retraining on cases it misses.
Alternatives and trade-offs
napari is the natural companion, not a substitute: use it to view and annotate the images Cellpose segments, especially in 3D.
QuPath wins when the job is whole-slide pathology analysis with tissue classification, not just per-cell segmentation.
Fiji has its own segmentation plugins (including ones that call Cellpose) and is the better choice if your pipeline is already built around ImageJ macros.
Cellpose is an open-source generalist model for segmenting cells and nuclei in microscopy images, distributed as a Python package with a drag-and-drop GUI. The current Cellpose-SAM model runs on CPU or GPU, handles 3D volumes, and supports human-in-the-loop retraining on images the base model gets wrong.