Performance and comparison tests

Scalability tests for Fig 1 were performed on a tower server with 512 GB of RAM and using a single Intel Xeon Platinum 8160T CPU at 2.10GHz. Comparisons against scikit-network (Supplementary Figures) were performed on a laptop with 32GB RAM and Intel Core Ultra 7 265H cpus. All tests were run 10 times with memory deallocation/garbage collection between runs and libraries. Library versions: igraph 1.0.0, networkx 3.6.1, scikit-network 0.33.0 and graph-tool 2.98 (Supplementary Figures).

Download:

• PNG
  larger image
• TIFF
  original image

Fig 1. Runtime scalability of igraph.

(A-B) Runtimes to construct (A) and analyse (B) graphs of varying sizes. Top row: Construction runtime of an undirected Bethe lattice or regular tree, an Erdős–Rényi or random graph and a directed ring graph using the igraph C core directly and, for the latter, the Python igraph interface and the networkx library. Bottom row: Analysis runtime – excluding graph construction time – for size-3 motif search, transitivity, and Leiden clustering using the C core. Each graph size was tested 10 times (crosses). Solid lines: averages for each graph size. (C) ratios of average runtimes between igraph (python interface) and networkx for four example algorithms across graph sizes (1-30,000 nodes).

https://doi.org/10.1371/journal.pone.0355108.g001

Graph layouts

To demonstrate the graph layout capabilities of igraph, we constructed graphs of increasing size. Each graph is built as a set of 10 groups of vertices that are tightly connected internally and with random distance between groups. The 2D Fruchterman-Reingold algorithm (force variant for graphs with less than 500 nodes, energy variant for larger graphs) and the UMAP algorithm [27] were run on the same graph for sizes up to 1,000 vertices. For the 100,000-node graph, only UMAP was run for performance reasons. Notice that UMAP is not designed to work on very small (e.g., 30-node) graphs. All plots use the new matplotlib backend for igraph.

Package statistics

Download statistics for PyPI were computed using PyPI stats (https://pypistats.org/). Download statistics for R were computed using cranlogs.app (https://github.com/r-hub/cranlogs.app). Counts of edited lines, forks, and stars were computed using GitHub’s online interface. The number of functions in Python were estimated using the inspect standard module. The number of functions in R were estimated using lsf.str(“package:igraph”).

Growing a large userbase across four programming languages

Since the initial publication in 2006 [28], igraph has grown in multiple areas, including the C core, extensions in Python, R, and Mathematica [29]. The codebase has had around 3 million lines of code edited across approximately 10,000 versioning commits. As of June 2026, the four main code repositories, one for each programming language, have been forked approximately 800 times and starred 3,000 times. During that month, the Python and R packages were downloaded around 2.1 million and 600 thousand times respectively, which is a conservative estimate given that tracking downloads is challenging.

Scaling network analysis to billions of edges through a fast C core

igraph is based on a low-level core codebase in C, on top of which higher-level language interfaces (Python, R, Mathematica) are built to leverage high-level languages’ conciseness without loss of speed (see S1 Fig for a cross-language example). The C core includes approximately 1,100 user-facing functions. Since 2006, three thousand files have been edited and 154 individual features added to the C core (S1 Table). The build system has been designed to enable easy cross-platform installation from source in Linux, macOS and Windows. Precompiled packages are also available at the system level (e.g., Ubuntu, Debian, and Alpine Linux, Homebrew and MacPorts for macOS, and vcpkg for Windows) and the language-specific extensions are available on PyPI for Python, the comprehensive R network (CRAN) for R, and as a Paclet for Mathematica.

To reach the largest audience, igraph relies on a compile-time configurable integer size. This enables support of users on 32-bit embedded devices but also 64-bit desktops, laptops, and servers, enabling analysis of networks with billions of vertices and edges. As an example, constructing an undirected Bethe lattice with 3.2 billion edges took 4 minutes on a server using a single CPU core (Fig 1A). Similar results were obtained when constructing a random graph with 400 million edges and a directed ring graph with 3.3 billion edges (Fig 1A). In addition to graph construction routines, several graph analysis routines were also assessed for runtime (Fig 1B) performance and memory usage (S2 Fig). Comparison of direct usage of the C API versus the igraph Python interface showed significant overhead for small graphs, reducing the performance of igraph’s Python code to networkx’s speed, but very little overhead for large graphs, where igraph’s execution is approximately 10 times faster than networkx. igraph’s R interface is more limited in terms of network size due to R’s internal usage of double precision floating point numbers to represent integers. To further assess igraph’s speed against networkx, we computed runtime ratios for four algorithms across a wide range of graph sizes (1–30 thousand nodes) and found that igraph was faster in essentially all cases, usually by approximately one order of magnitude (Fig 1C and S3 Fig). Comparisons with graph-tool and scikit-network were also performed (S4 Fig).

igraph includes hundreds of functions for graph construction, I/O, structural analysis, paths or traversals, community detection, and layouts. Community detection includes, among others, Leiden [26], multilevel (or Louvain) [30] and fluid communities [31]. Graph layout algorithms include Fruchterman-Reingold, multidimensional scaling [32], the Large Graph Layout [33], Davidson-Harel [34], the GEM layout [35], Kamada-Kawai, and an implementation of Uniform Manifold Approximation and Projection (UMAP) [27] that does not depend on cross-language packages such as numba and llvmlite.

Broad accessibility to R, Python, and Mathematica users

The Python interface, which includes around 600 functions, is compatible with Jupyter notebooks, a browser-based environment for scientific computing and rapid prototyping that supports both R and Python and is widely used in education, research, and industry [36]. The Python visualisation layer has also been redesigned to support not only the existing Cairo backend but also matplotlib [37] and plotly [38], which enable interactive plots (e.g., zoom and pan) and animations (Fig 2). Furthermore, igraph’s Python interface supports in-memory import/export of graphs to and from networkx [10] and graph-tool [11], two popular network analysis libraries (Fig 3A). Conversions preserve graph, vertex, and edge attributes, making it easy to convert an igraph graph into a networkx object, call a specific function on it, then convert back to igraph for further analysis (Fig 3B). Moreover, conversions are fast (S5 Fig): generating a graph in igraph and then converting it to a library of choice can sometimes be faster than using native constructor routines. Compatibility with pandas dataframes has been added as well [39]. Finally, we aimed to facilitate the use of igraph as a data preparation step for graph-based machine learning by adding a function that exports networks from igraph to pytorch geometric [40] (Fig 3A).

Download:

• PNG
  larger image
• TIFF
  original image

Fig 2. igraph enables simple and interactive graph visualisation.

(A) Example code to plot a simple graph with topological sorting. (B) Examples of graph layouts in igraph. The spring-based Fruchterman-Reingold layout and the Uniform Manifold Approximation and Projection (UMAP) layout algorithms [27] for graphs of increasing size. Plots within brackets are outside of the typical range of applicability of the respective algorithm.

https://doi.org/10.1371/journal.pone.0355108.g002

Download:

• PNG
  larger image
• TIFF
  original image

Fig 3. Linking network libraries together.

(A) igraph’s Python interface can exchange in-memory graphs with networkx, [10] graph-tool [11], and pytorch geometric [40]. (B) Example of a network conversion from igraph to networkx and back using the new import/export functions, which preserve attributes as well.

https://doi.org/10.1371/journal.pone.0355108.g003

The R interface of igraph supports R 4.0 and later and comprises approximately 750 user functions. As of June 2026, on CRAN, the main code repository for the R language, igraph is imported by 713 packages: igraph has even been used to compute CRAN’s own dependency graph [41]. Most R functions are wrappers around fast C functions, however the user interface and the structure of the package are idiomatic to R to lower the entry barrier for contributors.

A Mathematica interface is available at http://szhorvat.net/mathematica/IGraphM. Unlike the C, R, and Python interfaces, it is mainly designed to extend the network analysis capabilities of the Mathematica standard library rather than to replace them. For instance, the Mathematica interface exposes useful community detection, layout, motif finding, and random graph generation algorithms that are otherwise not available. It also implements a dedicated interactive editor to construct graphs visually, which is especially appealing for prototyping or brainstorming. Details of the Mathematica interface were described in a recent publication [29].

Documentation and testing

igraph has an extensive and robust testing framework. Continuous integration across multiple architectures (64-bit Linux for Intel and AMD CPUs, macOS for 64-bit Intel and the Apple Silicon M-series CPUs, and Windows), including usage of address sanitizers, ensures that the codebase is not just well tested but that new contributions are thoroughly vetted as well. Test coverage for the C core is 85% excluding vendored dependencies which are already tested separately. In the Python interface, visualization functions are tested by pixel-by-pixel matching of the resulting images, as in matplotlib [37].

igraph’s documentation includes an R package vignette and documentation website using pkgdown [42] designed to help new users. The Python interface is provided through readthedocs.org and includes a gallery of examples available as scripts or Jupyter notebooks [43]. Translations for both the R and Python interface tutorials into Spanish are available, and other translations (e.g., Mandarin) are planned.

Open science development towards a diverse community

We continue aiming to grow the contributor and user bases (Fig 4) via transparent development practices. Repository issues are the agora where aspiring contributors interact with the core development team on specific bugs, feature requests, or enhancement proposals. Automatic testing of new contributions via continuous integration is configured openly, with results accessible by anyone. Releases are triggered for the popular dissemination platforms for each language (e.g., PyPI for Python, CRAN for R) and relationships with downstream package managers are actively maintained. The igraph documentation is deployed using language-specific conventions, which feels familiar even to new users. In addition to internal communication on development via chat rooms and regular video calls, igraph has a public user forum at https://igraph.discourse.group/ that is regularly visited by both developers and users. The developers also check in on online Q&A platforms such as Stack Overflow to provide answers.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 4. Schematic of igraph’s open source/open science infrastructure.

From the top: development, releases, documentation, internal and external communication channels, and initiatives.

https://doi.org/10.1371/journal.pone.0355108.g004

The recent collaboration with Women in Network Science (WiNS) aims to extend our user and contributor base to a more diverse group of individuals, especially from women, non-binary people, and people from other groups that are traditionally underrepresented in open source. A team led by Foucault Welles ran a workshop with Women in Network Science that trained 25 women to use igraph for network analysis and visualization. Most participants had been unaware of igraph before the workshop, but successfully used igraph for network analysis and network visualization projects during the workshop. All expressed interest in continuing to use igraph in their scientific work, suggesting that targeted workshops are an effective strategy for onboarding new diverse users. In addition, the team conducted interviews with 19 open-source community managers lasting 60–90 minutes each on strategies for increasing diversity, inclusion, and belonging in open-source communities [44]. Briefly, these interviews suggested that the work of recruiting and onboarding new users and developers was universally recognized as important but often sidelined in favor of more technical tasks. Projects that successfully maintain diverse user and contributor bases had transparent governance structures with leaders specifically assigned to community maintenance tasks such as onboarding new users and giving constructive feedback to new contributors [44]. Based on these results, igraph has recently transitioned to a transparent governance structure with a Steering Committee that includes members responsible for strengthening the relationship between core developers and the broader user and developer community.