awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
hazelcast avatar

hazelcast/hazelcast

0
View on GitHub↗
www.hazelcast.com↗

Hazelcast

Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to support real-time analytics and event-driven applications. It functions as a partitioned, distributed key-value store that replicates data across cluster nodes to provide low-latency access and high availability. The platform also serves as a distributed SQL query engine, allowing users to execute standard SQL statements against both in-memory datasets and external data sources.

What distinguishes Hazelcast is its use of a distributed consensus subsystem to maintain strongly consistent state, ensuring reliability during network partitions or node failures. It optimizes performance by managing data in native off-heap memory, which minimizes garbage collection pauses, and by executing data pipelines through a directed acyclic graph that parallelizes transformation logic across cluster members. The platform automates cluster operations through dynamic membership discovery, which identifies and connects nodes in cloud or containerized environments without manual intervention.

The platform provides a comprehensive suite of capabilities for managing distributed state, including coordination primitives like locks and semaphores for microservices, and fault-tolerant stream processing for unbounded event data. It supports complex data workflows through windowing, stateful transformations, and integration with external systems via a library of connectors. A multi-language client bridge and standardized binary protocols enable external applications to interact with the cluster using various programming languages.

Hazelcast is designed for flexible deployment, supporting both embedded and client-server models across cloud and container orchestration platforms. It includes built-in observability tools for monitoring cluster health, performance metrics, and job execution, alongside security features such as TLS encryption, role-based access control, and authentication mechanisms.

Features

  • Distributed Key-Value Stores - Functions as a partitioned, distributed key-value store that replicates data across cluster nodes for low-latency access.
  • Distributed Consensus Stores - Uses distributed consensus algorithms to maintain strongly consistent state across cluster nodes.
  • Distributed Data Platforms - Combines in-memory data storage with stream processing for real-time data analytics and event-driven applications.
  • Caching and Key-Value Stores - Provides a distributed key-value store that functions as a high-performance caching layer for application state.
  • Cluster Member Status and Information Listing - Automates the discovery and connection of cluster nodes across cloud or local networks.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
6,570 stars·1,873 forks·Java·52 views
  • Distributed Atomic Operations - Provides atomic operations on key-value pairs across a distributed cluster without requiring manual locking.
  • Change Data Capture - Synchronizes in-memory state with external databases using change data capture to stream real-time modifications.
  • Distributed Data Replication - Distributes copies of data partitions across different cluster members to ensure continuous availability.
  • Partitioned Data Replicators - Distributes copies of data partitions across nodes to ensure continuous availability and automatic recovery.
  • Map Value Updates - Supports atomic updates to distributed map entries with conditional logic to prevent overwriting existing values.
  • Streaming Aggregations - Computes summary statistics or custom metrics over data streams using built-in operations.
  • Data Connectors - Provides a comprehensive library of connectors for extracting and loading data from messaging queues and databases.
  • Application Data Caches - Reduces database load by storing frequently accessed application data in a distributed memory layer.
  • Data Availability Layers - Distributes partition replicas across distinct physical or logical groups to prevent data loss during infrastructure failures.
  • Streaming Data Processing - Executes distributed pipelines that ingest, transform, and analyze unstructured data in real-time.
  • Data Joins - Correlates data from multiple sources using hash joins for memory-efficient lookups or co-grouping for key-based aggregation.
  • Data Pipeline Orchestration - Deploys and monitors streaming data processing jobs to handle event-driven workflows across the cluster.
  • Data Processing Pipelines - Constructs linear data transformation workflows by chaining source, compute, and sink stages for streaming information.
  • Exactly-Once Processing Semantics - Uses distributed snapshots to provide at-least-once or exactly-once processing semantics for fault-tolerant jobs.
  • Distributed Computing - Executes parallel processing tasks across cluster nodes to perform complex computations on large datasets.
  • Real-Time Data Processors - Handles both endless streams of event data and finite static datasets for unified processing.
  • Data Replication Strategies - Distributes data across cluster members using shards and maintains backup replicas to ensure high availability.
  • Cluster-Wide Data Synchronizers - Synchronizes key-value entries across all cluster members to ensure high-speed local access and automatic data recovery.
  • Stream Processing Pipelines - Defines and executes continuous data processing jobs that read from sources, transform data, and write to sinks.
  • Strongly Consistent Data Stores - Provides strongly consistent data structures that guarantee linearizability and remain operational during network partitions or node failures.
  • Atomic Key-Value Operations - Provides atomic key-value operations including reads, writes, and conditional updates for strict consistency.
  • Closure-Based Atomic Updates - Runs a function directly on the cluster member where a data entry resides to perform atomic read-and-update operations without network hops.
  • Distributed Atomic Transactions - Ensures data integrity across distributed operations by coordinating multiple resources to commit or abort as a single unit.
  • Distributed Cluster Execution - Executes data processing workloads across a cluster of server nodes to increase throughput using parallel graph processing.
  • Distributed Collections - Provides distributed versions of standard data structures like maps, queues, and lists for shared access across a cluster.
  • Distributed Data Grids - Stores data in memory across a cluster by splitting key-value pairs into shards distributed among multiple nodes for horizontal scalability.
  • Distributed Execution Coordinators - Orchestrates the distribution and lifecycle of execution plans across cluster members with automatic rescheduling and failure recovery.
  • Distributed Key-Value Stores - Provides a partitioned, distributed key-value store that replicates data across cluster nodes for high availability.
  • Data Partitioning - Splits datasets across multiple nodes to distribute load and increase storage capacity for parallel processing.
  • Distributed SQL Querying - Executes standard SQL statements against distributed data structures to retrieve or manipulate records.
  • Distributed Task Schedulers - Executes distributed tasks across cluster partitions to process data where it physically resides.
  • Time-Window Aggregations - Provides time-windowed aggregations for unbounded event streams to enable real-time analytics.
  • Fault Tolerant Storage - Replicates map entries across multiple cluster members to prevent data loss and maintain availability when a node fails.
  • Distributed Map Aggregators - Computes distributed functions like sum or max across map entries in parallel.
  • High Availability Architectures - Automatically replicates data across multiple cluster members to prevent data loss in the event of a single member failure.
  • In-Memory Data Stores - Maintains application state in distributed memory for low-latency access.
  • In-Memory State Querying - Retrieves and filters live application data stored in distributed memory using SQL or API calls.
  • Key-Value Stores - Distributes data pairs across a cluster to enable horizontal scaling and high-speed access to primitives, serialized objects, or JSON values.
  • Atomic State Transitions - Executes atomic reads, writes, and conditional updates on key-value pairs to ensure strict consistency.
  • Low-Latency Data Retrieval - Enables low-latency data retrieval by maintaining stateful data in memory across a distributed cluster.
  • Pessimistic - Prevents race conditions by using pessimistic or optimistic locking strategies to ensure data consistency across distributed nodes.
  • Replica Promotions - Ensures continuous availability by automatically promoting backup replicas to primary status when a member fails.
  • Automatic Failover Replicas - Ensures continuous data availability by automatically promoting backup replicas when primary nodes fail.
  • Low-Latency Query Engines - Executes low-latency SQL queries against real-time streams and stored datasets.
  • Streaming State Management - Manages internal state for complex streaming operations including TTL-based eviction and explicit deletion.
  • Real-Time Data Streaming - Handles endless streams of out-of-order data using stateful computations and low-latency processing.
  • Stream Computing Engines - Executes complex operations such as grouped aggregations and event-time windowing on streaming data.
  • Real-Time Event Processing - Builds and executes real-time data pipelines to power event-driven applications.
  • Cluster Distribution - Partitions data entries across cluster members using consistent hashing to ensure uniform distribution and predictable lookups.
  • Cluster Formation Engines - Forms a network of communicating server members that store and process data in memory across multiple instances.
  • Server-Side Data Processors - Processes data updates directly within the cluster to avoid the overhead of transferring entries to the client and back.
  • SQL Query Execution - Executes standard SQL statements against distributed datasets and external sources with configurable output.
  • Distributed Map Operations - Invokes remote procedures and data manipulations across a cluster to enable low-latency processing of shared application state.
  • Stream Processing Engines - Activates the distributed engine to perform stateful stream processing and event-driven computations across the cluster.
  • Stream Processing Pipelines - Ships a high-throughput stream processing engine for building real-time, event-driven data pipelines.
  • Strong Consistency Guarantees - Uses a consensus algorithm to provide strongly consistent data structures for critical operations that require guaranteed accuracy.
  • Consistency Level Management - Provides configurable consistency levels, allowing applications to choose between high availability and strong consistency.
  • Write Consistency Enforcement - Maintains strict data consistency across nodes using a consensus-based subsystem to ensure reliable state management.
  • Distributed Unique Collections - Stores a collection of unique elements across a cluster, ensuring data availability through backups on multiple members.
  • Stateful Pipeline Executions - Runs fault-tolerant, stateful stream processing jobs with independent scaling and recovery.
  • Backpressure Management - Uses bounded queues and adaptive windows to manage pipeline backpressure.
  • Distributed Concurrency Controls - Provides atomic primitives like locks and semaphores to ensure consistent state across distributed nodes.
  • Client Connection Configurations - Manages network settings, security credentials, and cluster discovery for client-to-cluster connectivity.
  • Cluster Configuration Management - Provides centralized configuration of member and client behavior before cluster startup.
  • Cluster Membership Protocols - Allows runtime modification of cluster membership via API to facilitate node discovery and recovery.
  • Clustered Infrastructure - Provides administrative tools and operators to deploy, monitor, and scale distributed clusters across cloud and containerized environments.
  • Backpressure Controllers - Regulates data ingestion rates to prevent system overload when downstream sinks are saturated.
  • Distributed Data Architectures - Splits data into partitions and distributes them across cluster members to achieve horizontal scalability.
  • Distributed Job Execution - Manages job lifecycles and distributes execution plans across cluster members with automatic failover.
  • Distributed Task Coordination - Provides synchronization primitives like locks and semaphores to manage concurrent access across nodes.
  • Fault Tolerance - Ensures fault-tolerant processing by persisting connector state to enable automatic recovery and resume ingestion.
  • Exactly-Once Processing Guarantees - Ensures reliable data delivery by coordinating pipeline snapshots to support exactly-once or at-least-once processing semantics.
  • High Availability Infrastructure - Groups partition replicas across distinct availability zones or fault domains to prevent data loss during infrastructure failures.
  • High Availability Job Execution - Ensures continuous task processing through automatic failover and redundancy across cluster members.
  • Automatic Job Rescaling - Provides automatic job rescaling and fault recovery to ensure continuous processing during cluster topology changes.
  • Cluster Discovery - Automates cluster member discovery in cloud and container environments by querying infrastructure metadata.
  • Distributed Cluster Provisioners - Automatically discovers members across cloud, Kubernetes, or network environments to form a unified communication network.
  • Pipeline Submissions - Package a pipeline into a deployable file and submit it to a cluster for optimized distributed execution.
  • Distributed Data Stores - Distributes data across a cluster to ensure high availability and scalability.
  • Engine Runtime Configurators - Centralizes core engine configuration for network discovery and stream processing capabilities.
  • Split-Brain Prevention Mechanisms - Validates cluster membership size before executing operations to prevent inconsistent data states during network partitions.
  • Data Synchronization and Consistency - Provides consensus-based state management to ensure data integrity and consistency during network partitions or node failures.
  • Consistency Models - Provides a choice between high availability or strict data synchronization based on the consensus algorithm.
  • Group Member Failure Detections - Repartition data across remaining cluster members automatically when a node shuts down to maintain service continuity.
  • Member Failure Recovery - Automatically repartitions data using backups when a member shuts down to maintain continuous availability.
  • Distributed Coordination Services - Provides distributed coordination primitives like locks and leader election for reliable state management.
  • Stream Processing Integrations - Provides fault-tolerant stream processing pipelines that ingest and transform unbounded event data from external sources.
  • Off-Heap Memory Managers - Manages data in native off-heap memory to minimize garbage collection pauses and support large-scale datasets.
  • Cluster Consistency Protections - Checks for a minimum number of active cluster members before performing operations to avoid inconsistent state during network partitions.
  • Cluster Security - Protects distributed data and management interfaces through authentication, authorization, and encryption mechanisms.
  • Consistency Protection Mechanisms - Validates that a minimum number of cluster members are available before performing operations to avoid conflicting updates during network failures.
  • Mutual TLS Authentication - Verifies the identity of cluster members and clients using configurable security realms and mutual TLS authentication.
  • Cluster Member Authentications - Validates the identity of connecting clients and cluster members to ensure only authorized entities join the cluster.
  • Mutual Authentication - Requires clients to present valid certificates during the TLS handshake to verify their identity.
  • Network Encryption - Secures data in transit between cluster members, clients, and WAN-replicated clusters by enforcing TLS encryption.
  • End-to-End Encryption - Secures data in transit between cluster members and clients using TLS protocols to ensure end-to-end encryption.
  • Concurrent Shared-Map Access - Provides exclusive locks, semaphores, and countdown latches to synchronize threads and control access to shared resources.
  • Security and Access Control - Enforces authentication and encryption protocols to protect data in transit and at rest.
  • Data Processing Pipelines - Implements modular data processing pipelines to ingest, transform, and move information between systems.
  • Distributed Storage Clusters - Spawns nodes that automatically discover each other to form a unified, scalable network for distributed data storage and processing.
  • Split Cluster Recoveries - Provides automated recovery mechanisms to merge partitioned cluster segments and restore a unified system state.
  • Event Partition Key Assigners - Routes events with identical keys to the same processing task to ensure consistent stateful aggregations.
  • Event-to-State Transformations - Retains mutable state across items to implement complex patterns or correlation IDs with time-based eviction.
  • Fault Tolerance - Captures periodic state snapshots to automatically resume jobs from the last checkpoint in the event of member failure.
  • Indeterminate Operation Handlers - Ensures consistency by determining whether to retry operations or report errors when responses are lost during network failures.
  • Microservices Process Coordinators - Offers distributed coordination primitives to manage state and synchronization across microservices.
  • Directed Acyclic Graph Pipelines - Transforms data processing logic into a directed acyclic graph to enable parallel, multi-stage execution across the cluster.
  • Distributed Work Queues - Implements a first-in-first-out queue that allows cluster members and clients to enqueue and dequeue serializable objects across a network.
  • Cluster Health Monitoring - Provides real-time status checks and diagnostic utilities to monitor cluster stability and member state.
  • Cluster Management Interfaces - Provides administrative interfaces and command-line tools to monitor cluster health and manage members.
  • Machine Learning Model APIs - Integrates external code-based models into data pipelines for real-time inference on incoming records.
  • Vector Similarity Search - Stores and retrieves vector embeddings to enable high-performance similarity matching across distributed partitions.
  • JSON and Data Parsing - Enables extraction, transformation, and aggregation of JSON-formatted data using path expressions.
  • Queryable JSON Stores - Saves JSON values with embedded metadata to accelerate queries, or as raw strings to reduce memory and processing overhead.
  • JSON Processing - Extracts, transforms, and constructs JSON documents using path expressions and object builders.
  • Data Change Listeners - Triggers custom logic in response to data modifications within distributed structures to enable event-driven application behavior.
  • API to SQL Mapping - Maps external data sources to virtual tables to enable standard SQL queries against remote datasets.
  • Predicate-Based Filtering - Provides programmatic filtering of distributed map entries using boolean predicates for targeted data retrieval.
  • Asynchronous Write Buffering - Decouples high-frequency write operations from primary storage using buffers to improve performance for write-heavy workloads.
  • Atomic Distributed Values - Updates numeric values and object references atomically across a distributed environment.
  • Atomic Scalars - Updates long values and object references atomically across a distributed environment.
  • Data Pipeline Connectors - Moves data between internal pipelines and external systems like messaging queues and databases via built-in connectors.
  • Refresh-Ahead Caches - Optimizes performance and consistency by configuring intelligent caching policies including write-through, write-behind, and refresh-ahead.
  • Cache Eviction Policies - Manages memory consumption by automatically removing cache entries based on size, idle time, or time-to-live policies.
  • Caching Strategies - Synchronizes memory and persistent storage by optimizing data retrieval using write-through, write-behind, and refresh-ahead policies.
  • Cardinality Estimation - Implements the HyperLogLog algorithm to approximate the number of unique elements in a large data set.
  • Change Data Capture Streams - Captures and synchronizes real-time updates from external databases into the cluster for immediate processing.
  • Cross-Location Data Replication - Synchronizes data across geographically distant data centers to protect against site-wide failures.
  • Cluster Load Balancing - Redistributes data shards across cluster nodes to ensure even resource utilization and balanced storage during scaling events.
  • Complex Data Structure Stores - Supports storage of data in various distributed structures to ensure high availability.
  • Consistency Tuning - Adjusts the balance between data availability and consistency to reduce the likelihood of stale reads.
  • Cluster Backups - Creates automatic daily snapshots or manual point-in-time copies of cluster state to disk to ensure data durability and recovery.
  • Cross-Zone Data Distribution - Ensures high availability by placing partition backups in separate availability zones to prevent data loss during localized failures.
  • Calculated Query Attributes - Enables creating calculated fields for objects to support querying based on derived values.
  • Partial Data Accessors - Improves query performance by deserializing individual fields directly from binary data.
  • Statistical Aggregators - Provides built-in statistical aggregators to compute summary metrics like sums and averages across distributed datasets.
  • Data Backup Solutions - Applies a processing function to both primary and backup data copies to ensure consistency across the cluster.
  • Local Data Caches - Maintains local near-caches on clients to reduce network latency for read-heavy workloads.
  • Local Backup Reads - Allows reading data from local backup copies to reduce network requests and latency.
  • Data Consistency Models - Controls how updates propagate to backup replicas using synchronous acknowledgments for durability or asynchronous updates for performance.
  • Method Result Caches - Caches the output of expensive function calls in a distributed memory layer to avoid redundant execution.
  • Distributed Caches - Accelerates data access and reduces backend load by connecting application data layers to a distributed memory store.
  • Data Persistence Management - Configures data persistence and automates backup and restore operations for distributed clusters.
  • Streaming Data Cleaning & Enrichment - Looks up data from distributed maps or external services to augment incoming stream items.
  • Streaming Data Transformers - Applies stateless functions to input items to modify, filter, or expand datasets in streaming pipelines.
  • Data Ingestion Sources - Ingests data from diverse external systems including Kafka, MongoDB, and JDBC for batch or streaming processing.
  • MongoDB Connectors - Integrates MongoDB collections into processing pipelines for batch or stream-based data ingestion.
  • Unique Identifier Generators - Generates cluster-wide unique identifiers to ensure distinct entity identity across all nodes.
  • Data Partitioning - Distributes data backups across distinct logical groups to prevent data loss during infrastructure failures.
  • Data Partitioning Strategies - Configures how keys are mapped to specific cluster partitions using custom logic or routing rules.
  • Automatic Rebalancing - Provides automated adjustment of data distribution across cluster nodes to maintain uniform performance and storage balance.
  • Partition-Targeted Queries - Allows executing queries on specific cluster partitions to minimize network overhead and improve performance for localized data access.
  • Batch Processing Jobs - Processes finite datasets to perform repetitive tasks like report generation.
  • Data Ingestion Pipelines - Ingests data from in-memory maps into stream processing engines for real-time enrichment and analytics.
  • Data Stream Aggregators - Enables the construction of streaming data pipelines that perform real-time joins, sorts, and aggregations.
  • Data Item Filters - Applies transformation functions to each item in a stream to enrich or convert data structures.
  • Stream-Oriented Data Pipelines - Reads in-memory map contents as a source for real-time data processing and analytics pipelines.
  • Data Query Filters - Provides SQL-based filtering capabilities to retrieve specific data subsets from distributed clusters without transferring entire datasets.
  • Data Replication - Coordinates data synchronization across geographically distributed clusters with consistency checks and delta management.
  • Wide-Area Data Replicators - Protects against regional failures by copying data across wide area networks.
  • JSON - Extracts values using path expressions, creates JSON structures from SQL values, and aggregates results into JSON formats.
  • Data Sinking - Routes processed data from pipelines to local or remote storage systems using built-in connectors.
  • Custom Serializer Implementations - Implements specialized logic for converting objects to and from byte streams to optimize data storage formats.
  • External Schema Resolvers - Inspects external data structures to automatically detect column names and types.
  • Database Change Listeners - Triggers custom actions in response to additions, updates, or removals of entries within distributed data structures.
  • Data Storage Configurations - Defines custom storage settings, eviction policies, and backup counts for named data structures to ensure consistent performance.
  • Stream Lookup Joins - Enriches streaming data by joining with external key-value stores or databases within a pipeline.
  • Web Session Replication - Synchronizes session state across multiple application instances to ensure continuous user experience.
  • Disk-Persistent Data Structures - Periodically writes local map data to disk or persistent memory to enable full data recovery after a complete cluster shutdown.
  • Distributed State Persistence - Enables disk-based storage for distributed consensus groups to allow members to recover their data and rejoin groups after a restart.
  • Distributed Code Deployment - Distributes user-defined classes across cluster members to execute custom logic on distributed data.
  • Distributed Data Processing Frameworks - Redistributes data across cluster members to prevent processing bottlenecks.
  • Distributed Data Synchronization Systems - Persists distributed map entries to external SQL or NoSQL systems and loads data from them to ensure state consistency.
  • Distributed State Structures - Synchronizes shared data structures across multiple application instances to maintain consistent state.
  • Injectable Distributed Structures - Exposes distributed data structures as injectable beans to simplify dependency management.
  • Regional Replication - Synchronizes data between geographically dispersed regions to ensure availability and disaster recovery.
  • Table Co-location - Groups related data entries on the same cluster member to minimize network overhead for multi-point operations.
  • Distributed Shared Memory - Executes data operations against a shared memory space to maintain consistent state across a distributed system.
  • Distributed Data Filters - Executes queries to retrieve only matching records from cluster members instead of iterating over the full dataset locally.
  • SQL-like Queries - Uses SQL syntax to filter distributed map entries using standard operators and logical expressions.
  • Distributed State Persistence - Saves consensus subsystem data to stable storage to ensure that committed operations are recovered automatically following crashes.
  • Processor State Snapshots - Saves internal processor state to a distributed map during snapshot barriers to allow for recovery and consistency.
  • Entry Expiration Policies - Removes data entries after a specified period of time or inactivity to reclaim memory.
  • External Data Connectors - Writes processed data from the cluster to external storage or messaging systems using built-in connectors.
  • External System Synchronization - Maintains consistency with external databases by automatically writing changes and loading missing entries on demand.
  • External Data Importers - Ingests data from diverse external sources into processing pipelines using a library of standard connectors.
  • External Data Integrations - Connects to a wide range of external data sources to enrich processing pipelines with additional context.
  • External Source Mappings - Registers metadata about external data sources to enable querying remote datasets through a unified interface.
  • External Store Synchronizers - Synchronizes in-memory data structures with an external database by implementing custom storage logic to handle read and write operations.
  • External System Integrations - Integrates with third-party frameworks and systems using a library of standardized connectors.
  • Federated Data Gateways - Joins information from multiple disparate systems into a single result set to provide a unified view.
  • Federated Data Query Engines - Retrieves and joins information from multiple disparate datasets within a single request.
  • Composite Indexes - Supports composite indexes across multiple attributes to optimize complex query performance.
  • File-Based Data Ingestion - Reads data from local files, distributed file systems, and cloud storage using a unified interface for stream processing.
  • Distributed Job Snapshots - Saves data structures, streaming job snapshots, and metadata to disk to enable recovery after cluster restarts or failures.
  • Geographic Data Replication - Replicates data between different data centers or geographic regions to ensure availability and proximity.
  • Group-By Aggregations - Groups related events by a specific key to ensure consistent stateful aggregation.
  • Concurrent Read Access - Executes non-mutating logic on map entries without requiring locks, allowing concurrent access during write operations.
  • Compute-Only Members - Scale computationally heavy tasks without increasing data overhead by deploying specialized members that do not store data partitions.
  • Vector Stores - Maintains collections of vectors and associated metadata, allowing for key-based storage and retrieval of high-dimensional data points.
  • Write-Behind Change Tracking - Buffers updates to external data stores to reduce request frequency and improve performance by decoupling operations.
  • In-Place Data Modifiers - Executes custom logic directly on data entries within the cluster to minimize network traffic and improve performance.
  • Incremental Map Population - Loads large datasets from external systems using lazy iteration to distribute data across cluster members efficiently.
  • Inter-Node Data Synchronization - Protects against data loss by ensuring partition backups are stored on different physical or virtual nodes within the cluster.
  • JDBC Migration Engines - Reads records from relational databases using JDBC drivers with support for parallel execution across cluster members.
  • JSON Document Stores - Stores JSON data with associated metadata to enable high-performance querying and filtering of document fields.
  • Distributed JSON Wrappers - Wraps raw JSON strings into a specialized format to enable efficient storage and retrieval within distributed data structures.
  • Kafka Payload Deserializers - Integrates with distributed log stores to ingest and transform event streams using configurable serializers.
  • Key-Value Pair Managers - Stores and retrieves data objects in a shared, cluster-wide dictionary accessible to all connected clients.
  • Entry Removals - Supports deletion of specific entries from memory and external storage using various strategies.
  • Predicate-Based Deletions - Removes all map entries that match a specific predicate, ensuring data is purged from memory and external storage.
  • Predicate-Based Removals - Deletes all map entries that match a specific set of criteria defined by a predicate.
  • Map Entry Listeners - Triggers custom code when map entries are added, updated, or removed to enable event-driven application behavior.
  • Predicate-Based Processors - Executes a processing function across all map entries or a specific subset defined by a predicate.
  • Parallelized Ingestion - Distributes connector tasks across cluster nodes to parallelize ingestion and handle configuration changes.
  • Cluster Data Persistence - Saves in-memory data to local storage periodically to enable full cluster recovery after a planned or unplanned shutdown.
  • In-Memory Object Caches - Accelerates query performance by caching previously deserialized objects in memory.
  • Maximum Value Calculators - Calculates summary statistics including sums, averages, and counts across distributed data collections.
  • Operational Mode Controls - Restricts cluster activity by toggling modes that control member joining, data migration, and read-only access for maintenance.
  • Kubernetes Deployments - Orchestrates cluster node deployment and scaling within containerized environments using dedicated operators.
  • JSON Object Querying - Extracts and filters values from JSON strings using standard predicates and nested attribute navigation.
  • Optimistic Data Update Management - Updates shared values only if they match an expected state, providing a high-performance alternative to locking.
  • Ordered Collection Management - Stores distributed lists of elements that allow duplicates and preserve insertion order across a cluster.
  • Distributed Ordered Collections - Stores ordered sequences of data across a cluster for use in stream processing pipelines.
  • Distributed Ordered Lists - Stores ordered sequences of elements across a cluster for shared access while preserving insertion order.
  • Child Order Preservation - Enforces strict sequential processing for events sharing the same key to support stateful operations.
  • Late Event Thresholds - Configures a time threshold for incoming data streams to ignore events that arrive after a specified lag period.
  • External Cache Integrations - Synchronizes data from external systems into distributed maps to provide low-latency access to frequently used records.
  • Atomic Data Store Operations - Runs custom logic directly on the cluster member where data resides to perform atomic reads and updates without multiple network round-trips.
  • Pipeline Output Forks - Sends the results of a single processing stage to multiple destinations simultaneously for divergent storage or processing.
  • Primary-Replica Replication - Propagates updates from primary to backup partitions using synchronous or asynchronous replication and an anti-entropy mechanism.
  • Cached Query Data Updaters - Tracks map changes in real time and automatically updates a local cache of entries that match a predefined predicate.
  • Map Data Processors - Integrates in-memory data structures into processing pipelines to enable real-time analytics and data enrichment workflows.
  • Caching Implementations - Stores frequently accessed data across a cluster using a specification-compliant caching implementation.
  • Message Broker Connectivity - Stores connection metadata for databases and message brokers to facilitate unified data access.
  • Distributed Cluster Setups - Establishes secure, persistent links between application environments and remote data clusters for distributed operations.
  • Mutation Monitors - Maintains a historical journal of all mutation actions performed on map or cache data structures.
  • Mutation Streaming - Maintains a chronological journal of changes made to maps or caches to enable event streaming.
  • Replication Mode Configurators - Controls data durability by choosing between synchronous or asynchronous replication modes to balance latency against safety.
  • Set-Based Operations - Enables complex data evaluation using SQL operators, conditional expressions, and set operations.
  • Rolling Statistical Aggregators - Computes rolling aggregates over unbounded data streams to provide real-time analytical insights.
  • Object Schema Evolutions - Permits adding, removing, or changing fields in serialized objects while allowing different versions of the same class to coexist.
  • Distributed Data Indexing - Organizes distributed map data using indexing structures to accelerate query performance.
  • Partitioned Index Scopes - Provides partitioned indexing to eliminate concurrency contention on specific data stores.
  • SQL Metadata Persistence - Ensures database schemas and access definitions survive restarts by persisting SQL metadata.
  • SQL Data Source Mappings - Defines metadata about data models and access patterns to enable the SQL service to query specific sources.
  • Background SQL Executions - Supports running SQL statements in the background with state snapshots for reliable execution.
  • Optimized Query Plans - Parses and compiles SQL statements into reusable execution plans to accelerate the performance of recurring data processing tasks.
  • Stateful Processing Backends - Maps events with the same key to the same processing task to ensure consistent stateful aggregation.
  • Distributed Map Scanning - Supports programmatic filtering of distributed map entries using predicates, SQL-like expressions, or regular expressions.
  • Operation Interceptors - Modifies or cancels map actions synchronously before they complete, allowing for the alteration of values or behavior during get, put, and remove operations.
  • Storage Scaling - Automatically scales data storage capacity to maintain performance without manual intervention.
  • Elastic Data Redistribution - Dynamically adjusts data distribution across the cluster to handle volume growth and membership changes without downtime.
  • Stream Enrichment - Combines real-time event streams with static reference data stored in distributed maps to add context to processed records.
  • Stream Filters - Applies predicates to incoming stream items to selectively pass or drop data based on defined criteria.
  • Strategies - Directs data between processing stages using round-robin, isolated, or partitioned strategies to balance load and preserve event order.
  • Index-Accelerated Querying - Accelerates complex search operations using ordered, composite, and parallel indexing strategies.
  • Bitmap Indexes - Accelerates range, equality, and low-cardinality queries by organizing data fields using sorted, hash, or bitmap structures.
  • Message Order Enforcement - Configures whether messages are delivered to subscribers in the order they were published or in a globally consistent sequence.
  • Queue Offloading - Integrates a queue with an external datastore to archive items and prevent memory exhaustion by offloading data.
  • Bulk Update Processing - Writes multiple key-value pairs to a distributed map in a single operation to improve efficiency when synchronizing large datasets.
  • Bulk Map Update Operations - Copies multiple key-value pairs from a local store into a distributed map in a single operation to improve throughput.
  • Predicate-Based Filters - Applies processing logic only to map entries that match a specified predicate, allowing for targeted bulk updates or deletions.
  • Vector Embedding Indexes - Organizes vector data and associated metadata in a partitioned structure to facilitate high-performance similarity searches.
  • Vector Similarity Search - Performs similarity searches on vector collections using configurable distance metrics.
  • Vector Index Maintenance - Maintains search accuracy and memory efficiency by reorganizing vector indexes after data modifications.
  • External Table Querying - Maps external data stores to SQL tables to perform distributed queries and joins across datasets.
  • In-Memory Table Reconstruction - Maintains an up-to-date, queryable view of external database tables by applying incoming change records to distributed maps.
  • Cache Invalidation - Maintains eventual consistency by synchronizing local caches with cluster state through the removal of entries when underlying data is modified.
  • Client Configuration - Allows tuning of client performance and operational settings via programmatic configuration or environment variables.
  • External Platform Integrations - Transfers data between the cluster and third-party messaging or database systems using built-in integration components.
  • External Service Integrations - Provides connectors for invoking external HTTP services and machine learning models within data processing pipelines.
  • Stream Processing Job Submissions - Supports deploying processing pipelines using various interfaces including CLI and SQL.
  • Blocking Task Offloaders - Executes complex data transformations in separate thread pools to prevent blocking partition operations and maintain throughput.
  • Partition-Aware Task Executors - Increases throughput by offloading processing tasks while maintaining key locks on data partitions.
  • Remote Task Offloaders - Offloads computationally intensive tasks and event listeners to specialized cluster members that do not store data partitions.
  • Storage Operation Offloaders - Executes data store interactions on dedicated background threads to prevent blocking partition operations.
  • Background Job Processing - Executes data processing tasks independently of the client for continuous stream processing.
  • External Client Connections - Enables external clients to locate and join distributed clusters by authenticating with cloud service accounts.
  • Cloud Infrastructure Automation - Automates the provisioning and maintenance of remote cluster environments through command-line operations.
  • Managed Infrastructure Deployment - Provisions and maintains distributed infrastructure for stream processing and data storage without manual server management.
  • Cluster Management - Provisions, lists, and deletes remote distributed data clusters directly from the command line.
  • Cluster Capacity Enforcements - Restricts read and write operations to ensure a minimum number of cluster members are reachable during network partitions.
  • Cluster Lifecycle Management - Automates the creation, scaling, and recovery of distributed clusters within containerized environments.
  • Cluster Management APIs - Controls cluster state, manages members, and retrieves diagnostics using a standardized web API.
  • Workload Isolation - Prevents resource contention and ensures performance stability for critical jobs by deploying independent clusters for storage and computation.
  • Asynchronous Membership Joiners - Optimizes cluster membership by enabling asynchronous joining strategies.
  • Automated Node Discovery - Automatically detects cloud or container runtimes to configure member discovery without manual intervention.
  • Capacity Scaling - Allows dynamic scaling of cluster members to increase throughput linearly without downtime.
  • In-Cluster Update Executions - Avoids the overhead of moving entries between the cluster and the client by performing data modifications directly on the cluster nodes.
  • Distributed Instance Initializers - Initializes cluster members and clients with network and operational settings before startup.
  • Configuration Validation - Validates cluster configuration files against schemas during startup to prevent runtime failures.
  • Configuration Property Overrides - Allows overriding configuration parameters using environment variables or system properties.
  • Runtime Environment Variable Injections - Replaces placeholders in configuration files with values provided via system properties or environment variables.
  • Declarative Configuration Files - Allows specifying system settings using files to maintain consistent cluster behavior.
  • Programmatic Configuration Interfaces - Enables defining cluster settings and data structure configurations using programmatic code.
  • Elastic Scaling Deployments - Maintains cluster integrity and data safety during automated scaling events by managing member lifecycle in a controlled manner.
  • Cross-Cluster Data Synchronizers - Synchronizes data across multiple geographic locations to ensure high availability and disaster recovery.
  • Stream - Moderates data production rates at the source based on downstream processing capacity to prevent system overload.
  • Job Pause and Resume Controls - Supports suspending and resuming data jobs to facilitate maintenance and scaling.
  • Dynamic Configuration Updates - Modifies cluster settings and data structure definitions at runtime through APIs.
  • Graceful Shutdowns - Stops individual nodes gracefully by synchronizing partitions to ensure data integrity before termination.
  • Network-Required Job Execution - Prevents job execution on isolated cluster fragments by requiring a quorum of members during network partitions.
  • Stream Correlations - Joins keyed inputs and applies aggregate functions to combined grouped items in real-time streams.
  • Storage Cluster Deployment - Automates the deployment of distributed data clusters with support for elastic scaling and development storage configurations.
  • Job Execution Controllers - Restricts the execution of processing jobs to specific cluster members to optimize resource allocation.
  • Job Scheduling - Stops running jobs and captures state snapshots before termination.
  • Job Failure Suspension - Suspends jobs on failure to preserve computational state for configuration updates and manual resumption.
  • Job Cancellation - Allows immediate termination of active processing jobs with optional state snapshotting for recovery.
  • Kubernetes Cluster Deployments - Manages cluster configuration and lifecycle updates through custom resource definitions in containerized environments.
  • Kubernetes Cluster Management - Automates the deployment and scaling of distributed nodes using a dedicated operator for container orchestration.
  • Cluster Access Control - Provides role-based access control for cluster operations and client connectivity using external identity providers.
  • Database Cluster Deployments - Orchestrates distributed database clusters across containerized environments to ensure high availability and automated recovery.
  • Automated Partition Balancers - Ensures consistent performance by automatically redistributing data partitions across cluster members.
  • Data Partition Balancers - Provides automated data rebalancing across cluster nodes to maintain consistent performance and prevent hotspots.
  • Independent Data Services - Enables independent scaling and fault isolation by running the data platform as a separate service from the application.
  • Compute-Only Node Deployments - Allows adding members that do not store data partitions but provide additional CPU and memory for heavy task execution.
  • Execution Parallelism Tuners - Tunes thread counts for query processing and data aggregation to maximize throughput.
  • Linear Throughput Scaling - Increases processing throughput linearly by dynamically adding cluster members.
  • Regional Data Residency - Places data clusters in specific geographic regions to satisfy data residency requirements and minimize network latency.
  • Cluster Failover Managers - Configures automatic reconnection and failover strategies to ensure high availability.
  • Resource Placement - Allows assigning specific cluster nodes to handle compute or storage workloads independently.
  • Data Job Restarts - Enables restarting data jobs to rebalance workloads and apply scaling changes.
  • Runtime Configurations - Allows customization of cluster behavior through external configuration files and runtime adjustments.
  • In-Memory Queue Capacity Strategies - Limits the number of items in a queue and blocks producers when the threshold is reached to prevent memory exhaustion.
  • Serialization Versioning - Manages multiple versions of serialized classes to ensure compatibility between clients and cluster members.
  • Rolling - Updates cluster members sequentially by migrating partitions and restarting nodes to ensure service continuity during upgrades.
  • Round-Robin Load Balancers - Distributes events between parallel processing tasks using round-robin, isolated, or partitioned routing.
  • Workload Placement Policies - Enables targeting specific cluster nodes for processing jobs to isolate compute workloads.
  • Task Execution Placement Restrictions - Isolates workloads by assigning specific cluster members to execute processing tasks.
  • Zero-Downtime Deployments - Maintains mirrored clusters and automatically redirects client traffic to ensure seamless failover and maintenance.
  • Memory-Resident Data Access Strategies - Optimizes data access latency by implementing read-through, write-through, and write-behind strategies for memory-resident data.
  • Client Connectivity Management - Monitors client health through heartbeat checks and defines cleanup policies to release resources when clients disconnect.
  • Cluster Discovery Services - Automates the identification and connection of cluster nodes in cloud environments using metadata services.
  • Distributed Messaging Libraries - Facilitates low-latency communication between services using pub-sub and queue-based messaging patterns.
  • Publish-Subscribe Messaging - Distributes messages across a cluster using a publish-subscribe model for registered listeners.
  • Broadcast Messaging - Implements a publish-subscribe messaging model allowing applications to communicate at high speed via specific topics.
  • Connection Configurations - Configures network and discovery parameters to manage how applications interact with the distributed environment.
  • Consensus Group Sessions - Organizes members into multiple consensus groups to scale throughput and memory capacity.
  • Database Change Streaming - Streams real-time updates from external databases to maintain synchronized in-memory state.
  • Distributed Coordination Primitives - Provides distributed implementations of collections, concurrency primitives, and messaging channels for real-time coordination.
  • External Service Connectivity - Defines metadata and connection settings for external databases and message brokers to enable SQL-based access.
  • Cluster HTTP Interfaces - Executes operations on a distributed data cluster using standard HTTP requests to perform management tasks without client libraries.
  • Real-time Event Streams - Evaluates and identifies patterns in incoming data streams in real time to support event-driven analytics.
  • Persistent Connection Enablements - Maintains persistent connections to remote data grids to enable shared state and low-latency access.
  • Remote Service Clients - Provides multi-language client libraries for programmatic access to the distributed processing engine.
  • Service Discovery Integrations - Integrates with external service registries to coordinate member discovery in dynamic environments.
  • Lock-Free Atomic Containers - Processes map or cache entries using lock-free, partition-aware logic to perform efficient, high-concurrency data modifications.
  • Lock-Free Read Executions - Improve performance for non-mutating operations by executing logic on entries without acquiring locks or checking lock status.
  • Map Lifecycle Management - Clears or destroys distributed maps to reclaim memory and remove metadata when data is no longer required.
  • Whitelisted Deserialization - Restricts object instantiation during deserialization to trusted types to prevent malicious code execution.
  • Object Serialization - Implements custom binary serialization to bypass reflection and reduce metadata overhead for faster data transfer.
  • Collection Querying - Matches entries based on specific indices or using any semantics to find matching elements within nested lists or arrays.
  • Deserialization Filtering - Filters incoming data by class or package name to prevent the execution of untrusted code during deserialization.
  • Role-Based Access Control - Enforces role-based access control policies to manage permissions for cluster operations and data access.
  • Distributed Session Storage - Replaces local server session storage with a distributed data store to persist user session data across instances.
  • Named Cluster Isolation - Groups instances into named clusters via configuration to prevent interaction between different environments.
  • Permission-Based Access Control - Restricts SQL statement execution and connector management based on assigned security roles and permissions.
  • SQL Access Controls - Controls which users or clients can create connectors or execute specific SQL statements based on assigned security permissions.
  • Role-Based Access Control - Assigns permissions to authenticated clients based on roles to control data operations within the cluster.
  • Generic Record Interfaces - Allows manipulation of serialized data using a generic record interface without requiring original class definitions.
  • Distributed Consistency Snapshots - Captures global state of running pipelines using barrier markers to ensure consistent recovery points.
  • Asynchronous Event Dispatchers - Processes high-volume events asynchronously by dispatching them to shared thread pools with configurable queue capacities.
  • Asynchronous Operation Execution - Increases throughput by batching multiple asynchronous requests to manage operation limits and backpressure.
  • Configuration Persistence - Persists dynamic configuration changes to disk to ensure settings survive cluster restarts.
  • Distributed Object Mappings - Configures schema definitions for distributed objects to enable structured access and ensure consistent serialization formats.
  • Data Sync Conflict Resolution - Applies configurable merge policies to reconcile data differences between partitioned clusters.
  • Directed Acyclic Graph Engines - Executes data pipelines by decomposing transformation logic into a graph of stages that run in parallel across cluster members.
  • Distributed Object Identifiers - Enables efficient remote interaction with shared data structures by transmitting object identifiers across the cluster.
  • Distributed Counters - Increments and decrements counter values across multiple instances and propagates updates to all replicas.
  • Distributed ID Generators - Generates cluster-wide unique identifiers and maintains atomic numeric values synchronized across all instances.
  • Distributed Key-Value Stores - Sets memory formats, backup counts, and eviction policies for key-value stores using named configurations.
  • Distributed Task Queues - Facilitates asynchronous event processing between cluster members using distributed queues with configurable timeouts.
  • Event Stream Merging - Combines multiple streaming data sources using joins and co-grouping to enrich and unify disparate event streams.
  • Stream Merging - Provides logic for interleaving multiple streaming data sources into a single unified output stream.
  • Custom Eviction Logic - Allows defining specialized logic for selecting which data entries to remove when memory limits are reached.
  • User Code Namespace Isolation - Groups classes and artifacts into named namespaces to ensure resource isolation and manage dependencies for distributed business logic.
  • External Framework Integrations - Exchanges data in real time with third-party applications and frameworks using dedicated connectors.
  • Stream Processor State Persistence - Saves internal processor state to a distributed map when snapshot barriers are received to enable fault-tolerant processing.
  • Duplicate Removal - Suppresses duplicate entries from batch or windowed unbounded streams.
  • Dependency Injection - Enables the use of standard dependency injection patterns within distributed objects and tasks.
  • Runtime - Registers user-defined classes for data processing tasks at runtime.
  • Clustered Task Distribution - Distributes and manages computational tasks across cluster members to maximize throughput and locality.
  • Parallel Processing Pipelines - Executes pipeline stages across multiple parallel tasklets to balance CPU load.
  • Thread-Per-Core Architectures - Maximizes throughput by mapping tasks to threads pinned to specific CPU cores to reduce context switching.
  • Distributed Job State Replicators - Maintains fault-tolerant job state by storing snapshots in distributed, replicated in-memory maps.
  • Stream Mapping and Flattening - Transforms stream elements into new streams and merges them using flatMap operations.
  • Stream Value Mapping - Applies functional mapping to transform each input item into a new output item within a stream.
  • Network I/O Thread Pools - Optimizes cluster throughput by configuring dedicated thread pools for network data operations.
  • Cluster Management Tools - Provides centralized command-line tools to monitor, configure, and orchestrate distributed deployments.
  • REST Management APIs - Controls cluster state, manages members, and retrieves diagnostic metrics through a web API.
  • Distributed Data Inspections - Provides tools to query and validate raw data stored in distributed maps for debugging application state.
  • External Data Source Integrations - Connects to various external systems and formats, supporting the creation of custom connectors via APIs.
  • Monitoring and Observability - Supports native integration with third-party observability platforms for centralized alerting and visualization.
  • Metric and Performance Monitors - Visualizes real-time metrics for members, clients, and data structures to identify bottlenecks.
  • Cluster Monitoring Systems - Collects and exposes internal performance diagnostics and operational telemetry to track cluster health.
  • Prometheus Metrics Exporters - Exposes cluster statistics via Prometheus, JMX, and REST endpoints for integration with enterprise monitoring systems.
  • Memory Eviction Policies - Provides configurable eviction policies to manage memory usage and prevent exhaustion in distributed data structures.
  • Cluster Version Updaters - Triggers automated cluster-wide version updates once all members meet the required criteria.
  • Cluster Status Notifications - Registers listeners or queries the cluster to receive notifications regarding split-brain protection events.
  • Stream Performance Monitoring - Tracks performance metrics and execution status for distributed stream processing jobs.
  • Streaming Execution Visualization - Visualizes streaming job execution plans using directed acyclic graphs to manage job lifecycles.
  • System Setting Configurations - Supports overriding default application settings via environment variables or system properties.
  • Programmatic Data Query APIs - Uses a programmatic predicate API to perform ad-hoc or batch lookups on distributed map entries.
  • Desktop Entry Mapping - Removes specific entries from memory or linked external storage based on the desired level of erasure.
  • Data Structure Change Listeners - Triggers custom logic in response to add, update, or remove operations performed on replicated data structures.
  • Time-To-Live Expirations - Attaches specific time-to-live values to individual data entries to manage data lifecycle at the record level.
  • Data Collection - Registers callbacks to react in real-time to lifecycle events within distributed data collections.
  • Job Status Monitoring - Tracks the real-time execution status and history of distributed data processing jobs.
  • Multi-Source Combiners - Merges or enriches data from disparate streaming and batch sources using join or union operations within a pipeline.
  • Data Pipelines and Orchestration - Real-time data platform combining stream processing with fast storage.
  • Databases and Storage - In-memory data grid for distributed computing.
  • Distributed Systems - Scalable in-memory data grid.

    • Star history

    Star history chart for hazelcast/hazelcastStar history chart for hazelcast/hazelcast

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does hazelcast/hazelcast do?

    Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to support real-time analytics and event-driven applications. It functions as a partitioned, distributed key-value store that replicates data across cluster nodes to provide low-latency access and high availability. The platform also serves as a distributed SQL query engine, allowing users to execute standard SQL statements against both in-memory datasets and…

    What are the main features of hazelcast/hazelcast?

    The main features of hazelcast/hazelcast are: Distributed Key-Value Stores, Distributed Consensus Stores, Distributed Data Platforms, Caching and Key-Value Stores, Cluster Member Status and Information Listing, Distributed Atomic Operations, Change Data Capture, Distributed Data Replication.

    Which projects share features with hazelcast/hazelcast?

    Projects with overlapping indexed features include: olric-data/olric — Olric is a distributed data grid and in-memory key-value store that partitions and replicates data across a cluster of… apache/pinot — Pinot is a distributed, columnar analytical database designed for high-concurrency, low-latency query processing. It… apache/ignite — Ignite is a distributed in-memory data grid and compute platform. It functions as a distributed SQL database and… apple/foundationdb — FoundationDB is an ACID-compliant distributed transactional key-value store. It functions as a scalable database… zhisheng17/flink-learning — This project is a collection of educational resources and reference implementations for the Apache Flink stream… vonng/ddia — This project serves as a comprehensive technical reference for the architecture and design of data-intensive…

    Projects sharing features with Hazelcast

    These projects share indexed features with Hazelcast. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • olric-data/olricolric-data avatar

      olric-data/olric

      3,469View on GitHub↗

      Olric is a distributed data grid and in-memory key-value store that partitions and replicates data across a cluster of servers. It serves as a shared memory system for managing distributed maps, performing atomic operations, and acting as an in-memory data cache. The system provides a distributed locking mechanism for concurrency control and a pub-sub messaging system that broadcasts and routes messages over named channels across the cluster. The platform covers wide-ranging capabilities including cluster management and orchestration, data replication with configurable quorums, and automated

      Gocachedatabasedistributed-cache
      View on GitHub↗3,469
    • apache/pinotapache avatar

      apache/pinot

      6,098View on GitHub↗

      Pinot is a distributed, columnar analytical database designed for high-concurrency, low-latency query processing. It functions as a real-time OLAP datastore, enabling interactive, user-facing analytics by ingesting and querying massive datasets from both streaming and batch sources. The system architecture relies on a centralized controller for cluster coordination and a distributed segment-based storage model to ensure horizontal scalability. The platform distinguishes itself through a hybrid ingestion pipeline that unifies real-time event streams and historical batch data into a single quer

      Java
      View on GitHub↗6,098
    • apache/igniteapache avatar

      apache/ignite

      5,066View on GitHub↗

      Ignite is a distributed in-memory data grid and compute platform. It functions as a distributed SQL database and storage engine designed to store and process large datasets in RAM to minimize latency and increase calculation speed. The system is distinguished by a multi-tier storage engine that manages data placement across memory and disk to balance high-speed access with large capacity. It features a distributed compute grid that executes custom logic directly on the nodes where data resides to reduce network traffic. The platform provides a broad set of capabilities including ACID transac

      Javabig-datacachecloud
      View on GitHub↗5,066
    • apple/foundationdbapple avatar

      apple/foundationdb

      16,446View on GitHub↗

      FoundationDB is an ACID-compliant distributed transactional key-value store. It functions as a scalable database engine that ensures strict serializability and data consistency across a cluster of servers using a shared-nothing architecture. The system is distinguished by its multi-region replication capabilities, allowing data to be synchronized across different datacenters for high availability and disaster recovery. It utilizes optimistic concurrency control to manage distributed transactions and employs a majority-based coordination system to maintain cluster state. The platform provides

      C++aciddistributed-databasefoundationdb
      View on GitHub↗16,446
    Compare all 30 related projects→