What does this skill do, and when should you use it?
This NVIDIA-authored guide helps implementers work with cuDF and dask-cuDF GPU DataFrames. It covers the cudf.pandas accelerator, explicit cuDF APIs, and dask-cuDF for datasets larger than one GPU's memory. Its scope includes ETL, joins, groupby, CSV/Parquet I/O, nullable semantics, spilling, and pandas parity checks. The tracked cuDF release is 26.04, with stated CUDA, driver, and Python compatibility requirements.
It instructs users to read CSV or Parquet data, filter, join, group, reshape, process strings, and handle time-series workloads through cudf.pandas or explicit cuDF, then move to dask-cuDF for multi-GPU datasets. It provides examples for enabling spill, configuring RMM, profiling cudf.pandas fallbacks, and maintaining a pandas reference path. It recommends comparing shape, labels, null counts, ordering, representative values, and dtypes before claiming semantic parity.
- A pandas user wants GPU acceleration with minimal code changes and third-party pandas compatibility.
- An implementer is migrating named DataFrame code or optimizing a visible ETL hot path with explicit control.
- A workload exceeds single-GPU memory and needs dask-cuDF with spill enabled.
- A pipeline contains joins, groupby, reshaping, nullable columns, or time-series logic that requires pandas comparison.
- A GPU pipeline encounters out-of-memory errors, allocator fragmentation, or repeated allocation overhead.
How do you install this skill?
- Performance, correctness, and security metrics in the benchmark are claims contained in the supplied materials; this review did not execute cuDF, CUDA, dask-cuDF, or any evaluation.
- Before use, verify GPU architecture, CUDA/driver, Python, cuDF versions, and availability of the referenced files, then compare pandas and cuDF results on representative data.
- The skill does not specify sensitive-data handling, external WebFetch behavior, offline/network failure handling, or rollback; external documentation may be unreachable in mainland-China or restricted-network environments.
- cudf.pandas may silently fall back to CPU for unsupported operations, so successful execution alone must not be treated as evidence of GPU acceleration.
- Shell / CLI
- Network access
- Local filesystem
NVIDIA Volta or newer with CUDA 12, or Turing or newer with CUDA 13CUDA 12.2-12.9 with driver 535+ or CUDA 13.0-13.1 with driver 580+Python 3.11-3.14cuDFdask-cuDFDask-CUDARMM
Install the individual skill with the skills CLI:
npx skills add nvidia/skills --skill accelerated-computing-cudf --yes
The README does not provide commands for installing cuDF, CUDA, drivers, or Python; those runtime dependencies must be prepared through their respective documentation.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/NVIDIA/skills.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/skills/accelerated-computing-cudf" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Once installed, send your agent any of these to trigger it:
- Migrate this pandas ETL code to explicit cuDF and compare pandas and GPU results for nulls, ordering, and representative values.
After installing the skill, ask an Agent for a concrete task, for example: “Migrate this pandas ETL code to explicit cuDF and compare pandas and GPU results for nulls, ordering, and representative values.” Request cudf.pandas for minimal-change acceleration, explicit cuDF for controlled migrations, or dask-cuDF for data larger than GPU memory. The guide tracks cuDF release 26.04.
What are this skill's strengths and limitations?
- Covers minimal-change acceleration, explicit API migration, and multi-GPU processing.
- Gives concrete guidance on the 100K-row size gate, conversion boundaries, and semantic validation.
- Addresses null handling, sort stability, floating-point differences, fallbacks, and OOM troubleshooting.
- Includes copyable examples for cudf.pandas, dask-cuDF, spilling, and RMM.
- Below 100K rows, GPU transfer overhead may outweigh the benefit.
- It requires compatible NVIDIA hardware, CUDA, drivers, and Python versions.
- Some pandas operations may fall back to CPU or be unsupported, requiring reference-file workarounds and narrow compatibility boundaries.
- The source provides no standalone test suite, benchmark results, or evidence of validation on specific platforms.
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| NVIDIA cuDF DataFrame Guide this page ✓ NVIDIA · Official | 57 · Use with care | ★ 3.6k | 13d ago | Apache-2.0 |
| cuPyNumeric Parallel Shard Loader ✓ NVIDIA · Official | 54 · Use with care | ★ 3.6k | 13d ago | Apache-2.0 |
| Local Knowledge Base Retriever | 53 · Use with care | ★ 13k | 17d ago | MIT |
| Hugging Face Datasets Skill | 50 · Use with care | ★ 38k | 15d ago | MIT |
| Hugging Face Dataset Explorer | 49 · Use with care | ★ 11k | 19d ago | Apache-2.0 |
The guide explicitly positions three paths: cudf.pandas for compatibility and minimal changes, explicit cuDF for control and hot-path work, and dask-cuDF for datasets that exceed GPU memory.
How did FollowSkills review this skill?
The skill is scoped to local cuDF/data-processing guidance and shows no malware, credential theft, covert exfiltration, destructive default, or grossly excessive permission. It makes GPU/CPU boundaries and conversion boundaries visible, but lacks explicit user confirmation, sensitive-data handling, dependency-security guidance, rollback, and clear data-flow controls for external documentation access, so points are deducted.
Path selection, compatibility notes, semantic validation advice, and OOM/unsupported-operation troubleshooting are reasonably detailed. However, the supplied material does not fully reproduce dependencies, referenced files, or key APIs; silent fallback is acknowledged; and there is no statically verifiable CI or test coverage, so the score is conservatively capped.
The audience, cuDF/cudf.pandas/dask-cuDF scenarios, 100K-row gate, and negative PyTorch case are reasonably clear. The description remains broad, explicit negative triggers are limited, Chinese-language interaction and mainland-China reachability are not addressed, and environment-fit evidence is thin, so points are deducted.
The documentation provides compatibility, three implementation paths, memory guidance, troubleshooting, reference files, a release version, and license information; the benchmark also recommends refreshing maintenance evidence. It lacks recommended Instructions, Examples, and Purpose sections, and installation/dependency notes, changelog, maintenance ownership, and update path remain incomplete, so points are deducted.
The material directly covers core ETL, joins, aggregations, nulls, reshaping, time series, and multi-GPU tasks, with actionable code patterns. The committed benchmark and evaluation tasks indicate potential utility, but static review cannot verify correctness, performance gains, or runtime usability, so the score stays within the static ceiling.
A pinned release, external documentation references, committed evaluation tasks, and a benchmark report provide some auditability. However, independently reproducible execution logs, CI workflows, test outputs, and cross-source corroboration are absent, warranting a low score.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →