GPU-accelerated single-cell and spatial omics analysis with rapids-singlecell, RAPIDS and JupyterLab in a ready-to-run CUDA container. AnnData-first and largely Scanpy-compatible, for x86-64 and Arm.
rapids-singlecell Lite Container Overview
Description
The rapids-singlecell "lite" container packages rapids_singlecell — Graphics Processing Unit (GPU)-accelerated single-cell analysis with an AnnData-first API, largely compatible with Scanpy and including selected functionality from Squidpy, decoupler and pertpy, running common single-cell workflows on GPUs via CuPy and NVIDIA CUDA-X Data Science — together with its GPU dependency stack, a JupyterLab environment and its own test suite, as a ready-to-run CUDA image.
Four images are published for each release, one per CPU architecture and CUDA
major version: {x86_64, aarch64} × {cu12, cu13}. See Container Version(s)
below for the tags.
The container houses a numerical analysis library, not a trained model. It
carries no model weights, no checkpoints and no inference server. The
algorithms it accelerates — PCA, nearest neighbors, UMAP, Leiden and Louvain
clustering, differential expression, regression, and the spatial statistics in
rapids_singlecell.squidpy_gpu — are computed from the user's own data at run
time. The library is part of the scverse® project.
Alongside it the image carries jupyterlab, ipykernel, bokeh and squidpy, so it is usable as an interactive analysis environment rather than only as a continuous integration (CI) artifact.
The container components are ready for commercial or non-commercial use.
License/Terms of Use
Use of this container is governed by the NVIDIA Software License Agreement and Product-Specific Terms for NVIDIA AI Products.
The principal components and their licenses:
| Component | License |
|---|---|
| rapids_singlecell | MIT (© 2022 Severin Dicks, © 2025 scverse®) |
| Build and CI tooling | Apache-2.0 |
| CUDA base image, RAPIDS and CuPy components | NVIDIA license terms |
| Ubuntu 24.04 userland | GNU General Public License (GPL) 2.0 and others, per dpkg |
The complete per-component inventory is generated from each image at build time and shipped inside it; see Third-Party Licenses below.
You are responsible for ensuring that your use of NVIDIA provided containers complies with all applicable laws.
Third-Party Licenses
Every published image carries its attribution file inside it, at
/opt/NOTICES.txt, reproducing the copyright notices and verbatim license text
of every Python distribution and every dpkg package in that image:
docker run --rm nvcr.io/nvidia/clara/rapids-singlecell:0.18.1-1-x86_64-cu13 cat /opt/NOTICES.txt
It is generated during the build from the finished environment rather than maintained by hand, so it describes what actually shipped rather than what was intended to.
The build also checks licenses: any strong-copyleft component in the Python
layer fails the build unless it has been reviewed and exempted, and the Python
layer currently has no such exemptions — it is entirely permissive or
NVIDIA-licensed. The image installs the test-minimal dependency group
specifically to drop igraph (GPL-2.0-or-later), which was the only
strong-copyleft component it would otherwise carry. The OS layer is reported
rather than gated, because an Ubuntu userland is unavoidably GPL.
Deployment Geography
Global.
Use Case
GPU-accelerated single-cell and spatial transcriptomics analysis.
Release Date
NGC 11/20/2026 via https://catalog.ngc.nvidia.com/orgs/nvidia/teams/clara/containers/rapids-singlecell
References
- rapids_singlecell source and issue tracker: https://github.com/scverse/rapids_singlecell
- rapids_singlecell documentation: https://rapids-singlecell.scverse.org/en/stable/
- RAPIDS: https://rapids.ai
- scanpy, which this API is largely compatible with: https://scanpy.scverse.org/en/stable/
- squidpy: https://squidpy.readthedocs.io/en/stable/
Model Architecture
- Architecture Type: Other: Not Applicable (numerical analysis library; no neural network)
- Network Architecture: Not Applicable
- Number of model parameters: Not Applicable
- Model Version(s): Not Applicable (the container carries no model; for the image versions, see Container Version(s) below)
Input
- Input Type(s): Tabular, Other: AnnData single-cell matrices
- Input Format(s): AnnData (
.h5ad, Zarr) - Input Parameters: Two-Dimensional (2D) cells × features matrices
- Other Properties Related to Input: Dense or sparse count matrices held in an AnnData object; practical dataset size is bounded by available GPU memory.
Output
- Output Type(s): Tabular, Other: AnnData single-cell matrices
- Output Format(s): AnnData (
.h5ad, Zarr) - Output Parameters: Two-Dimensional (2D) cells × features matrices and per-cell or per-feature annotations
- Other Properties Related to Output: Embeddings, cluster labels, neighbor graphs, differential-expression scores and spatial statistics, stored back into the AnnData object.
Training, Testing, and Evaluation Datasets
The container carries no trained model and ships no datasets; analyses run on data the user supplies.
Training Dataset
- Data Modality: Other: Not Applicable (no training data; size bucket: Not Applicable)
- Data Collection Method: Not Applicable
- Data Labeling Method: Not Applicable
- Dataset Properties: Data count: none. Modalities: none. Nature of content: none; the container carries no trained model and bundles no training data. Linguistic characteristics: Not Applicable.
Testing Dataset
- Data Collection Method: Not Applicable
- Data Labeling Method: Not Applicable
- Dataset Properties: Data count: none. Modalities: none. Nature of content: none; the container bundles no testing data. Linguistic characteristics: Not Applicable.
Evaluation Dataset
- Data Collection Method: Not Applicable
- Data Labeling Method: Not Applicable
- Dataset Properties: Data count: none. Modalities: none. Nature of content: none; the container bundles no evaluation data. Linguistic characteristics: Not Applicable.
Program Classes
The container includes no models. It houses the following software components:
| Model Name & Link | Use Case | How to Pull the Model |
|---|---|---|
| rapids_singlecell | GPU-accelerated single-cell and spatial transcriptomics analysis | Automatic |
| RAPIDS (cuDF, cuML, cuGraph) and CuPy | GPU dataframe, ML and array backends the library dispatches to | Automatic |
| squidpy | Builds the spatial graphs that rapids_singlecell.squidpy_gpu consumes | Automatic |
| JupyterLab, ipykernel, bokeh | Interactive analysis environment; bokeh also serves the dask distributed dashboard | Automatic |
| rapids_singlecell test suite | Validates each built image on real GPUs | Automatic |
No component is downloaded at run time; the image is self-contained.
Deployment Details
The image is a CUDA/Python environment, not a service — there is no inference
endpoint to stand up. Pull it, run it with GPU access, and work in JupyterLab
or a shell. Use an x86_64 tag on x86-64 hosts and an aarch64 tag on Arm
hosts such as Grace, and a cu13 tag for Blackwell GPUs.
Pull an image:
docker pull nvcr.io/nvidia/clara/rapids-singlecell:0.18.1-1-x86_64-cu13
Start JupyterLab with your current directory mounted as /workspace:
docker run --rm --gpus all -p 127.0.0.1:8888:8888 -p 127.0.0.1:8787:8787 -v "$(pwd)":/workspace \
nvcr.io/nvidia/clara/rapids-singlecell:0.18.1-1-x86_64-cu13
- Open the JupyterLab URL printed in the container log; it includes an access token, which changes every time the container starts. Token authentication is on by default; only disable it (
--ServerApp.token='') where that is safe. - Port 8888 is JupyterLab. Port 8787 is the dask dashboard. Both are published on
127.0.0.1only, so nothing else on the network can reach them. Keep it that way: the dask dashboard has no authentication of its own. - To work from another machine, forward both ports over SSH with
ssh -L 8888:127.0.0.1:8888 -L 8787:127.0.0.1:8787 <gpu-host>, then open the tokenized URL on your own machine.
Check that the GPU is visible:
docker run --rm --gpus all nvcr.io/nvidia/clara/rapids-singlecell:0.18.1-1-x86_64-cu13 \
python -c "import cupy; print(cupy.cuda.runtime.getDeviceCount(), 'GPU(s) visible')"
Run a script instead of JupyterLab:
docker run --rm --gpus all -v "$(pwd)":/workspace \
nvcr.io/nvidia/clara/rapids-singlecell:0.18.1-1-x86_64-cu13 python /workspace/my_analysis.py
Requirements: a Linux host (x86-64 or aarch64), a container runtime, the NVIDIA
Container Toolkit, an NVIDIA driver that supports the image's CUDA version
(12.9 for cu12, 13.1 for cu13), and at least one NVIDIA GPU whose compute
capability is compiled into the chosen image. The cu12 images compile for
75;80;86;89;90 and the cu13 images for 75;80;86;89;90;100;120, so Blackwell
requires a cu13 image and has no cu12 fallback.
Inside the image: virtual environment at /opt/venv (already on PATH), source
and test suite at /src/rapids_singlecell, working directory /workspace for
mounting data, and the fully resolved environment recorded at
/opt/venv-manifest.txt. The container starts its setup as root, then runs
JupyterLab or your command as the non-root user rsc, matched to the owner of
the mounted /workspace (1000:1000 unless the workspace belongs to a different
non-root user).
Supported hardware, as exercised by the test matrix:
| Microarchitecture | Validated on | Compute capability |
|---|---|---|
| NVIDIA Ada Lovelace | L40S | 8.9 |
| NVIDIA Ampere | A100 | 8.0 |
| NVIDIA Blackwell | RTX PRO 6000 Blackwell | 12.0 |
| NVIDIA Hopper | H100, GH200 Grace Hopper | 9.0 |
| NVIDIA Turing | T4 | 7.5 |
Software Integration
- Runtime Engines: CUDA, CuPy, RAPIDS (cuDF, cuML, cuGraph), Python 3.13
- Supported Hardware Microarchitecture Compatibility: NVIDIA Ampere, NVIDIA Blackwell, NVIDIA Hopper, NVIDIA Lovelace, NVIDIA Turing
- Operating Systems: Linux (x86-64 and aarch64 hosts)
The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.
Inference
- Acceleration Engine: CUDA (via CuPy and NVIDIA CUDA-X Data Science)
- Test Hardware: NVIDIA Ada Lovelace L40S, NVIDIA Ampere A100, NVIDIA Blackwell RTX PRO 6000, NVIDIA Hopper H100, NVIDIA Hopper GH200, NVIDIA Turing T4
Other Properties Related to Output
Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA’s hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.
Container Version(s)
Each release is published as four tags of nvcr.io/nvidia/clara/rapids-singlecell:
| Tag | Architecture | CUDA | Base image |
|---|---|---|---|
0.18.1-1-x86_64-cu12 | x86-64 | 12.9.2 | NGC CUDA devel, Ubuntu 24.04 |
0.18.1-1-x86_64-cu13 | x86-64 | 13.1.2 | NGC CUDA devel, Ubuntu 24.04 |
0.18.1-1-aarch64-cu12 | aarch64 | 12.9.2 | NGC CUDA devel, Ubuntu 24.04 |
0.18.1-1-aarch64-cu13 | aarch64 | 13.1.2 | NGC CUDA devel, Ubuntu 24.04 |
Tags have the form <version>-<build>-<architecture>-<CUDA>: <version> is the
rapids_singlecell version, and <build> increases when the container is rebuilt
for the same version. Python 3.13 in every image.
Validation
There is no benchmark score to report; the artifact is a library, and its
pass/fail signal is its own test suite, which ships in the image at
/src/rapids_singlecell and runs inside each built image on GPUs spanning
Turing, Ampere, Ada Lovelace, Hopper, Grace Hopper and Blackwell, in both
single-GPU and two-GPU configurations. Two test cases skip by design as a
consequence of the licensing decision described above.
Security Common Vulnerabilities and Exposures (CVEs)
Please review the Security Scanning tab on NGC to view the latest security scan results. For certain open-source vulnerabilities listed in the scan results, NVIDIA provides a response in the form of a Vulnerability Exploitability eXchange (VEX) document. The VEX information can be reviewed and downloaded from the Security Scanning tab.
Ethical Considerations
NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. Developers should work with their internal developer team to ensure these software components meet requirements for the relevant industry and use case and address unforeseen product misuse.
Please report quality, risk, security vulnerabilities or NVIDIA AI Concerns here.
Limitations
This container processes data the user supplies and retains none of it. Single-cell and spatial transcriptomics data may be derived from human subjects and may constitute personal or health-related information; users are responsible for ensuring they hold the necessary rights, consents and approvals for any data they mount into it, and for handling it in accordance with applicable privacy and research ethics requirements. Results are a research tool and are not validated for clinical or diagnostic use.
Users are responsible for inputs and outputs. Users are responsible for ensuring safe integration, including implementing guardrails as well as other safety mechanisms, prior to deployment.
Get Help
Getting started
See Deployment Details above for a first run, and rapids-singlecell.scverse.org for the library's own documentation.
Issues with the packaged library belong upstream at github.com/scverse/rapids_singlecell/issues.