NVIDIA cuDF: GPU-Accelerated DataFrames

Integrate cuDF directly into your environment to accelerate pandas. Follow these steps to get started.

Install cuDF for pandas

wget
"https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh

conda create -n rapids-25.06 -c rapidsai -c conda-forge -c nvidia  \
    cudf=25.06 python=3.13 'cuda-version>=12.0,<=12.8'

Install via the NVIDIA PyPI index:

pip install \
    --extra-index-url=https://pypi.nvidia.com \
    "cudf-cu12==25.6.*"

See the complete install selector for docker, WSL2, and individual libraries.

Install Selector

Enable cuDF Acceleration of pandas With Zero Code Changes

cuDF implements zero-code-change acceleration through the cuDF.pandas module. This module is part of the cuDF package. Load it to seamlessly accelerate your existing pandas code. Enable it using one of these methods before importing or using pandas. For a step-by-step visual guide, watch this video.

To accelerate IPython or Jupyter notebooks, use the magic command:

%load_ext cudf.pandas
import pandas as pd
...

To accelerate a Python script, use the Python module flag on the command line:

python -m cudf.pandas script.py
import pandas as pd
...

If you can't use command-line flags, explicitly enable cudf.pandas via import:

import cudf.pandas
cudf.pandas.install()

import pandas as pd
...

From Minutes to Seconds: cuDF Accelerates pandas

Standard DuckDB data benchmark (5 GB) performance comparison between cudf.pandas and traditional pandas v2.2 (lower is better).

Specs: HW: NVIDIA L4, CPU: Intel Xeon 8480CL | SW: pandas v2.2.1, NVIDIA RAPIDS™ cuDF 24.02

Run the benchmark here.

Hands-On Tutorials: Accelerate pandas on Colab

cuDF comes preinstalled in Google Colab, making it incredibly easy to get started. Simply switch to a GPU runtime and enable cudf.pandas at the top of your notebook to instantly accelerate your pandas workflows. Explore these starter kits for hands-on examples:

Integrate the Polars GPU engine directly into your environment to accelerate Polars. Follow these steps to get started.

Install Polars With GPU Support

pip install polars[gpu]

Configure Polars to Use the GPU Engine

Activate GPU acceleration for your Polars operations by configuring the engine. You can use the default GPU engine or customize it for finer control.

Default GPU Engine

Materialize the Polars LazyFrame into a DataFrame with the default GPU engine configuration by calling .collect(engine="gpu"):

import polars as pl

ldf = pl.LazyFrame({"a": [1.242, 1.535]})

print(
    ldf.select(
        pl.col("a").round(1)
    ).collect(engine="gpu")
)

Custom GPU Engine

For finer control on the engine, you can pass a GPUEngine object with additional configurations like device details and verbosity to the engine=parameter:

import polars as pl

ldf = pl.LazyFrame({"a": [1.242, 1.535]})

gpu_engine = pl.GPUEngine(
    device=0,  # This is the default
    raise_on_fail=True,  # Fail loudly if can't execute on the GPU
)

print(
    ldf.select(
        pl.col("a").round(1)
    ).collect(engine=gpu_engine)
)

Accelerate Polars Workflows Up to 13x

Top performing compute heavy queries with complex groupby and join operations
(PDS-H benchmark | 80 GB dataset)

Query Number

Performance Improves as Data Size Grows

Query processing time across a range of dataset sizes

Specs: PDS-H benchmark | GPU: NVIDIA H100 | CPU: Intel Xeon W9-3495X (Sapphire Rapids) | Storage: Local NVME
Note: Note: PDS-H is derived from TPC-H but these results are not comparable to TPC-H results.

Run the benchmark here.

Hands-On Tutorials: Accelerate Polars on Colab

The Polars GPU engine is preinstalled in Google Colab, making it incredibly easy to get started. Simply switch to a GPU runtime and enable the GPU engine to instantly accelerate your Polars workflows. Explore these hands-on resources:

How cuDF Accelerates Polars

Polars is already a highly performant DataFrame library, designed with multi-threaded execution, advanced memory optimizations, and lazy evaluation. These features allow Polars to efficiently handle medium- to large-scale data out of the box

The Polars GPU engine takes these strengths further. By adding the speed of cuDF to the efficiency of Polars, you can achieve even faster execution, enabling the processing of hundreds of millions of rows in seconds.

Built directly into the Polars Lazy API, the GPU engine works by attempting to execute operations on the GPU first and falling back to the CPU if necessary. This approach ensures you can continue to use familiar Polars syntax and functions while benefiting from enhanced GPU acceleration.

For a deep dive into the architecture and underlying mechanisms of the Polars GPU Engine, check out the official Polars blog post.