Skip to content
Back to search

cudf

cuDF - GPU DataFrame Library

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/NVIDIA/cudf with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/NVIDIA/cudf'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/nvidia--cudf/badge.svg)](/listings/nvidia--cudf)

HTML

<a href="/listings/nvidia--cudf"><img src="/api/listings/nvidia--cudf/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

System Requirements

Operating System, GPU driver, and supported CUDA version information can be found at the [system requirements](https://docs.nvidia.com/datascience/install/#system-req)

pip

A stable release of each cudf library is available on PyPI. You will need to match the major version number of your installed CUDA version with a `-cu##` suffix when installing from PyPI.

A development version of each library is available as a nightly release by including the `-i https://pypi.anaconda.org/rapidsai-wheels-nightly/simple/` index.

# CUDA 13
pip install libcudf-cu13
pip install pylibcudf-cu13
pip install cudf-cu13
pip install cudf-polars-cu13
pip install dask-cudf-cu13

# CUDA 12
pip install libcudf-cu12
pip install pylibcudf-cu12
pip install cudf-cu12
pip install cudf-polars-cu12
pip install dask-cudf-cu12

conda

A stable release of each cudf library is available to be installed with the conda package manager by specifying the `-c rapidsai` channel.

A development version of each library is available as a nightly release by specifying the `-c rapidsai-nightly` channel instead.

conda install -c rapidsai libcudf
conda install -c rapidsai pylibcudf
conda install -c rapidsai cudf
conda install -c rapidsai cudf-polars
conda install -c rapidsai dask-cudf

source

To install cuDF from source, please follow [the contribution guide](CONTRIBUTING.md#setting-up-your-build-environment) detailing how to setup the build environment.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 153 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # NVIDIA cuDF: A GPU-accelerated DataFrame library for tabular data processing
  2. NVIDIA cuDF (pronounced "KOO-dee-eff") is an [Apache 2.0 licensed](LICENSE), GPU-accelerated DataFrame library
  3. for tabular data processing. The cuDF library is one part of the [NVIDIA
  4. CUDA-X](https://developer.nvidia.com/cuda/cuda-x-libraries) suite of GPU
  5. Accelerated libraries.
  6. ## About
  7. cuDF is composed of multiple libraries including:
  8. * [libcudf](https://docs.nvidia.com/cudf/latest/libcudf/): A CUDA C++ library with [Apache Arrow](https://arrow.apache.org/) compliant
  9. data structures and fundamental algorithms for tabular data.
  10. * [pylibcudf](https://docs.nvidia.com/cudf/latest/pylibcudf/): A Python library providing [Cython](https://cython.org/) bindings for libcudf.
  11. * [cudf](https://docs.nvidia.com/cudf/latest/cudf/): A Python library providing
  12. - A DataFrame library mirroring the [pandas](https://pandas.pydata.org/) API
  13. - A zero-code change accelerator, [cudf.pandas](https://docs.nvidia.com/cudf/latest/cudf_pandas/), for existing pandas code.
  14. * [cudf-polars](https://docs.nvidia.com/cudf/latest/cudf_polars/): A Python library providing a GPU engine for [Polars](https://pola.rs/)
  15. * [dask-cudf](https://docs.nvidia.com/dask-cudf/latest/): A Python library providing a GPU backend for [Dask](https://www.dask.org/) DataFrames
  16. Examples of projects that use cuDF:
  17. * [NVIDIA cuDF plugin for Apache Spark](https://github.com/NVIDIA/cudf-spark): A GPU accelerator plugin for [Apache Spark](https://spark.apache.org/)
  18. * [cuML](https://docs.nvidia.com/cuml/latest/) (NVIDIA): cuDF DataFrame inputs and outputs for GPU machine-learning workflows.
  19. * [cuGraph](https://docs.nvidia.com/cugraph/latest/) (NVIDIA): cuDF edge-list inputs for GPU graph construction and analytics.
  20. * [NeMo Curator](https://docs.nvidia.com/nemo/curator/latest/reference/infra/gpu-processing) (NVIDIA): cuDF-backed GPU processing for text curation and deduplication.
  21. * [Velox-cuDF](https://github.com/facebookincubator/velox/blob/main/velox/experimental/cudf/README.md): An experimental [Velox](https://velox-lib.io/) extension that executes supported query operators on GPUs using libcudf.
  22. * [Polars](https://docs.pola.rs/user-guide/gpu-support/): A cuDF-backed GPU engine for supported Lazy API queries.
  23. * [Sirius](https://www.sirius-db.com/): A GPU-native SQL engine providing extensions for libraries like [DuckDB](https://duckdb.org/)
  24. * [Starburst Torin](https://docs.starburst.io/latest/admin/gpu-acceleration.html): GPU execution for Starburst Enterprise SQL using cuDF.
  25. * [Presto GPU](https://github.com/prestodb/prestorials/tree/main/docker-compose-native/cpu-and-gpu): Experimental GPU-accelerated Presto query processing through Velox and cuDF, with public evaluation notebooks.
  26. * [TornadoVM](https://github.com/beehive-lab/TornadoVM): A GPU programming framework for Java that JIT-compiles Java to CUDA and runs [libcudf operations](https://github.com/beehive-lab/TornadoVM/tree/develop/tornado-native-libs/tornado-cudf) as tasks alongside those kernels; used as a GPU engine for [Apache Flink](https://flink.apache.org/)
  27. * HoloViz: [Datashader](https://datashader.org/user_guide/Performance.html), [HoloViews](https://holoviews.org/reference_manual/holoviews.core.data.cudf.html) and [hvPlot](https://hvplot.holoviz.org/en/docs/latest/) provide cuDF-backed aggregation, data exploration and plotting interfaces.
  28. * [PyGraphistry](https://pygraphistry.readthedocs.io/en/latest/gfql/engines.html): cuDF-backed graph queries and exploration through GFQL.
  29. * [Ray Data](https://docs.ray.io/en/latest/data/api/doc/ray.data.Dataset.map_batches.html): Experimental cuDF batch support for GPU transforms in distributed data pipelines.
  30. * [XGBoost](https://xgboost.readthedocs.io/en/stable/python/data_input.html): Native cuDF DataFrame and Series inputs for supported gradient-boosting workflows.
  31. This list is not exhaustive. If your project uses cuDF, you're welcome to [submit a pull request](https://github.com/NVIDIA/cudf/blob/main/CONTRIBUTING.md) with a project link, a short description of the integration, and public documentation or an example.
  32. ## Installation
  33. ### System Requirements
  34. Operating System, GPU driver, and supported CUDA version information can be found at the [system requirements](https://docs.nvidia.com/datascience/install/#system-req)
  35. ### pip
  36. A stable release of each cudf library is available on PyPI. You will need to match the major version number of your installed CUDA version with a `-cu##` suffix when installing from PyPI.
  37. A development version of each library is available as a nightly release by including the `-i https://pypi.anaconda.org/rapidsai-wheels-nightly/simple/` index.
  38. ```bash
  39. # CUDA 13
  40. pip install libcudf-cu13
  41. pip install pylibcudf-cu13
  42. pip install cudf-cu13
  43. pip install cudf-polars-cu13
  44. pip install dask-cudf-cu13
  45. # CUDA 12
  46. pip install libcudf-cu12
  47. pip install pylibcudf-cu12
  48. pip install cudf-cu12
  49. pip install cudf-polars-cu12
  50. pip install dask-cudf-cu12
  51. ```
  52. ### conda
  53. A stable release of each cudf library is available to be installed with the conda package manager by specifying the `-c rapidsai` channel.
  54. A development version of each library is available as a nightly release by specifying the `-c rapidsai-nightly` channel instead.
  55. ```bash
  56. conda install -c rapidsai libcudf
  57. conda install -c rapidsai pylibcudf
  58. conda install -c rapidsai cudf
  59. conda install -c rapidsai cudf-polars
  60. conda install -c rapidsai dask-cudf
  61. ```
  62. ### source
  63. To install cuDF from source, please follow [the contribution guide](CONTRIBUTING.md#setting-up-your-build-environment) detailing
  64. how to setup the build environment.
  65. ## Examples
  66. The following examples showcase reading a parquet file, dropping missing rows with a null value,
  67. and performing a groupby aggregation on the data.
  68. ### cudf
  69. `import cudf` and the APIs are largely similar to pandas.
  70. ```python
  71. import cudf
  72. df = cudf.read_parquet("data.parquet")
  73. df.dropna().groupby(["A", "B"]).mean()
  74. ```
  75. ### cudf.pandas
  76. With a Python file containing pandas code:
  77. ```python
  78. import pandas as pd
  79. df = pd.read_parquet("data.parquet")
  80. df.dropna().groupby(["A", "B"]).mean()
  81. ```
  82. Use cudf.pandas by invoking `python` with `-m cudf.pandas`
  83. ```bash
  84. $ python -m cudf.pandas script.py
  85. ```
  86. If running the pandas code in an interactive Jupyter environment, call `%load_ext cudf.pandas` before
  87. importing pandas.
  88. ```python
  89. In [1]: %load_ext cudf.pandas
  90. In [2]: import pandas as pd
  91. In [3]: df = pd.read_parquet("data.parquet")
  92. In [4]: df.dropna().groupby(["A", "B"]).mean()
  93. ```
  94. ### cudf-polars
  95. Using Polars' [lazy API](https://docs.pola.rs/user-guide/lazy/), call `collect` with `engine="gpu"` to run
  96. the operation on the GPU
  97. ```python
  98. import polars as pl
  99. lf = pl.scan_parquet("data.parquet")
  100. lf.drop_nulls().group_by(["A", "B"]).mean().collect(engine="gpu")
  101. ```
  102. ## Questions and Discussion
  103. For bug reports or feature requests, please [file an issue](https://github.com/NVIDIA/cudf/issues/new/choose) on the GitHub issue tracker.
  104. For questions or discussion about cuDF and GPU data processing, feel free to post in the [community Slack](https://rapids.ai/slack-invite) workspace.
  105. ## Contributing
  106. cuDF is open to contributions from the community! Please see our [guide for contributing to cuDF](CONTRIBUTING.md) for more information.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.