Skip to main content
NVIDIA
rapids-singlecell Lite
Container
NVIDIA
rapids-singlecell Lite

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:

ComponentLicense
rapids_singlecellMIT (© 2022 Severin Dicks, © 2025 scverse®)
Build and CI toolingApache-2.0
CUDA base image, RAPIDS and CuPy componentsNVIDIA license terms
Ubuntu 24.04 userlandGNU 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

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 & LinkUse CaseHow to Pull the Model
rapids_singlecellGPU-accelerated single-cell and spatial transcriptomics analysisAutomatic
RAPIDS (cuDF, cuML, cuGraph) and CuPyGPU dataframe, ML and array backends the library dispatches toAutomatic
squidpyBuilds the spatial graphs that rapids_singlecell.squidpy_gpu consumesAutomatic
JupyterLab, ipykernel, bokehInteractive analysis environment; bokeh also serves the dask distributed dashboardAutomatic
rapids_singlecell test suiteValidates each built image on real GPUsAutomatic

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.1 only, 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:

MicroarchitectureValidated onCompute capability
NVIDIA Ada LovelaceL40S8.9
NVIDIA AmpereA1008.0
NVIDIA BlackwellRTX PRO 6000 Blackwell12.0
NVIDIA HopperH100, GH200 Grace Hopper9.0
NVIDIA TuringT47.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

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:

TagArchitectureCUDABase image
0.18.1-1-x86_64-cu12x86-6412.9.2NGC CUDA devel, Ubuntu 24.04
0.18.1-1-x86_64-cu13x86-6413.1.2NGC CUDA devel, Ubuntu 24.04
0.18.1-1-aarch64-cu12aarch6412.9.2NGC CUDA devel, Ubuntu 24.04
0.18.1-1-aarch64-cu13aarch6413.1.2NGC 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.

Publisher
NVIDIA
LicenseNVIDIA proprietary
Latest Tag0.18.1-1-x86_64-cu13
UpdatedNovember 20, 2026 UTC
Compressed Size6.82 GB
Multinode SupportNo
Multi-Arch SupportNo

Modal Content

NVIDIA uses cookies to improve your experience on our web site. We and our third-party partners also use cookies and other tools to collect and record information you provide as well as information about your interactions with our websites for performance improvement, analytics, and to assist in marketing efforts. By clicking "Accept All", you consent to our use of cookies and other tools as described in our Cookie Policy. You can manage your cookie settings by clicking on "Manage Settings." By continuing to use this site or by clicking one of the buttons below, you agree to our Terms of Service (which contains important waivers). Please see our Privacy Policy for more information on our privacy practices.