Rustworkx: A High-Performance Graph Library for Python

0.17.1 · active · verified Thu Apr 09

Rustworkx is a general-purpose, high-performance graph library for Python, implemented in Rust. It provides efficient data structures and algorithms for working with graphs and complex networks, offering a fast alternative to other Python graph libraries, especially for performance-critical applications. The current version is 0.17.1, with a consistent release cadence that includes multiple minor/patch releases per year.

Warnings

breaking The library was renamed from `retworkx` to `rustworkx`. While `retworkx` may still work for older versions, the legacy name will no longer be supported starting from the `1.0.0` release.
Fix: Update all import statements from `import retworkx` to `import rustworkx` and update package names in `requirements.txt` or `pyproject.toml`.
breaking The minimum supported Rust version required for building `rustworkx` from source has been raised to `1.79` for versions `0.17.1` and later. Users installing pre-compiled binaries are not affected.
Fix: If building from source, ensure your Rust toolchain is updated to version `1.79` or newer using `rustup update`.
gotcha Unlike NetworkX, `rustworkx` uses stable integer indices for all nodes and edges. While arbitrary Python objects can be stored as node/edge payloads, all graph operations (adding/removing/accessing) must use these integer indices, not the payload objects directly.
Fix: Adapt code to work with node/edge indices returned by `add_node()`/`add_edge()` methods. Access node data using the graph's mapping protocol (e.g., `graph[node_index]`). Use callback functions for algorithms that operate on node/edge data (e.g., `weight_fn`).
gotcha Many `rustworkx` algorithm functions are explicitly typed (e.g., `rustworkx.graph_something` for `PyGraph` and `rustworkx.digraph_something` for `PyDiGraph`). Passing the wrong graph type will result in an error.
Fix: Always use the correct explicitly typed function for `PyGraph` (undirected) or `PyDiGraph` (directed) instances. Check the API documentation for the correct function signature.
gotcha When developing `rustworkx` from source, `pip install -e` (editable install) does not fully work as expected. Local changes to Rust code will not be reflected live in the Python environment without a full reinstallation.
Fix: After making changes to the Rust codebase, rerun `pip install .` in the repository root to recompile and update the installed library. Avoid `pip install -e` for Rust code changes.

Install

pip install rustworkx Install stable version
pip install 'rustworkx[all]' Install with all optional dependencies (e.g., for visualization)

Imports

rustworkx
```
import rustworkx
```
The entire library's functionality is accessible via the top-level `rustworkx` module.
rx
```
import rustworkx as rx
```
Aliasing `rustworkx` to `rx` is a widely adopted convention for brevity.

Quickstart

This quickstart demonstrates creating a `PyGraph` (undirected graph), adding nodes and edges with associated data, and calculating the shortest path between two nodes using Dijkstra's algorithm. Node and edge data can be any Python object, and nodes are referenced by stable integer indices.

import rustworkx as rx

# Create an undirected graph
graph = rx.PyGraph()

# Add nodes with data payloads (e.g., strings)
a = graph.add_node("A")
b = graph.add_node("B")
c = graph.add_node("C")

# Add edges with weights
graph.add_edges_from([(a, b, 1.5), (a, c, 5.0), (b, c, 2.5)])

# Find the shortest path using Dijkstra's algorithm
# Nodes are referenced by their integer indices
path = rx.dijkstra_shortest_paths(graph, a, c, weight_fn=float)
print(f"Shortest path from A to C: {path}")

# Access node data using its index
print(f"Node at index {a}: {graph[a]}")

view raw JSON →