For a dataframe engine for huge data, the first results are apache/datafusion (Apache DataFusion is a distributed query engine that provides a DataFrame API, lazy evaluation with query optimization, and scales across multiple nodes, matching your need for a distributed computing engine for large-scale datasets), eventual-inc/daft and modin-project/modin (Modin is a distributed DataFrame engine that scales pandas workflows across clusters with a familiar API, hitting the core requirement of a distributed big-data DataFrame tool with pluggable backends and out-of-core capabilities). pola-rs/polars and dask/dask round out the shortlist. Compare the match explanations and check the project documentation against your requirements.
High-performance computing frameworks designed for processing and analyzing massive datasets across distributed cluster environments.
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 distributed query engine that provides a DataFrame API, lazy evaluation with query optimization, and scales across multiple nodes, matching your need for a distributed computing engine for large-scale datasets.
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 on Ray that provides a vectorized execution engine with a unified DataFrame API, supports multiple file formats (Parquet, Iceberg, etc.) and storage backends, and scales to large datasets across clusters using lazy evaluation and optimized query execution — exactly fitting the search for a distributed DataFrame engine for big data.
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 engine that scales pandas workflows across clusters with a familiar API, hitting the core requirement of a distributed big-data DataFrame tool with pluggable backends and out-of-core capabilities.
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 DataFrame library with a lazy query engine and support for distributed execution across clusters, fitting the core requirement of a distributed DataFrame API for large-scale data, though its fault tolerance and mature cluster management are less emphasized than in dedicated distributed engines.
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 provides a distributed DataFrame API that scales pandas workflows across clusters with lazy evaluation and fault tolerance, making it a perfect fit for large-scale data analysis.
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 the definitive unified distributed data processing engine with a rich DataFrame API, lazy evaluation with Catalyst query optimization, native fault tolerance, and broad file-format and storage backend support, making it the perfect match for large-scale cluster analytics.
Pathway is a high-performance data processing framework designed for building unified batch and streaming pipelines. It functions as an orchestrator for complex data transformations, utilizing a differential dataflow engine to process updates incrementally. By treating static datasets and continuous event streams with identical logic, the platform ensures exactly-once processing semantics and consistent results across diverse data sources. The framework distinguishes itself through its specialized support for real-time artificial intelligence and retrieval-augmented generation. It features in
Pathway is a distributed data processing framework that offers a DataFrame-like API for unified batch and stream pipelines, making it a solid fit for a distributed DataFrame engine, though its emphasis on real-time AI and incremental processing may mean traditional big-data file format support is less comprehensive.
Apache Flink is a distributed processing engine designed for both high-throughput, low-latency data streams and finite batch workloads. It functions as a stateful stream processor and a SQL stream processing engine, providing a unified runtime to execute relational queries and event-based transformations. The system is distinguished by its ability to manage persistent operator state to ensure exactly-once processing guarantees and consistency during failures. It features specialized capabilities for complex event processing to detect temporal patterns and handles out-of-order events using eve
Apache Flink is a distributed processing engine that supports both stream and batch workloads, and its Table API and SQL provide a relational abstraction similar to a DataFrame API for large-scale data analysis with fault tolerance and cluster scalability, fitting the search for a distributed DataFrame engine.
Storm is a distributed stream processing framework and fault-tolerant compute engine designed for executing real-time continuous computations across a cluster of machines. It functions as a stateful stream processor and cluster topology manager, enabling the deployment and monitoring of distributed data flow configurations. The system ensures exactly-once semantics by utilizing transactional state management to guarantee that every message in a data stream is processed exactly one time. It further operates as a distributed RPC system, allowing for the integration of non-native languages throu
Storm is a distributed stream processing engine for real-time computations, not a DataFrame-based engine for batch analytics on large datasets—so it fits a related but different use case than what you are looking for.
Apache Storm is a distributed stream processing framework and real-time data processing engine. It functions as a fault-tolerant distributed computing system designed to analyze data in motion across a cluster of machines for continuous stream computation. The system enables the creation of fault-tolerant data pipelines and scalable event processing by distributing workloads across a network of computing nodes. This architecture ensures low latency and high throughput for live data while allowing the system to recover automatically from individual node failures. The framework provides capabi
Apache Storm is a distributed stream processing framework for real-time event streams, not a DataFrame API engine for batch analytics; it lacks the DataFrame abstraction and lazy query optimization this search requires.
Pygwalker is a library that transforms tabular data into interactive, drag-and-drop interfaces for exploratory analysis and visualization. It functions as a grammar-based framework that translates user interactions into declarative chart definitions, allowing for the creation of dynamic data exploration environments directly within notebooks or embedded web applications. The system distinguishes itself by offloading heavy analytical computations to backend kernels, which maintains responsiveness when visualizing large datasets. It supports the serialization of visual states into portable conf
Pygwalker is an interactive data exploration and visualization library that works with DataFrames but is not a distributed computing engine — it runs on a single machine and focuses on visual analysis rather than cluster-wide data processing with fault tolerance and query optimization.
Hadoop is a big data infrastructure suite and distributed data processing framework designed to store and process massive datasets across clusters of computers. It consists of a distributed storage system for managing large files across multiple nodes and a parallel computing engine for processing data across a distributed cluster. The framework implements a distributed file system to ensure fault tolerance and high throughput, paired with a programming model that processes large datasets in parallel. It manages the underlying hardware and software environment required for distributed big dat
Hadoop provides fault-tolerant distributed processing for large datasets, but it uses the MapReduce programming model rather than a high-level DataFrame API, so it does not match the desired distributed DataFrame engine.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| apache/datafusion | 8.9K | Rust | Apache-2.0 | |
| eventual-inc/daft | 5.2K | Rust | apache-2.0 | |
| modin-project/modin |
| 10.4K |
| Python |
| Apache-2.0 |
| pola-rs/polars | 38.9K | Rust | MIT |
| dask/dask | 13.7K | Python | bsd-3-clause |
| apache/spark | 43.5K | Scala | Apache-2.0 |
| pathwaycom/pathway | 63K | Python | NOASSERTION |
| apache/flink | 26.1K | Java | Apache-2.0 |
| nathanmarz/storm | 8.8K | Java | Apache-2.0 |
| apache/incubator-storm | 6.7K | Java | Apache-2.0 |