pyVIPER: a fast and scalable Python package for protein activity estimation and master regulator analysis of single-cell RNA sequencing data Authors: Alexander L. E. Wang, Luca Zanella, Zizhao Lin, Filippo Riva, Heeju Noh, Gabriel M. Aizenman, Lukas Vlahos, Miquel Anglada-Girotto, Rowan Cassius, Léo Dupire, Aziz Zafar, Andrea Califano, Alessandro Vasciaveo Published: 2026 ABSTRACT SummarySingle-cell sequencing has revolutionized biomedical research by offering insights into cellular heterogeneity at unprecedented resolution. Yet, the low signal-to-noise ratio characteristic of single-cell RNA sequencing (scRNA-seq) challenges quantitative analyses. Gene regulatory network (GRN) analysis can help overcome this obstacle, enabling the mechanistic elucidation of cellular state determinants. For instance, the VIPER algorithm can identify Master Regulator proteins from gene expression data. However, as the size and complexity of scRNA-seq datasets grow, the demand for scalable tools supporting the analysis of datasets with up to hundreds of thousands of cells becomes increasingly critical in its original implementation in R.ResultsTo address this challenge, we introduce pyVIPER, a Python-based tool for protein activity inference from transcriptional data. pyVIPER supports flexible data transformation/postprocessing modules, enrichment analysis algorithms, and features a novel data structure for GRNs manipulation. It integrates seamlessly with scverse, scanpy and widely adopted machine learning libraries. By leveraging PyTorch-based GPU acceleration and optimized core operations, benchmarking demonstrates orders-of-magnitude improvements in runtime efficiency compared to R-based VIPER, reducing analysis time for large datasets from hours to minutes.ConclusionspyVIPER is a fast, memory-efficient, and highly scalable Python toolkit for protein activity inference in large-scale scRNA-seq datasets. Its scalability and hardware acceleration enables high-throughput VIPER-based analysis of virtually any single-cell dataset while facilitating integration with other Python-based, including state-of-the-art machine learning workflows. Taken together, these features make pyVIPER a valuable resource to expand the applicability of mechanistic regulatory network-based analysis in single-cell research.Supplementary InformationThe online version contains supplementary material available at https://doi.org/10.1186/s12859-026-06524-x. Background We have shown that the analysis of gene expression data through the interrogation of context-specific gene regulatory networks (GRNs) plays a key role in the identification of Master Regulator (MRs) proteins representing mechanistic determinants of cellular states [1–4]. These MR proteins can be computationally identified using the VIPER (Virtual Inference of Protein Activity by Enriched Regulon analysis) and metaVIPER algorithms through the analysis of their transcriptional targets [5, 6]. VIPER leverages a gene expression signature and a GRN representing context-specific, genome-wide topological interactions between regulatory proteins and their downstream target genes, referred to as regulons. By focusing on the collective activity of entire regulatory programs, the VIPER framework provides a mechanistic lens to view cellular identity that is more robust and biologically interpretable than mRNA levels alone [5]. GRNs can be accurately reconstructed from gene expression data using several algorithms, e.g., ARACNe [7] or SCENIC [8], among others. VIPER prioritizes regulatory proteins whose regulons are most enriched in the gene expression signature of each individual sample, by performing a gene set enrichment analysis using the analytic Rank-based Enrichment Analysis (aREA) or the novel Non-parametric analytical-Rank-based Enrichment Analysis (NaRnEA) [5, 9]. Moreover, the metaVIPER algorithm extends this approach to the inference of protein activity by integrative analysis of multiple, non-tissue matched GRNs, thus assuming that the transcriptional targets of each protein can be recapitulated by one or more available GRN. This is an effective strategy for the analysis of cellular populations missing a matched GRN, due to either lack of lineage information or low sample availability [6]. While different statistical methods can be employed to infer biological activities from omics data, our VIPER framework has led to the identification of several physiological or dysregulated transcriptional programs with extensive and rigorous validation in a variety of contexts, including many cancer types and other diseases, demonstrating its accuracy and reliability [2–4, 10–14]. A primary advantage of VIPER over alternative frameworks is its rigorously validated algorithmic robustness. For example, VIPER-inferred differentially active proteins showed a > 250-fold reduction in sample-to-sample variance compared to differentially expressed genes across samples of the same subtype [5]. Additionally, the algorithm remains accurate even when up to 90% of the genes in the input signature are removed—a property of direct relevance to the gene dropout problem in scRNA-seq—and is robust to network noise: in normalization benchmarks, noticeable performance loss was only observed when > 60% of GRN interactions were randomized [5]. Notably, 45% of cancer mutations associated with VIPER-inferred protein activity signatures showed no significant differential expression of the corresponding gene [5], demonstrating that VIPER captures biologically critical regulatory hubs that are invisible to conventional expression-based methods. The recent availability of technologies to profile the transcriptome of individual cells by single-cell RNA sequencing (scRNA-seq) has provided unparalleled insights into tissue heterogeneity. Critically, scRNA-seq data exhibit high sparsity and low signal-to-noise ratio due to gene dropout biases, resulting in the capture of a small fraction of the expressed genes (10–20%) in every cell [15, 16]. This phenomenon hinders fine-grained quantitative analyses, such as the elucidation of small cell populations due to the lack of expression of few critical lineage markers. VIPER critically mitigates such gene dropout bias by robustly assessing the differential activity of regulatory and signaling proteins based on the differential expression of their downstream transcriptional targets. VIPER has been successfully applied to quantitate protein activity of > 6000 regulatory and signaling proteins in individual cells, including transcription factors and co-factors, chromatin remodeling enzymes, signaling proteins, and surface receptors [3, 13, 14]. Single-cell protein activity analysis has proven instrumental to the identification of rare cell types and novel cell states representing subpopulations that are virtually undetectable at the gene expression level, comparing favorably with flow cytometry and CITE-seq antibody-based measurements [13]. VIPER-inferred cell states have been linked to critical functional roles, including those affecting immune-evasion and progression [13, 14], disease heterogeneity and drug sensitivity in diabetes and cancer [3, 17, 18], and stem cell biology [4]. The ever-growing size of scRNA-seq datasets, due to lower reagent and sequencing costs, supports creation of extensive single-cell atlases and large-cohort analyses. Yet, they also require novel tools capable of analyzing tens to hundreds of thousands of cells. The current R-based VIPER implementations [5, 15] are not designed to handle dataset sizes that are becoming the de facto standard for single cell studies. This scalability gap is further exacerbated in the R-based NaRnEA implementation [9], which has improved specificity but is even more computationally demanding, making it hardly scalable to large datasets. Furthermore, the absence of production-ready Python implementations of VIPER has prevented seamless integration with the Python single-cell ecosystem (scverse, scanpy) and with state-of-the-art machine learning frameworks [19, 20]. To bridge this gap, we developed pyVIPER, a fast, memory-efficient, and highly scalable Python-based VIPER implementation. While other Python packages provide partial VIPER functionality [21], pyVIPER is the only one integrating all steps of a comprehensive protein activity workflow—from preprocessing and regulon handling to enrichment analysis and metaVIPER integration as well as novel postprocessing tools—ensuring full consistency with the original algorithm and further expanding beyond its original functionalities. For example, pyVIPER delivers OncoMatch [2]—a Master Regulator–based framework that scores how faithfully preclinical models recapitulate the regulatory state of patient tumors—as the first pip-installable, parameter-tuned module integrated directly into the Python single-cell ecosystem. The pyVIPER package leverages AnnData objects [22] and seamlessly integrates with standard single cell analysis packages, such as scanpy and others from the scverse ecosystem [19, 20]. Unlike previous R-based implementations, pyVIPER can directly interface with Machine Learning (ML) packages, such as scikit-learn, TensorFlow and PyTorch [23–25] to allow plug-and-play ML analyses that leverage VIPER-assessed protein activity profiles. We benchmarked pyVIPER’s performance improvements using scRNA-seq data from pancreatic ductal adenocarcinoma [26] and compared it to the R-based VIPER implementation [5, 15]. Implementation pyVIPER is available in Python and named after the ‘viper’ function, the Python implementation of the VIPER algorithm [5]. For each single cell, or bulk RNA-seq sample, ‘viper’ estimates the activity of regulatory proteins based on the expression of their downstream targets. Inputs include: (1) a gene expression matrix provided as an AnnData object or Pandas DataFrame, and (2) one or more GRN objects of a new Python class Interactome (see below). The function operates in VIPER or metaVIPER mode depending on the number of GRNs provided. Innovatively, users can select one of two enrichment algorithms, aREA [5] or NaRnEA [9] (see Tutorial 1 for details). Both algorithms compute the Normalized Enrichment Score (NES) of each protein, a test statistic that represents the enrichment of the protein’s target in differentially expressed genes and serves as a proxy for the quantification of its activity [5]. NaRnEA additionally computes the per-protein Proportional Enrichment Score (PES), a metric with values in the interval [− 1, + 1] that measures the effect size for each regulon’s enrichment. aREA and NaRnEA also differ in the formulation of their null models: aREA uses an empirical phenotype-specific permutation null model, while NaRnEA uses a fully analytical null model based on the maximum entropy principle [9]. Compared to aREA, NaRnEA improves type I error control resulting in higher sensitivity, at the expense of increased computational time [15]. Notably, aREA and NaRnEA allow also standalone use for pathway enrichment analysis; we provide a set of functions that exploit this feature (Tutorial 2). Optionally, users can request aREA correction for pleiotropic regulation (i.e., genes being regulated by multiple transcription factors) to minimize false positives arising from inactive regulators whose targets overlap significantly with bona fide active regulators [5]. Lastly, ‘viper’ supports independent execution modes for either CPU multicore parallelization or native PyTorch-based GPU acceleration (single-core) to maximize efficiency and seamlessly integrate with high-performance computing workflows [25]. The interactome class pyVIPER introduces the new Interactome class for easy GRN manipulation, as described in Tutorials 1–2 (see Availability and requirements). This class provides a unified data structure for complex tasks—such as taxonomy filtering, cross-species translation, and regulon pruning—that previously required fragmented, manually-coded routines. Interactomes can be conveniently created from any Pandas DataFrame with the following columns names: regulator, target, mor and likelihood. The first two columns denote the genes involved in the regulatory relationship, i.e. those for which there is an edge in the network topology; mor describes the “mode of regulation”, i.e. the directionality of the relationship: a positive value means that an increase in the regulator’s activity causes an increase in target expression, a negative value means that it leads to a decrease. Last, the likelihood quantifies the weight of the association. The Interactome class provides more than ten methods for network manipulation. These include: ‘filter_regulators’, to automatically filter a GRN to retain only those regulatory proteins belonging to selected ontology classes; ‘filter_target’, to focus only on specific regulatory-target interactions; ‘integrate’, to consolidate several Interactome objects into a “consensus” network that integrates multiple GRNs with similar epigenetics, such as those inferred from the same cell population in similar biological contexts but distinct datasets; ‘prune’, to prune each regulon to a specified number of targets, thus making aREA-inferred NES comparable across regulators and preventing regulators controlling more targets to numerically dominate those having fewer; ‘translate_regulators’ and ‘translate_targets’, to translate gene identifiers and symbols between HGNC, Ensembl genes, Entrez IDs, and orthologous genes between organisms (mouse and human); ‘read_networks’ for importing outputs from widely used GRN inference tools, such as ARACNe-AP, ARACNe3 and SCENIC [8, 9, 27] and formatting them into interactomes. pyVIPER’s modules pyVIPER has a modular architecture built around the AnnData class. Some of the main modules recall scanpy’s framework structure and are (Fig. 1):Fig. 1Overview of the pyVIPER package and its modular architecture. pyVIPER includes the core ‘viper’ function and several modules for the inference of Protein Activity from transcriptomic data, mainly scRNA-seq, analysis, visualization, and user-friendly tutorials Overview of the pyVIPER package and its modular architecture. pyVIPER includes the core ‘viper’ function and several modules for the inference of Protein Activity from transcriptomic data, mainly scRNA-seq, analysis, visualization, and user-friendly tutorials pp. The preprocessing module embeds functions for the preprocessing of gene expression and protein activity data. ‘viper_similarity’ computes a matrix of NES-based cell similarity scores based on the MRs of each cell state; ‘stouffer’ generates cluster-based protein signatures with Stouffer’s method [28]; ‘aracne3_to_regulon’ automatically converts the raw output of a GRN topology reconstructed with ARACNe3 [9] into a Pandas DataFrame with regulator, target, mor and likelihood columns; ‘rank_norm generates’ a gene expression signature by rank transformation of the input data (AnnData object or Pandas DataFrame) followed by median centering and mean absolute deviation- (MAD) based scaling; ‘repr_metacells’ generates metacells to rescue signal lost due to gene dropouts. Metacell assembly is performed by partitioning a k-nearest neighbors (k-NN) graph into homogeneous subsets of cells and aggregating their unnormalized counts, thus generating “pseudo-bulk” profiles that can be used for downstream gene expression analysis or as input to ARACNe or other GRN-inference algorithms for datasets with median depth less than 10 k UMI/cell [15]. Metacell overlap is minimized by splitting all the data into N groups of neighboring cells where N is the number of desired metacells. This is followed by selecting a cell within each group for conversion to a metacell based on the minimal overlap of its k-NN with all other selected cells (Tutorial 3). Translate conveniently allows the translation of gene names like those within the Interactome class. tl. The tools module provides functions for transformation and postprocessing of a VIPER-inferred protein activity matrix. ‘find_top_mrs’, identifies candidate MRs within each cluster; ‘path_enrich’ leverages aREA and NaRnEA to compute pathway enrichments based either on gene expression or protein activity profiles; ‘oncomatch’, implements a tumor-to-model (i.e., organoid, cell line or mouse models) fidelity analysis based on the overlap of MR proteins inferred from patient and model samples, a methodology validated in several preclinical and precision medicine studies [2]. Other modules include pl, which not only wraps the ‘scanpy.pl’ module for simultaneous visualization of gene expression and protein activity, but also allows generating heatmaps to plot the top MRs from each cluster and visualize the regulator-target relationships in Interactome objects; config, for user specifications of many default pipeline settings, such as the species being analyzed and the custom list of regulatory proteins used to automatize the analysis workflow, and load, which provides previously curated lists of regulatory and signaling proteins, gene sets from the Molecular Signature Database (MSigDB) [29] formatted as an Interactome, and a large collection of prebuilt PISCES regulatory networks (‘pyviper.load.pisces_network’) spanning 29 tissue contexts and 49 unique cell types, covering major epithelial, immune, mesenchymal, and organ-specific lineages [15]. To help users navigate the numerous functionalities offered by pyVIPER, we provide 3 detailed tutorials covering relevant topics, including GRN manipulation and VIPER analysis (Tutorial 1), gene expression signature generation and metaVIPER analysis (Tutorial 2), and metacell assembly (Tutorial 3). Results pyVIPER implementation offers greater scalability to large single-cell datasets comprising several hundred thousand cells, thus overcoming the memory-constraints and runtime limitations of the VIPER’s R-based implementations [5, 15]. This is achieved through several computational improvements over the original R implementation that leverage Python’s performance advantage and improved programming paradigms. Key enhancements include the use of optimized data structures such as the Interactome objects, faster and more efficient than the vectors of lists used in R, and faster vectorized operations enabled by the highly optimized C-based core of Numpy [30]. Additionally, pyVIPER supports multicore processing, batching, and hardware-accelerated execution via PyTorch to drastically reduce runtimes on massive single-cell atlases. To test the performance of the core ‘viper’ function, we ran multiple benchmarks on input data of varying size (1 k, 2 k, 5 k, 20 k, and 50 k cells). Each instance was generated by randomly sampling the selected number of cells from a large transcriptomic atlas of 41,986 individual cells from primary pancreatic tumors [26]. UMI data were normalized and transformed to Pearson residuals [31]. To mimic different biological scenarios, we computed the enrichment score of two sets of 2 k and 5 k regulatory proteins. Each GRNs was reverse engineered using ARACNe3. Tests were run using both aREA and NaRnEA enrichment algorithms. metaVIPER was run by integrating n = 5 lineage-specific GRNs, each pruned to 100 targets and runtimes were recorded for several memory allocations, 16, 32, 48 and 64 GB. All the tests were run on an Intel® Xeon® E5-2630 CPU with 15 M Cache, 2.30 GHz, using a single core. Figure 2a schematically represents all the configurations tested. Notably, pyVIPER demonstrated critical performance improvements compared to R-based VIPER, for all memory configurations (Fig. 2d, Extended Data Fig. 1), with increasingly significant gains for the most demanding analyses (e.g. NaRnEA-based metaVIPER). As an example, metaVIPER execution on 5 k cells showed a runtime decrease of up to 15 times, from approximately 6 h to less than 10 min. Moreover, given the same memory allocation (32 GB), pyVIPER easily supported the analysis of 20,000 vs. 5000 cells for VIPER (400% improvement) (NaRnEA enrichment, Fig. 2c). Similar outcomes were observed for all memory configurations and number of inferred regulators. pyVIPER faithfully reproduced the results of the R-based implementation, as benchmarked across three single-cell datasets, with relative discrepancies (%) in the order of 10–14–10–15 (NES, aREA) and 10–7–10–5 (NES; PES, NaRnEA) (P-values for such differences is > 0.99) and protein activity profiles with Pearson’s correlation asymptotically 1.0 (Extended Data Fig. 2). Additional details on pyVIPER accuracy estimation are illustrated in Supplementary Information 1. Finally, we emphasize that beyond computational metrics, the ultimate measure of an advanced bioinformatics software tool is its utility to drive biological discovery. This is exemplified by pyVIPER’s application across studies characterizing complex disease states [3]. Notably, pyVIPER serves as the computational backbone for standardized systems biology frameworks, including a recently established protocol for the high-resolution analysis of intestinal stem cell populations, and AI models, such as GREmLN, a GRN-informed foundation model for biologically informed single-cell gene embedding generation. [3, 4, 32–34].Fig. 2pyVIPER performance comparison vs R-based implementations. a Configurations tested in the Python vs R runtime comparison. 20 configurations were generated for different numbers of i. input single-cells (1 k, 2 k, 5 k, 20 k, 50 k), ii. inferred regulatory proteins (1 k, 5 k) and iii. input regulatory networks (1 for runs involving VIPER and 5 for runs involving metaVIPER). VIPER and metaVIPER were run using both the aREA (meta-aREA) and NaRnEA (meta-NaRnEA) enrichment methods. Each instance was executed using 4 memory allocations: 16, 32, 48 and 64 GB. b and c Python vs R runtime comparisons: VIPER- and metaVIPER-based Protein Activity inference of 2 k regulators (NaRnEA enrichment) with 32 GB of allocated memory. pyVIPER exhibits a substantial runtime decrease compared to the R-based implementation. pyVIPER’s speedup is even more significant for the most demanding configurations (e.g., metaVIPER), where it provides a runtime decrease from several hours to minutes (e.g., from 6 h to < 10 min with 5 k cells). pyVIPER scales more efficiently with the number of cells, enabling the analysis of 4 × more cells with the same memory allocation. p < d Python vs R average runtime comparison for each enrichment algorithm: Protein Activity inference of 2 k regulators with 32 GB of allocated memory shows runtime reductions up to 15 times. All the metaVIPER runs involved 5 regulatory networks inferred from malignant ductal, normal ductal, fibroblast, endothelial and B cell populations. Time is in seconds (s) in all plots. All tests where run on an Intel® Xeon® E5-2630 2.30 GHz CPU using 1 core pyVIPER performance comparison vs R-based implementations. a Configurations tested in the Python vs R runtime comparison. 20 configurations were generated for different numbers of i. input single-cells (1 k, 2 k, 5 k, 20 k, 50 k), ii. inferred regulatory proteins (1 k, 5 k) and iii. input regulatory networks (1 for runs involving VIPER and 5 for runs involving metaVIPER). VIPER and metaVIPER were run using both the aREA (meta-aREA) and NaRnEA (meta-NaRnEA) enrichment methods. Each instance was executed using 4 memory allocations: 16, 32, 48 and 64 GB. b and c Python vs R runtime comparisons: VIPER- and metaVIPER-based Protein Activity inference of 2 k regulators (NaRnEA enrichment) with 32 GB of allocated memory. pyVIPER exhibits a substantial runtime decrease compared to the R-based implementation. pyVIPER’s speedup is even more significant for the most demanding configurations (e.g., metaVIPER), where it provides a runtime decrease from several hours to minutes (e.g., from 6 h to < 10 min with 5 k cells). pyVIPER scales more efficiently with the number of cells, enabling the analysis of 4 × more cells with the same memory allocation. p < d Python vs R average runtime comparison for each enrichment algorithm: Protein Activity inference of 2 k regulators with 32 GB of allocated memory shows runtime reductions up to 15 times. All the metaVIPER runs involved 5 regulatory networks inferred from malignant ductal, normal ductal, fibroblast, endothelial and B cell populations. Time is in seconds (s) in all plots. All tests where run on an Intel® Xeon® E5-2630 2.30 GHz CPU using 1 core Comparison with enrichment analysis tools pyVIPER offers functionalities that extend beyond general-purpose enrichment analysis tools in Python [21, 35] and R [36–38], by implementing a rigorous pipeline for Protein Activity inference, as well as enabling downstream analyses that leverage these activity estimates, such as OncoMatch and other mechanistic analyses. As such, pyVIPER is designed to achieve the distinct goal of providing a comprehensive, unified framework for MR analysis, positioning itself as a specialized resource for studies on gene regulation. Another implementation of the ‘viper’ function is available in Python through the decoupler package [21]. While correct, this implementation lacks relevant features required to perform a comprehensive Protein Activity analysis that encompasses all steps from initial preprocessing to final postprocessing, which are available through our specialized package. These missing features include GRN preprocessing functionalities (e.g., regulon pruning and size-harmonization for aREA-based inference) and gene expression signature generation (Tutorial 1). Additionally, unlike pyVIPER, decoupler does not incorporate the NaRnEA enrichment engine, which has been demonstrated to provide improved specificity compared to aREA for Protein Activity assessment [9]. Moreover, pyVIPER uniquely includes metaVIPER for integrative regulatory analysis, a feature absent in decoupler. This feature is essential for the robust analysis of single cells from undetermined tissue samples and for leveraging networks generated by different algorithms and/or omics technologies. pyVIPER additionally ensures complete consistency with the original VIPER algorithm (Supplementary Information 1) whereas the decoupler-based aREA, which doesn’t describe GRN edges using both mor and likelihood, provides an approximation of VIPER-inferred profiles. Benchmarking across bulk RNA-seq profiles from 24 TCGA cohorts [39], revealed that decoupler exhibited significantly greater deviations compared to pyVIPER considering activities inferred through R-based VIPER (p < 10–13 by two-sample t-test; Supplementary Information 2). Furthermore, computational benchmarking demonstrates that pyVIPER outperforms decoupler in scalability, completing analyses faster while avoiding the fatal out-of-memory errors that decoupler experiences on datasets exceeding 250,000 cells (Suppementary Figure S.2.2). Ultimately, decoupler and pyVIPER pursue fundamentally distinct analytical goals. Decoupler serves as a general-purpose computational suite, providing multiple statistical methods, while pyVIPER is the specialized ecosystem for rigorous MR analysis. These tools should be viewed as complementary resources within the Python single-cell community. Precision oncology applications: the OncoMatch framework A persistent challenge in translational oncology is due to the inability of standard pre-clinical models—including immortalized cell lines, genetically engineered mouse models (GEMMs) and patient-derived xenografts (PDXs)—to robustly represent actual human tumors [2]. pyVIPER incorporates the OncoMatch algorithm to support precision oncology applications. OncoMatch assesses tumor-model fidelity at the functional level of MR proteins, instead of relying on somatic mutation overlaps: as MR proteins act as the bottleneck dictating cellular state, a model sharing the same set of dysregulated MRs as the patient is expected to respond to pharmacological perturbations in a comparable manner, regardless of divergent mutational profiles [2]. pyVIPER introduces the first fully integrated, streamlined, and accessible implementation of this framework in Python, thus transforming a high-level analytical framework into a production-ready tool for translational oncology. Case study: recovery of lineage-specific regulatory programs To evaluate algorithm scalability and biological resolution at atlas scale, we demonstrated pyVIPER’s ability to identify lineage-specific MRs across 500,000 immune cells from a colorectal cancer single-cell atlas [40]. The heatmap in Extended Data Fig. 3 displays the top five differentially active MRs for each immune lineage based on Wilcoxon rank-sum analysis on VIPER-inferred protein activity profiles. pyVIPER successfully identified key regulatory drivers of B cell differentiation into antibody-secreting plasma cells, including PRDM1, XBP1, ELL2. XBP1 is considered a gold-standard regulator of plasma cell biology [41]; PRDM1 represses the B cell transcriptional program and is a central driver of plasma cell fate [42], while ELL2 is an essential elongation factor required for secretory immunoglobulin synthesis (Extended Data Fig. 3) [43]. The heatmap further shows enrichment of SPIB (early B cell differentiation) [44], TCF4 (B cell and plasmacytoid dendritic cell development) [45] and ID3 (lymphocyte differentiation) within the B cell compartment (Extended Data Fig. 3) [46]. The algorithm also resolved the broader myeloid lineage into distinct functional compartments; myeloid cells were characterized by activation of ZEB2 and GAS7 consistent with monocyte/macrophage identity and inflammatory activation programs [47, 48]. Within CD4 + T cells, pyVIPER identified key regulators including SATB1, a chromatin organizer controlling chemokine expression [49]; MAF, which directs helper T cell differentiation [50]; and PIM1, a mediator of CD4 + T cell development [51]. In CD8 + T cells, the analysis highlighted TBX21, encoding the transcription factor T-bet that orchestrates cytotoxicity and Interferon-γ production—together with IFNG itself [52]. The coordinated enrichment of TBX21 and IFNG illustrates pyVIPER’s ability to accurately recover functional regulatory cascades within effector populations. Together, these results demonstrate that pyVIPER maintains both computational scalability and biological specificity at atlas scale, enabling identification of lineage-defining regulatory programs across hundreds of thousands of single-cells while overcoming performance bottlenecks of legacy implementations. Integration with AI/ML libraries The computational efficiency and scalability of pyVIPER enables protein activity inference on single-cell datasets with millions of cells [53]—including on-the-fly during data-loading—with only a few lines of code. These protein activity profiles serve as biologically grounded, low-dimensional features for training AI and models on single-cell data. pyVIPER-derived activity features have been successfully used to train models to support a range of cell-level tasks, including cell type annotation, cell state classification, and prediction of cellular responses to CRISPR-mediated genetic perturbations [34]. Moreover, pyVIPER's utilities for metacell generation, regulator selection, and efficient network loading streamline preprocessing steps required to train cutting-edge single-cell RNA foundation models that integrate gene regulatory network priors. Notably, pyVIPER is being adopted within the GREmLN (Gene Regulatory Embedding-based Large Neural model), a next-generation AI framework that incorporates regulatory network biology into single-cell representation learning [34]. Continuous integration and testing To ensure code reliability and reproducibility, pyVIPER employs an automated continuous integration (CI) workflow implemented through Github Actions. Using Python’s ‘unittest’ framework, this pipeline programmatically executes a comprehensive suite of unit tests covering all major functionalities of pyVIPER, including but not limited to protein activity inference, gene expression preprocessing, interactome manipulation, metacells assembly, pathway enrichment and viper similarity analysis. The tests make logical assertions and ensure consistency with reference outputs computed using VIPER’s original implementation in R. Code coverage is programmatically calculated within the CI workflow using coverage.py. The analytical components of pyVIPER achieve 75% coverage, demonstrating extensive validation of the package’s core computational logic and ensuring robust and reproducible analyses across releases. Conclusions pyVIPER addresses the increasing need for scalable and interpretable network-based analysis of large gene expression datasets, which are becoming more common in single-cell studies, thus enabling mechanistic inference of protein activity and regulatory programs underlying cellular states. pyVIPER is not merely a software port, but a toolkit that address a functional necessity for systems biology and modern precision medicine. pyVIPER-inferred protein activity profiles—i.e., regulon-based estimates of regulatory protein activity from the expression of their transcriptional targets—are virtually identical to those inferred with the original VIPER implementation. Yet, the computational speedup can substantially benefit researchers, particularly those who do not have access to expensive computational resources or want to perform exploratory data analyses. On a personal computer, pyVIPER can perform protein-based NaRnEA analysis of > 50,000 single-cells in ~ 10 min, whereas the R-based implementation is generally limited to ~ 5000 cells because of memory constraints, making pyVIPER more accessible for large single-cell datasets. This orders-of-magnitude improvement simplifies “atlas-scale” regulatory analysis on standard hardware, democratizing access to mechanistic modeling. The availability of new functionalities and tutorials also facilitates the systematic, highly reproducible, network-based analysis of scRNA-seq data. The real-world utility of pyVIPER is best exemplified by its recent applications across diverse biological contexts. [3, 32, 34] By exploiting a modular architecture, pyVIPER is also amenable to future developments to include additional data modalities and algorithms. Moreover, pyVIPER’s interoperability with scanpy and other tools from the scverse ecosystem enables easy cross-compatibility and results transfer within the Python environment, as demonstrated by the recent pyVIPER incorporation into next-generation single-cell foundation models. As core enrichment analysis steps involve large-scale rank transformation and matrix multiplication operations, Graphics Processing Unit (GPU) acceleration has been integrated into pyVIPER via PyTorch, enabling direct execution of key computational steps on GPU hardware [25]. The broader single-cell ecosystem has already seen the emergence of GPU-accelerated frameworks, such as ScaleSC and rapids-singlecell, with speedups of up to several 100-fold compared to optimized CPU baselines [34, 54]. While we have already steered in this direction, we plan to explore deeper GPU integration in future releases, for example by storing large matrices as GPU-resident cunnData objects, and replacing NumPy array operations with CuPy, [55, 56] which would further reduce CPU-GPU transfer overhead and improve performance on sparse matrix operations. Taken together, these essential improvements suggest that the redesign and consolidation of the entire protein activity framework into the unified pyVIPER platform will increase both ease of use and deployment, providing scientists with an embedded toolkit for the network-based, systematic analysis of large-scale scRNA-seq datasets that can be further interfaced with the rapidly expanding set of Python tools for multimodal data analysis, cell–cell communication, single-cell trajectory inference and single-cell foundation models. Availability and requirements Project name: pyVIPER. Project home page: https://github.com/alevax/pyviper Operating system(s): platform independent. Programming language: Python. Other requirements: Scanpy, Pandas, AnnData, Numpy, Scipy, Joblib, Tdqm, Statsmodel, Loompy, Pyarrow. License: The VIPER software is distributed by Columbia University under a non-commercial, academic-only evaluation license, which restricts its use to non-profit or not-for-profit organizations and prohibits any commercial use, redistribution, or sublicensing without a separate commercial agreement with Columbia University’s Science and Technology Ventures office. All terms and conditions are specified in the accompanying https://github.com/alevax/pyviper/blob/main/LICENSE file. Any restrictions to use by non-academics: Yes – academic/non-profit use only. Non-academic or commercial use requires a separate commercial license, as stated in https://github.com/alevax/pyviper/blob/main/LICENSE. Supplementary Information Extended Data Fig. 1 Extended Data Fig. 2 Extended Data Fig. 3 Supplementary Information 1 Supplementary Information 2 Extended Data Fig. 1 Extended Data Fig. 2 Extended Data Fig. 3 Supplementary Information 1 Supplementary Information 2