Skip to content
NVIDIA cuDF Accelerated Computing

NVIDIA cuDF Accelerated Computing Skill

NVIDIA's own guidance for moving pandas workloads onto GPU DataFrames with cuDF and dask-cuDF — when it pays off, and how to keep results identical.

GitHub Docs

Install

Install with the skills CLI

One command for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf and dozens of other agents. Needs Node.js; the skill is fetched straight from NVIDIA/skills.

$ npx skills add NVIDIA/skills --skill accelerated-computing-cudf

Run it in a terminal. The CLI finds the agents installed on your machine, asks which ones to add the skill to, and whether to install it into the folder you ran it from or for all your projects.

Other ways to install

Copy the whole skill folder — SKILL.md and any scripts or references beside it — into ~/.claude/skills/accelerated-computing-cudf/, where Claude Code picks it up in every project. Only git is needed.

tmp=$(mktemp -d) && \
  git clone --depth 1 --branch main https://github.com/NVIDIA/skills.git "$tmp" && \
  mkdir -p ~/.claude/skills && \
  cp -R "$tmp"/skills/accelerated-computing-cudf ~/.claude/skills/accelerated-computing-cudf

No scripts or references next to it? Saving the SKILL.md alone as ~/.claude/skills/accelerated-computing-cudf/SKILL.md works too.

Using another agent? Its personal skills folder
Codex
~/.agents/skills/
Cursor
~/.cursor/skills/
GitHub Copilot
~/.copilot/skills/
Gemini CLI
~/.gemini/skills/
Windsurf
~/.codeium/windsurf/skills/
OpenCode
~/.config/opencode/skills/

About

  • Chooses between cudf.pandas, explicit cuDF and dask-cuDF from the user's intent
  • Enforces a 100K-row size gate so small data is not moved to GPU pointlessly
  • Keeps intermediate data on GPU and converts only at output boundaries
  • Validates null handling, ordering and numeric parity against a pandas reference
  • Covers CSV/Parquet I/O, joins, groupby and multi-GPU workloads
  • Tracks cuDF release 26.04 with explicit CUDA and driver requirements

An official, NVIDIA-authored agent skill that turns a coding agent into a competent cuDF implementer. Most "port this to GPU" attempts fail in one of two ways: the dataset is too small for the transfer cost to ever pay back, or the port silently changes null handling, row ordering or numeric precision and nobody notices until a downstream report is wrong. This skill encodes the guardrails for both.

What it teaches the agent
  • Which of three paths to take. cudf.pandas for near-zero-change acceleration of an existing pandas codebase, explicit cuDF for deliberate migrations and hot ETL paths where parity matters, and dask-cuDF once the working set exceeds GPU memory (with enable_cudf_spill=True).
  • A size gate. Below roughly 100,000 rows the host-to-device transfer usually costs more than the speedup buys; the skill tells the agent to stop rather than produce a slower program.
  • Where conversions belong. Keep intermediate ETL data on the GPU and convert at boundaries only — display, plotting, CPU-only libraries and final output — via .to_pandas(), .values or .numpy().
  • Parity discipline. For null semantics, joins, time series, reshapes and grouped logic, keep a small pandas reference path and compare shape, labels, null counts, ordering and representative values before claiming equivalence.
  • Cheap wins, such as casting to float32 early where precision allows, since float64 operations are slower on GPU.

Bundled reference files cover dask-cuDF patterns, multi-GPU workloads, and CSV/Parquet I/O in more depth than the main file.

Compatibility

Tracks cuDF release 26.04. Requires NVIDIA Volta or newer on CUDA 12, or Turing or newer on CUDA 13; CUDA 12.2–12.9 needs driver 535+, CUDA 13.0–13.1 needs driver 580+. Python 3.11–3.14.

Installing it

Part of the NVIDIA agent-skills catalogue, which is mirrored daily from NVIDIA's product repositories and carries OMS signatures verifiable against nv-agent-root-cert.pem. Install the whole set with npx skills add nvidia/skills, or copy this one folder into your agent's skills directory. Works with Claude Code, Codex, Cursor and any runtime that follows the Agent Skills standard. Source is Apache-2.0, skill text is CC-BY-4.0.

Try it

Once installed, ask your agent something like:

"This nightly ETL job reads a 40M-row Parquet file and does three groupby aggregations in pandas. Can cuDF help, and what would change about the output?"

SKILL.md

The instructions your agent loads, as published by NVIDIA.

SKILL.md
name
accelerated-computing-cudf
description
Official NVIDIA-authored guidance for NVIDIA cuDF GPU DataFrames, pandas acceleration, dask-cuDF, ETL, joins, groupby, CSV/Parquet I/O, nullable semantics, and multi-GPU DataFrame workloads.
license
CC-BY-4.0 AND Apache-2.0
metadata
author: NVIDIA tags: - cudf - dataframes - pandas - dask-cudf - etl

cuDF & dask-cuDF Implementer's Guide

Compatibility
  • Release tracked by this skill: 26.04.
  • Requires NVIDIA Volta or newer on CUDA 12, or Turing or newer on CUDA 13. Release 26.04 supports CUDA 12.2-12.9 with driver 535+ or CUDA 13.0-13.1 with driver 580+, and Python 3.11-3.14. cuDF sweet spot: >100K rows.
Naming

Use NVIDIA library-first wording in user-facing answers. Keep literal RAPIDS/rapidsai URLs, package names, and release metadata when citing sources.

Role

You are a cuDF expert helping an implementer work with GPU DataFrames. The user understands pandas and their data — your job is to get them to correct, fast GPU code with minimal friction. Choose the path from the user's intent: cudf.pandas for broad compatibility or minimal-change acceleration, explicit cuDF for named DataFrame migrations, hot ETL paths, and parity-sensitive work. Treat source schema, row counts, null placement, ordering, and numeric tolerances as user-visible behavior.

Critical Rules
  1. Choose the right cuDF path. Use cudf.pandas for broad compatibility or minimal-change acceleration. Use explicit cuDF when the user asks to migrate DataFrame code, inspect parity, optimize a visible ETL hot path, or control unsupported operations.
  2. Size gate: 100K rows minimum. Below that, GPU transfer overhead usually beats the speedup; use small data for correctness and benchmark larger working sets for performance.
  3. Keep conversions at boundaries. Use .to_pandas(), .values, or .numpy() for display, plotting, CPU-only libraries, or final output boundaries. Keep intermediate ETL data on GPU.
  4. Float32 is your friend. cuDF operations on float64 are slower; cast early when precision allows.
  5. Validate semantics on representative slices. For null handling, joins, time series, reshape, or grouped logic, keep a small pandas reference path and compare shape, labels, null counts, ordering, and representative values before claiming parity.
  6. For data > GPU memory, move to dask-cuDF with enable_cudf_spill=True. See references/dask-cudf-patterns.md.
Three Paths to GPU DataFrames
Path 1: cudf.pandas Accelerator (Compatibility / Minimal Change)

Use when the user needs a small code change, third-party pandas compatibility,
or one code path that can keep running while unsupported operations fall back.

Jupyter/IPython:

%load_ext cudf.pandas
import pandas as pd   # now GPU-backed; falls back silently for unsupported ops

Script:

python -m cudf.pandas my_script.py

With multiprocessing:

import cudf.pandas
cudf.pandas.install()   # must come BEFORE pandas import, before Pool creation
from multiprocessing import Pool

Confirm acceleration with the cudf.pandas profiler before claiming speedup.
For notebook, CLI, and stats examples, read
references/cudf-pandas-accelerator.md. If the profile shows the hot path
running on CPU, use Path 2 for explicit cuDF control.

Path 2: Explicit cuDF API

For full control, hot-path optimization, named DataFrame migrations, and
parity-sensitive operations:

import cudf

# Read data directly to GPU
df = cudf.read_parquet("data.parquet")

# Operations mirror pandas
result = df.groupby("key")["value"].sum()
merged = df.merge(lookup, on="id", how="left")
filtered = df[df["amount"] > 1000]

# String operations
df["clean"] = df["name"].str.strip().str.lower()

# To check API coverage before committing to migration:
# See references/api-patterns.md for known gaps and workarounds

Keep data on GPU end-to-end. Only call .to_pandas() at the very end for display or CPU or non-GPU handoff.

Prefer explicit cuDF for tasks involving read_csv/read_parquet, joins,
groupby, reshape, nullable types, fillna/where, time buckets, rolling
windows, or CPU/GPU parity checks. Add a small CPU/GPU validation path when
semantics matter instead of relying on successful execution alone.

For pandas code with null handling, reshape, or time-series behavior, read
references/api-patterns.md for the relevant semantic checklist before
rewriting. A cudf.pandas bootstrap is enough for a minimal-change request; an
implementation request should make the hot path explicit and observable.

For reshape-heavy pandas code (pivot_table, melt, stack/unstack,
crosstab), keep the source schema as part of the contract: index labels,
column labels or levels, fill_value, aggfunc, margins, and normalization.
Use explicit cuDF where the equivalent is supported; use cudf.pandas or a
narrow compatibility boundary when exact pandas reshape semantics matter more
than rewriting every operation. Add a small pandas-reference parity check for
shape, labels, and representative values before finalizing. See
references/api-patterns.md.

Path 3: dask-cuDF (Multi-GPU / Large Data)

When dataset exceeds GPU memory. See references/dask-cudf-patterns.md for full patterns.

from dask_cuda import LocalCUDACluster
from dask.distributed import Client
import dask_cudf

cluster = LocalCUDACluster(enable_cudf_spill=True)  # one worker per GPU
client = Client(cluster)

ddf = dask_cudf.read_parquet("s3://bucket/data/*.parquet")
result = ddf.groupby("key").agg({"value": "sum"}).compute()
Memory Management

Enable spill before OOM happens (not after):

import cudf
cudf.set_option("spill", True)   # spill to host RAM when GPU is full

RMM pool allocator (reduces cudaMalloc overhead in pipelines with many allocations):

import rmm
rmm.set_current_device_resource(rmm.mr.CudaAsyncMemoryResource())
# Must be called BEFORE any cuDF operations
GPU Free vs DatasetStrategy
Free > 2× datasetSingle GPU cuDF
Free 1–2× datasetcuDF + cudf.set_option("spill", True)
Dataset > GPU memdask-cuDF
Dataset > node memdask-cuDF + multi-node (see accelerated-computing-mpf)
Troubleshooting

No speedup vs pandas:

  • Data < 100K rows? GPU overhead dominates, so treat the run as correctness validation and measure speedup on a larger working set.
  • Run %%cudf.pandas.profile — high CPU % means many fallbacks. Identify and fix those ops.
  • Check references/api-patterns.md for known gaps.

OOM (CUDA out of memory):

  1. Enable spill: cudf.set_option("spill", True)
  2. If allocator fragmentation or repeated allocation overhead is visible, use the accelerated-computing-rmm memory-resource setup guidance before GPU allocations
  3. Still failing: move to dask-cuDF

AttributeError / NotImplementedError:

  • Check references/api-patterns.md for the specific operation
  • Keep that one operation on CPU at a narrow boundary and continue the supported pipeline on GPU
  • Use .to_pandas() only for the unsupported op, then .from_pandas() back

Wrong results vs pandas:

  • Null/NaN handling differs: cuDF uses <NA> (nullable) by default, pandas uses NaN. See references/api-patterns.md.
  • Sort stability: cuDF sort is not guaranteed stable unless stable=True is passed
  • If the difference is due to floating point differences, try casting to higher precision floats (e.g. float64 instead of float32). If the results are still different, stop. GPU and CPU algorithms will always produce different results on floating point numbers due to the non-associativity of floating point arithmetic and that cannot be fixed.
Nullable and Fill Semantics

When the user explicitly cares about pandas nullable dtypes, fillna,
where/mask, or grouped null behavior, treat parity checks as part of the
implementation. See references/api-patterns.md for nullable dtype examples.

  • Preserve nullable integer/string columns instead of filling them with sentinel

values unless the source code already did that.

  • Keep where/mask semantics when they encode a condition. Use broad

fillna only when the condition is exactly null-only.

  • Compare with to_pandas(nullable=True) when the pandas reference uses

nullable extension dtypes.

  • Put the parity check in a reusable helper next to the GPU path, so future

changes exercise the same nullable conversion and aggregation checks.

  • Validate row counts, null counts, mask truth tables, grouped aggregates, and

representative dtypes before claiming semantic parity.

Reference Files
  • references/cudf-pandas-accelerator.md — Profiling, fallback detection, cudf.pandas deep dive
  • references/api-patterns.md — Known API gaps, workarounds, semantic differences
  • references/dask-cudf-patterns.md — Multi-GPU patterns, best practices, partition tuning
External Documentation

Use WebFetch to retrieve detailed API signatures, parameter descriptions, and examples on demand.

  • cuDF Documentation: https://docs.rapids.ai/api/cudf/stable/
  • dask-cuDF API Reference: https://docs.rapids.ai/api/dask-cudf/stable/api/
  • GitHub: https://github.com/rapidsai/cudf
  • CHANGELOG: https://github.com/rapidsai/cudf/blob/main/CHANGELOG.md
Install

Diagnoses wrong gradients in differentiable NVIDIA Warp programs by measuring first — comparing autodiff against finite differences on a shrunk reproduction before proposing any fix.

Trains, distils, quantises, evaluates, exports and runs inference for RT-DETR real-time object detection in NVIDIA TAO, routing training through AutoML hyperparameter search by default.

Runs NVIDIA's NV-Reason-CXR-3B chest X-ray reasoning model through a documented wrapper, locally on GPU or via the public Hugging Face Space, and returns the model's full reasoning trace as engineering evidence.

Browse all skills →