rapids-singlecell: GPU-Accelerated Single-Cell Omics

• rapids-singlecell is a GPU-accelerated analytical framework for single-cell omics, delivering performance improvements of up to several hundred-fold over CPU pipelines.
• It leverages GPU-native libraries such as CuPy, cuML, and cuGraph to efficiently execute core steps like PCA, UMAP, clustering, and batch correction.
• The framework integrates natively with the scverse ecosystem using a near drop-in API that mimics Scanpy, streamlining the transition to GPU workflows.

rapids-singlecell is a GPU-accelerated analytical framework designed for scalable, interactive single-cell omics data analysis. It integrates natively with the scverse ecosystem, operates directly on the AnnData data structure, and delivers performance improvements of up to several hundred-fold over optimized CPU pipelines. By leveraging GPU-native array libraries (CuPy) and the RAPIDS suite (cuML, cuGraph, RMM), rapids-singlecell enables efficient execution of the core steps of single-cell workflows—including quality control, normalization, feature selection, dimensionality reduction (PCA, UMAP), graph construction, clustering, and batch correction—at the scale of tens to hundreds of millions of cells. The framework emphasizes minimal workflow disruption, with a near drop-in API compatible with established Scanpy conventions and seamless extensibility through multi-GPU and distributed processing (Dicks et al., 2 Mar 2026).

1. Framework Architecture and Ecosystem Integration

rapids-singlecell builds on the AnnData schema, the canonical format for single-cell analysis, and ensures bidirectional compatibility with scverse tools. It directly reads and writes to AnnData fields (adata.X, adata.layers, adata.obs, adata.var, adata.obsp) without data conversion. A single function call (e.g., rsc.get_anndata_to_GPU(adata)) efficiently transfers all dense and sparse matrices in an AnnData object to GPU memory. This ecosystem-level integration preserves the interoperability between rapids-singlecell and other scverse packages such as Scanpy, Squidpy, Decoupler, and Pertpy (Dicks et al., 2 Mar 2026).

All array computations utilize CuPy, with full support for dense and sparse formats mirroring SciPy’s API. RAPIDS libraries are layered beneath this interface: cuML provides PCA, UMAP, and t-SNE modules; cuGraph accelerates k-nearest-neighbor graph construction and Leiden clustering; RMM manages GPU memory, enabling pooling and oversubscription by spilling to host RAM; and Dask enables multi-GPU and out-of-core partitioned workflows. The rapids-singlecell API closely mirrors Scanpy: function signatures and user interface patterns are preserved (e.g., rsc.pp.normalize_total corresponds to sc.pp.normalize_total) to minimize code changes during migration to GPU workflows (Dicks et al., 2 Mar 2026).

2. Accelerated Single-Cell Analytical Methods

rapids-singlecell implements GPU-native versions of essential analytical steps:

• Filtering and Normalization: Cell- and gene-level quality control is realized as parallel GPU reductions over sparse CSR matrices. Library-size normalization rescales cell profiles to a user-specified target sum (typically 10⁴), followed by log1p-transformation,

$$x'_{ij} = \log\bigl[1 + (x_{ij}/\sum_j x_{ij}) \times s\bigr].$$

All operations are performed in-place on-device, precluding costly dense intermediate conversions or CPU transfers.

• Highly Variable Gene (HVG) Selection: A CUDA kernel computes per-gene means ($\mu_j$) and variances ($\sigma^2_j$) directly on sparse CSC matrices, fits a mean–variance trend, and identifies HVGs analogously to Scanpy’s approach.
• Principal Component Analysis (PCA): Feature covariance is computed using custom upper-triangular GPU kernels, and centering is applied as $C = \frac{1}{n-1}(S - n u u^\top)$ with $u = (1/n) X^\top 1$. cuML’s truncated eigensolver extracts the top loadings, and projection is performed with GPU-optimized chunked, implicitly-centered multiplication.
• UMAP Embedding: cuML’s UMAP implementation optimizes the cross-entropy objective

$$C = \sum_{i<j} \left[-p_{ij}\log q_{ij} - (1-p_{ij})\log (1-q_{ij})\right],$$

where $p_{ij}$ are obtained from sparse kNN graphs, and $q_{ij}$ define low-dimensional similarities. All neighbor searches, graph symmetrizations, and SGD steps are GPU-accelerated.

• Neighborhood Graph and Clustering: kNN graphs use cuML or cuGraph’s PyNNDescent, stored as sparse CSR in adata.obsp on-GPU. Leiden clustering is implemented via cuGraph, targeting modularity and Potts model objectives:

$$Q = \sum_{ij}[A_{ij} - \gamma(k_i k_j / 2m)]\delta(c_i, c_j).$$

• Batch Correction (Harmony): Harmony integration is GPU-accelerated, operating on PCA embeddings. Batch correction is achieved by iteratively solving weighted linear models in latent space, projecting with batch label weights and avoiding dense one-hot matrices. Results empirically match CPU outputs with Pearson correlation >95% (Dicks et al., 2 Mar 2026).

3. GPU-Specific Optimizations for UMAP and Downstream Steps

GPU-accelerated UMAP in RAPIDS cuML leverages specialized algorithmic improvements (Nolet et al., 2020):

• k-NN graph construction is performed using the FAISS exact-search backend entirely on-GPU, minimizing host–device transfer.
• Fused kernels are used for $\rho_i$, $\mu_j$0 computations and for fuzzy-set union operations, yielding 12–15× speedups over naïve separate computations.
• Embedding optimization exploits one CUDA thread per positive edge and negative samples, with atomic update minimization and shared memory register accumulation.
• Data batching, epoch-boundary global memory updates, and distributed multi-GPU inference enable linear scalability across up to 8 GPUs, embedding tens of millions of cells in seconds.

4. Performance Benchmarks and Scaling

Performance gains are substantial. A canonical 1.3 M-cell mouse-brain workflow (Normalize → HVG → PCA → kNN → UMAP → Leiden) completes in 26 seconds on an NVIDIA DGX B200 (192 GB HBM3e), compared to 52 minutes on a 32-core AMD Threadripper Pro CPU—a >120× speedup (Dicks et al., 2 Mar 2026). Stepwise accelerations are outlined below:

Step	CPU Time	GPU Time	Speedup
Preprocessing	—	—	70×
PCA	—	—	80–100×
kNN graph	—	—	200×
UMAP	—	—	350×
Leiden clustering	—	—	100×

Batch correction with Harmony exhibits 100× (200k cells) to 250× (2.4M cells) speedup and maintains <25s total runtime for 11.4M cells. Atlas-scale workflows (100M cells, 8×DGX B300) complete in <20 minutes. RMM’s explicit memory pooling and host oversubscription support workflows for >1M cells on 16GB cards, with longer runtimes if host RAM is used (Dicks et al., 2 Mar 2026).

End-to-end R pipelines monitored with CudaMon confirm that compute-intensive steps (PCA, UMAP, clustering) saturate GPU utilization, while data loading and quality control are bottlenecked by I/O. For 1M cells, overall throughput $\mu_j$1 cells/s, with per-step utilization efficiencies $\mu_j$2, $\mu_j$3 (Zadenoori et al., 13 May 2026).

5. Workflow Usage, Best Practices, and Monitoring

GPU acceleration requires minimal code modifications—imports and function call changes. Example rapids-singlecell workflow:

$\mu_j$4

Tuning parameters (e.g., n_neighbors, min_dist in UMAP) is rapid, permitting interactive exploration. For >1M cells and multi-GPU clusters, Dask-based chunking and distributed computation is recommended for optimal memory and throughput. Data partitioning in chunks of ~50k cells balances GPU memory and scheduling overhead (Dicks et al., 2 Mar 2026).

Performance monitoring via CudaMon in R provides stepwise diagnostics: GPU memory and utilization traces, detection of I/O bottlenecks, and event-oriented profiling. Monitoring recommends:

• Overlapping data transfer with compute (asynchronous CUDA streams)
• Preallocating memory and chunking I/O
• Exporting raw metrics for reproducibility and bottleneck debugging (Zadenoori et al., 13 May 2026)

6. Limitations, Bottlenecks, and Future Considerations

Although compute kernels are highly optimized, several bottlenecks persist:

• I/O and data management phases (e.g., AnnData loading, QC) can dominate total runtime and saturate <40% of available GPU.
• Host-to-device transfer latency and storage limitations may become limiting for ultra-large datasets without NVMe or high-bandwidth interconnects.
• Out-of-core workflows and memory oversubscription can slow runtime if hardware limits are exceeded.

A plausible implication is that further acceleration will require novel solutions for high-throughput data streaming, asynchronous I/O, and distributed orchestration at the file and memory management level. Future work may address these with advanced chunked APIs and integration of faster storage backends (Zadenoori et al., 13 May 2026).

7. Impact on Single-Cell Omics and Computational Biology

The advent of rapids-singlecell and RAPIDS-accelerated workflows enables real-time, interactive hypothesis-testing and iterative exploration of single-cell transcriptomic atlases previously limited by CPU-bound bottlenecks. GPU acceleration transforms analysis from a timescale of hours or days to seconds or minutes, enabling full-data exploration without partitioning or downsampling even for atlases of 100M+ cells (Dicks et al., 2 Mar 2026). This scalability fundamentally shifts best practices in computational single-cell biology, algorithm design, and large-cohort integrative analysis.

By embedding GPU-native computation into canonical analysis workflows and providing instrumentation at the resource and performance level, rapids-singlecell establishes an extensible, reproducible, and interoperable analytical infrastructure for single-cell omics at unprecedented scales (Dicks et al., 2 Mar 2026, Zadenoori et al., 13 May 2026, Nolet et al., 2020).