awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

Verteilte Dataframe-Engines

Ranking aktualisiert am 30. Juni 2026

For eine Dataframe-Engine für große Datenmengen, the strongest matches are apache/datafusion (Apache DataFusion is a distributed query engine that provides), eventual-inc/daft (Daft is a distributed DataFrame library built on Ray) and modin-project/modin (Modin is a distributed DataFrame engine that scales pandas). pola-rs/polars and dask/dask round out the shortlist. Each is ranked by relevance to your query, popularity and recent activity.

High-Performance-Computing-Frameworks für die Verarbeitung und Analyse massiver Datensätze in verteilten Cluster-Umgebungen.

Verteilte Dataframe-Engines

Finde die besten Repos mit KI.Wir suchen mit KI nach den am besten passenden Repositories.
  • apache/datafusionAvatar von apache

    apache/datafusion

    8,908Auf GitHub ansehen↗

    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.

    RustDataframe EnginesDistributed Execution Coordinators
    Auf GitHub ansehen↗8,908
  • eventual-inc/daftAvatar von Eventual-Inc

    Eventual-Inc/Daft

    5,225Auf GitHub ansehen↗

    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.

    RustDistributed ComputingLazy Evaluation Frameworks
    Auf GitHub ansehen↗5,225
  • modin-project/modinAvatar von modin-project

    modin-project/modin

    10,389Auf GitHub ansehen↗

    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.

    PythonDataframe Engines
    Auf GitHub ansehen↗10,389
  • pola-rs/polarsAvatar von pola-rs

    pola-rs/polars

    38,855Auf GitHub ansehen↗

    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.

    RustDistributed Analytical RuntimesLazy Evaluation FrameworksCompute Cluster Orchestration
    Auf GitHub ansehen↗38,855
  • dask/daskAvatar von dask

    dask/dask

    13,746Auf GitHub ansehen↗

    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.

    PythonDistributed ComputingLazy Evaluation FrameworksData Partitioning Configuration
    Auf GitHub ansehen↗13,746
  • apache/sparkAvatar von apache

    apache/spark

    43,467Auf GitHub ansehen↗

    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.

    ScalaLazy Evaluation Engines
    Auf GitHub ansehen↗43,467
  • pathwaycom/pathwayAvatar von pathwaycom

    pathwaycom/pathway

    62,959Auf GitHub ansehen↗

    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.

    PythonData Processing Frameworks
    Auf GitHub ansehen↗62,959
  • apache/flinkAvatar von apache

    apache/flink

    26,086Auf GitHub ansehen↗

    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.

    JavaStream ProcessingUnified Batch and Stream Processing EnginesComplex Event Processing Engines
    Auf GitHub ansehen↗26,086

Related searches

  • eine schnellere Dataframe-Bibliothek als pandas
  • eine hochperformante Bibliothek für tabellarische Daten
  • eine Engine zum lokalen Abfragen von CSV- und Parquet-Dateien
  • Framework für verteiltes Modelltraining
  • ein Framework zum Aufbau skalierbarer Daten-Pipelines
  • eine Analytics-Datenbank für schnelle Abfragen großer Tabellen
  • ein gemeinsames In-Memory-Spaltenformat
  • ein Framework zum Aufbau skalierbarer Datenpipelines