For a faster dataframe library than pandas, the first results are vaexio/vaex (Vaex is an Apache Arrow DataFrame library with lazy evaluation and out-of-core processing for billion-row datasets, fitting your need for a faster-than-pandas tool — it covers parallel execution and disk-based handling well, though it lacks built-in GPU acceleration), rapidsai/cudf (cuDF is a GPU-accelerated DataFrame library that provides a pandas-like API while using GPU parallelism and Apache Arrow for fast data manipulation on large datasets, making it a comprehensive and flagship answer to the search for a faster pandas alternative) and pola-rs/polars. modin-project/modin and eventual-inc/daft round out the shortlist. Compare the match explanations and check the project documentation against your requirements.
These libraries provide accelerated data processing and manipulation capabilities that outperform standard pandas performance benchmarks.
Vaex is a high-performance Apache Arrow DataFrame library and out-of-core data processing engine designed to handle billion-row tabular datasets in Python. It functions as a lazy evaluation framework that defers computations and transformations until results are required, enabling the processing of datasets that exceed available system RAM by mapping files directly from disk. The project distinguishes itself as a tool for big data visualization and exploration, specifically integrated for use within interactive notebooks. It provides specialized capabilities for machine learning feature engin
Vaex is an Apache Arrow DataFrame library with lazy evaluation and out-of-core processing for billion-row datasets, fitting your need for a faster-than-pandas tool — it covers parallel execution and disk-based handling well, though it lacks built-in GPU acceleration.
cuDF is a GPU-accelerated dataframe library and data processing engine designed for manipulating and analyzing large tabular datasets. It provides a high-level API for executing filtering, joining, and aggregating operations directly on GPU hardware. The project integrates the Apache Arrow memory format to enable zero-copy data transfers and includes a just-in-time compiler for executing custom user-defined functions on the GPU. The library features specialized acceleration for existing workflows by redirecting standard Pandas dataframe calls and Polars query plans to a GPU backend. It also p
cuDF is a GPU-accelerated DataFrame library that provides a pandas-like API while using GPU parallelism and Apache Arrow for fast data manipulation on large datasets, making it a comprehensive and flagship answer to the search for a faster pandas alternative.
Polars is a high-performance columnar data processing library designed for efficient analytical workflows. It functions as a structured data library that organizes information into typed columns, utilizing the Apache Arrow memory format to enable zero-copy data sharing and cache-friendly, vectorized operations. The engine is built to handle large-scale tabular datasets, providing both local and distributed analytical runtimes that scale from single-machine environments to multi-node clusters. The project distinguishes itself through a sophisticated lazy query engine that constructs abstract e
Polars is a high-performance DataFrame library that uses Apache Arrow for zero-copy operations, offers parallel execution via its vectorized engine, supports out-of-core processing, and includes a sophisticated lazy evaluation system — directly meeting the need for faster-than-pandas data tasks on large or complex datasets, with GPU acceleration hinted through hardware-acceleration tags.
Modin is a distributed dataframe library and parallel data processing engine designed to handle large datasets that exceed system memory. It functions as a distributed computing framework that parallelizes data manipulation tasks across multiple CPU cores or clusters to increase throughput and avoid memory errors. The project mirrors the Pandas API, allowing for the distribution of data workflows without changing core code logic. It utilizes a pluggable backend interface, which enables users to switch between different distributed execution engines to optimize performance based on available h
Modin is a distributed DataFrame library that parallelizes pandas operations across CPU cores or clusters to handle large datasets, which aligns with the search for a high-performance alternative to pandas; it supports parallel execution and out-of-core processing but does not explicitly advertise GPU acceleration or Apache Arrow integration.
Daft is a distributed dataframe library and multimodal data processor designed to handle large-scale structured and unstructured data. It functions as a vectorized execution engine that processes tables alongside images, audio, and video, utilizing a unified schema to manage diverse data types. The project distinguishes itself by combining distributed data engineering with large-scale AI inference. It provides an AI data pipeline for batch-optimizing model prompts and generating high-dimensional text embeddings, while utilizing zero-copy memory sharing to execute custom Python functions witho
Daft is a distributed dataframe library built in Rust with Apache Arrow support, designed for large-scale data and AI pipelines, making it a strong candidate for high-performance DataFrame tasks beyond pandas, though GPU acceleration is not explicitly highlighted.
Apache DataFusion is an extensible, columnar SQL query engine that runs embedded within a host application without requiring a separate server process. It processes data in columnar batches using Apache Arrow for memory-efficient analytics, and can scale analytic workloads across multiple nodes for parallel execution. The engine supports both SQL and DataFrame queries through a modular, streaming architecture that allows custom operators, data sources, functions, and optimizer rules. The engine distinguishes itself through its modular extension framework, which enables building custom query e
Apache DataFusion is a high-performance DataFrame and SQL query engine built on Apache Arrow with built-in parallel execution and lazy evaluation, making it a strong fit for large-scale analytical workloads even though it lacks explicit GPU acceleration.
Apache Spark is a unified distributed data processing engine designed for large-scale data analysis and computation graphs. It functions as a distributed machine learning framework, a graph processing system, a real-time stream processor, and a SQL analytics engine. The system enables the execution of distributed SQL querying, large-scale graph analysis, and real-time stream analytics across clusters of machines. It also provides a scalable environment for implementing machine learning algorithms and predictive model development on massive datasets. The engine incorporates relational query e
Apache Spark is a distributed DataFrame engine with lazy evaluation and parallel execution across clusters, fitting the core need for high-performance data operations, though it does not natively emphasize Apache Arrow or GPU acceleration.
Dask is a parallel computing framework and distributed task scheduler designed to scale Python data science workflows from single machines to large clusters. It functions as a cluster resource manager that orchestrates computational logic by representing tasks and their dependencies as directed acyclic graphs. This architecture allows the system to automate the distribution of workloads across available hardware while managing complex execution requirements. The project distinguishes itself through a lazy evaluation engine that defers data operations until they are explicitly requested, enabl
Dask is a parallel computing framework that provides a lazy-evaluation DataFrame API scaling beyond pandas for large data tasks, aligning with your need for a high-performance DataFrame library, though its core documentation doesn't emphasize GPU acceleration or Arrow format integration.
A Python package for manipulating 2-dimensional tabular data structures
datatable is a high-performance DataFrame library for Python that achieves speed through parallel execution and out-of-core processing, making it a solid fit for large tabular data tasks, though it does not offer GPU acceleration or lazy evaluation.
This library is a data processing framework for the JVM that provides a type-safe environment for manipulating structured tabular data. It functions as a comprehensive toolset for performing complex data transformations, aggregations, and statistical analysis, while leveraging compile-time schema validation to ensure structural integrity across data pipelines. The project distinguishes itself through its deep integration with interactive notebook environments and its use of compile-time code generation. By automatically deriving and enforcing schemas from raw inputs, it generates type-safe ac
Kotlin DataFrame is a typesafe in-memory structured data processing library for the JVM, matching the DataFrame category you are looking for, but it does not advertise the high-performance capabilities—such as parallel execution, out-of-core processing, or GPU acceleration—that would make it a faster alternative to pandas.
Lance is a columnar data format and storage layer designed for high-performance random access and the persistence of multimodal data. It functions as a vector database storage system, a multimodal data store, and a versioned dataset manager. The project distinguishes itself as a hybrid search engine that combines vector similarity search and full-text indexing on a single dataset. It provides unified storage for diverse data types including images, audio, and video, utilizing a system that lazy-loads large binary objects only when requested. The system manages dataset evolution through schem
Lance is a columnar storage format and multimodal data store built on Apache Arrow, not a DataFrame manipulation library — it can store data that DataFrames might read, but it does not itself provide DataFrame operations like groupby, join, or aggregation.
This project is an automated machine learning framework and toolkit designed for training and tuning custom models for classification, regression, and recommendations. It functions as a multimodal machine learning toolkit capable of processing and training models using a combination of text, image, audio, and sensor data. The framework distinguishes itself as a multimodal data processor that can handle and visualize large datasets on a single machine using column-oriented disk storage. It includes a core machine learning model generator that converts trained models into formats compatible wit
Turi Create is an automated machine learning framework for building classification, regression, and recommendation models, not a dedicated DataFrame library—though it does handle large datasets with column-oriented storage and GPU acceleration, its core identity is ML toolkit, not the high-performance DataFrame you're seeking.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| vaexio/vaex | 8.5K | Python | MIT | |
| rapidsai/cudf | 9.7K | C++ | Apache-2.0 | |
| pola-rs/polars |
| 38.9K |
| Rust |
| MIT |
| modin-project/modin | 10.4K | Python | Apache-2.0 |
| eventual-inc/daft | 5.2K | Rust | apache-2.0 |
| apache/datafusion | 8.9K | Rust | Apache-2.0 |
| apache/spark | 43.5K | Scala | Apache-2.0 |
| dask/dask | 13.7K | Python | bsd-3-clause |
| h2oai/datatable | 1.9K | C++ | MPL-2.0 |
| kotlin/dataframe | 1K | Kotlin | Apache-2.0 |