akkadotnet/akka.net

Features

• Actor Models - Provides a complete framework for building concurrent and distributed applications using isolated actors and asynchronous messaging.
• Distributed Actor Frameworks - Provides a comprehensive framework for building concurrent and distributed applications using the actor model.
• Distributed Systems Architectures - Provides a framework for building high-availability, asynchronous distributed applications using the actor model.
• Remote Actor Spawning - Creates actor instances on remote systems across a network using configurable deployment strategies.
• Distributed Computing Platforms - Offers a distributed computing platform managing actor clusters with location transparency and P2P communication.
• Log State Recovery - Restores actor system state by replaying committed event logs or loading point-in-time snapshots.
• Gossip Protocols - Uses a decentralized gossip protocol to maintain cluster membership and detect node failures.
• Cluster Membership Protocols - Tracks active nodes and removes dead ones using a decentralized gossip protocol to maintain cluster state.
• Self-Healing Infrastructure - Organizes actors into supervisor trees that automatically detect and resolve failures to maintain system availability.
• High Availability Clustering - Coordinates server nodes in a cluster to ensure continuous service availability and fault tolerance through dynamic scaling.
• Hierarchical Failure Responses - Defines a supervision hierarchy where parents manage child failures through specific restart and escalation policies.
• Distributed Actor Workload Scaling - Scales processing power by distributing messages across a cluster of nodes using sharding and adaptive routing.
• Distributed State Management - Manages distributed state across a cluster using sharding and dynamic rebalancing for high availability.
• Location Transparency - Enables location-transparent communication, allowing messages to be sent to actors via logical IDs regardless of physical location.
• Asynchronous Messaging - Implements asynchronous message passing through mailboxes to ensure thread-safe state management without manual locks.
• Lock-Free State Management - Manages shared state across threads using asynchronous message passing instead of manual synchronization primitives.
• Concurrent Task Execution - Manages parallel execution through message passing to remove the need for manual locks and thread management.
• Abstract Actor Addressing - Routes messages to actors across multiple nodes without requiring the caller to know the physical address of the target.
• Event Sourcing - Provides a full event sourcing engine that persists actor state as an immutable sequence of events for recovery.
• Fault Tolerance Implementation - Implements a fault-tolerant supervision system that organizes components into self-healing hierarchies.
• Actor Sharding - Manages the placement of actors across multiple nodes using logical identifiers to ensure high availability and scalability.
• Lock-Free State Management - Processes messages in a first-in-first-out order to ensure internal state remains thread-safe without synchronization locks.
• Message Passing Systems - Implements mechanisms for decoupling components through asynchronous, thread-safe message passing.
• Self-Healing Architectures - Implements self-healing system design using supervisor trees to automatically detect and restart crashed actors.
• Append-Only Event Logs - Provides a mechanism to persist internal actor state changes as an append-only log of events to ensure recovery after crashes.
• Supervisor-Based Recovery - Organizes actors into supervisor trees that automatically detect failures and execute self-healing restart strategies.
• Process Supervision - Organizes actors into hierarchies where parents monitor child health and execute restart or stop strategies.
• Dynamic Workload Rebalancers - Dynamically moves groups of actors between nodes during membership changes to ensure even load distribution.
• Message Routing Strategies - Implements routing strategies like round-robin to distribute messages among actors and balance load.
• Stream Processing - Provides specialized streaming abstractions to handle continuous flows of data or live network signals.
• Sharded Actor Persistence - Assigns unique persistence identifiers to sharded actors to ensure state recovery after they move or are recreated.
• Event Stores - Includes persistence mechanisms designed to retrieve sequences of events from a journal to populate read-side databases.
• Read Model Projections - Transforms persisted events into alternative datastores using reactive streams to create materialized read views.
• Real-Time Data Streaming - Provides reactive stream abstractions for processing continuous flows of events and live signals.
• Actor Instance Restoration - Tracks running actors during restarts or rebalances and automatically recreates them to maintain system state.
• Cluster Membership Coordination - Tracks active node instances and manages peer discovery via heartbeats in a distributed cluster.
• Distributed Leader Election - Provides mechanisms for electing a cluster leader to coordinate consistency and administrative duties.
• Load Balancing - Employs architectural patterns for distributing traffic across nodes to maintain system elasticity and eliminate single points of failure.
• Actor Location Resolution - Retrieves the current physical address of a specific actor within a distributed cluster.
• Node Failure Detection - Identifies failing nodes through heartbeat monitoring and cluster consensus to trigger recovery.
• Peer-to-Peer Networking - Enables construction of decentralized networks of applications to eliminate single points of failure.
• At-Least-Once Delivery Guarantees - Ensures that messages sent between actors are delivered at least once through acknowledgments and retries.
• Remote Actor Transports - Ships configurable network transport layers to enable transparent communication between actors in different processes.
• Node-Aware Routing - Distributes tasks across a cluster using routers that update target lists based on node availability.
• Exponential Backoff Retries - Implements exponential backoff strategies for restarting failed components to avoid overloading resources.
• Consistent Hashing - Implements consistent hashing to partition actors across a cluster, ensuring balanced workload and state distribution.
• Group Recovery Coordination - Coordinates recovery by applying directives to failed components and their siblings based on system interdependencies.
• Event Log Projections - Transforms persisted event logs into materialized read views using asynchronous data streams for efficient querying.
• Actor Frameworks - Port of the Akka actor framework.
• Distributed Computing - Port of the actor-based distributed framework.
• Application Frameworks - Toolkit for building concurrent, distributed actor-based systems.

Star history