Based on NVIDIA cuGraph | Not affiliated with NVIDIA Corporation
doubleGraph is doubleAI's hyperoptimised version of cuGraph, built by WarpSpeed, for three of the most common GPUs among cloud instances: A100, L4, and A10G. doubleGraph attains substantial speedups across-the-board, on every algorithm in cuGraph, with over 18% of algorithms accelerated by factors of 10-100x. See our blog post for details on WarpSpeed.
Legal Notice
This project is a derivative work based on NVIDIA cuGraph.
- Original work: Copyright (c) 2018-2026, NVIDIA CORPORATION
- Modifications: Copyright (c) 2026, AA-I Technologies Ltd
- License: Apache License 2.0
- Original repository: https://github.com/rapidsai/cugraph
NVIDIA, cuGraph, and RAPIDS are trademarks of NVIDIA Corporation. This project is not affiliated with, endorsed by, or sponsored by NVIDIA Corporation.
For complete attribution, see the NOTICE file.
@misc{doubleai2026warpspeed,
title = {doubleAI's WarpSpeed: Surpassing Expert-Written Kernels At Scale},
author = {{doubleAI Team}},
year = {2026},
note = {WarpSpeed is doubleAI's AI system for GPU performance engineering, demonstrated by independently generating and verifying a hyper-optimized drop-in version of NVIDIA cuGraph that delivers broad speedups across graph algorithms and GPU architectures},
url = http://doubleai.com/research/doubleais-warpspeed-surpassing-expert-written-kernels-at-scale
}doubleAI's optimised kernels can be found under cpp/src/aai/impl/, with per-GPU variants in a100/, a10g/, and l4/.
Prebuilt wheels are available for the following GPU architectures:
- A100: v0.1.0 (A100)
- L4: v0.1.0 (L4)
- A10G: v0.1.0 (A10G)
Install doubleGraph as a drop-in replacement for cuGraph:
# 1. Download the three doubleGraph wheels for your GPU from GitHub Releases
# A100: https://github.com/double-ai/doubleGraph/releases/tag/v0.1.0-a100
# L4: https://github.com/double-ai/doubleGraph/releases/tag/v0.1.0-l4
# A10G: https://github.com/double-ai/doubleGraph/releases/tag/v0.1.0-a10g
# 2. Install the wheels in dependency order
pip install --force-reinstall --no-deps libcugraph_cu13-*.whl
pip install --force-reinstall --no-deps pylibcugraph_cu13-*.whl
pip install --force-reinstall --no-deps cugraph_cu13-*.whl
# 3. Install remaining dependencies
pip install cudf-cu13 numpy --extra-index-url https://pypi.nvidia.comThe original cuGraph README follows below.
RAPIDS cuGraph is a repo that represents a collection of packages focused on GPU-accelerated graph analytics. cuGraph supports the creation and manipulation of graphs followed by the execution of scalable fast graph algorithms.
- Installation
- General
- Packages
- API Docs
- Python
- C
- C++
- References
RAPIDS cuGraph is a collection of GPU-accelerated graph algorithms. At the Python layer, cuGraph operates on GPU DataFrames, thereby allowing for seamless passing of data between ETL tasks in cuDF and machine learning tasks in cuML. Data scientists familiar with Python will quickly pick up how cuGraph integrates with the Pandas-like API of cuDF. Likewise, users familiar with NetworkX will quickly recognize the NetworkX-like API provided in cuGraph, with the goal to allow existing code to be ported with minimal effort into RAPIDS. To simplify integration, cuGraph also supports data found in Pandas DataFrame, NetworkX Graph Objects and several other formats.
While the high-level cugraph python API provides an easy-to-use and familiar interface for data scientists that's consistent with other RAPIDS libraries in their workflow, some use cases require access to lower-level graph theory concepts. For these users, we provide an additional Python API called pylibcugraph, intended for applications that require a tighter integration with cuGraph at the Python layer with fewer dependencies. Users familiar with C/C++/CUDA and graph structures can access libcugraph and libcugraph_c for low level integration outside of python.
NOTE: For the latest stable README.md ensure you are on the latest branch.
As an example, the following Python snippet loads graph data and computes PageRank:
import cudf
import cugraph
# read data into a cuDF DataFrame using read_csv
gdf = cudf.read_csv("graph_data.csv", names=["src", "dst"], dtype=["int32", "int32"])
# We now have data as edge pairs
# create a Graph using the source (src) and destination (dst) vertex pairs
G = cugraph.Graph()
G.from_cudf_edgelist(gdf, source='src', destination='dst')
# Let's now get the PageRank score of each vertex by calling cugraph.pagerank
df_page = cugraph.pagerank(G)
# Let's look at the top 10 PageRank Score
df_page.sort_values('pagerank', ascending=False).head(10)(alphabetical order)
- ArangoDB - a free and open-source native multi-model database system - https://www.arangodb.com/
- CuPy - "NumPy/SciPy-compatible Array Library for GPU-accelerated Computing with Python" - https://cupy.dev/
- Memgraph - In-memory Graph database - https://memgraph.com/
- NetworkX (via nx-cugraph backend) - an extremely popular, free and open-source package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks - https://networkx.org/
- PyGraphistry - free and open-source GPU graph ETL, AI, and visualization, including native RAPIDS & cuGraph support - http://github.com/graphistry/pygraphistry
- ScanPy - a scalable toolkit for analyzing single-cell gene expression data - https://scanpy.readthedocs.io/en/stable/
(please post an issue if you have a project to add to this list)
The RAPIDS suite of open source software libraries aims to enable execution of end-to-end data science and analytics pipelines entirely on GPUs. It relies on NVIDIA® CUDA® primitives for low-level compute optimization but exposing that GPU parallelism and high-bandwidth memory speed through user-friendly Python interfaces.
For more project details, see rapids.ai.
The GPU version of Apache Arrow is a common API that enables efficient interchange of tabular data between processes running on the GPU. End-to-end computation on the GPU avoids unnecessary copying and converting of data off the GPU, reducing compute time and cost for high-performance analytics common in artificial intelligence workloads. As the name implies, cuDF uses the Apache Arrow columnar data format on the GPU. Currently, a subset of the features in Apache Arrow are supported.