Actor-based message-driven runtime

Akka is an actor-based message-driven runtime for managing concurrency, elasticity and resilience on the JVM with support for both Java and Scala.

In Akka, the communication between services uses messaging primitives that optimize for CPU utilization, low latency, high throughput and scalability—hardened from years of contributions from the open source community.

Akka embraces the reality of unplanned errors and adopts a pragmatic “Let It Crash” philosophy using supervision and self-healing to ensure impacted components are reset to a stable state and restarted upon failure.

We're delivering the future of money to over 148 million people worldwide with Akka.


and Capabilities

Based on the actor model

The actor model provides a higher level of abstraction for writing concurrent and distributed systems. It alleviates the developer from having to deal with explicit locking and thread management, making it easier to write correct concurrent and parallel systems.

Distributed by default

Everything in Akka is designed to work in a distributed setting: all interactions of actors use purely message passing and everything is asynchronous. This ensure that all functions are available equally when running within a single process or on a cluster of hundreds of machines.

Built-in supervision

Actors form a tree with actors being parents to the actors they've created. As a parent, the actor is responsible for handling its children’s failures (supervision), forming a chain of responsibility.

Resilient self-healing

When an actor crashes, its parent can either restart or stop it, or escalate the failure up the hierarchy of actors. This enables a clean set of semantics for managing failures in a concurrent, distributed system and allows for writing highly fault-tolerant systems that self-heal

Focus on business logic

With Akka, business logic is driven through message-based communication patterns that are independent of physical locations. Whether your actors live on the same thread, a different machine—the semantics are the same. You focus on the business logic while Akka handles the lower level plumbing.

Ideal for cloud

Stateless, asynchronous, and location transparent, Akka is ideally suited for hybrid cloud architectures and the elastic scaling of cloud platforms. In an experiment with Google, it only took 4 minutes to start a 1000 node Akka cluster on Google Compute Engine (GCE), which included the time to start the GCE instances.

Easier modernization migration

Industry analyst Forrester notes it’s possible to map an entity model to actors in a relatively straightforward way, then replace function calls with messages to transform legacy applications.

Integration with back pressure

Akka Streams provides streaming integration with back pressure to ensure nothing crashes or drops when maximum throughput is reached.

Subscription for monitoring

An annual subscription to Lightbend Reactive Platform includes expert instrumentation for monitoring Akka. The agent-based approach understands streams, flows, futures, and traces and integrates with existing visualization solutions.

Subscription for advanced healing

Network partitions are inevitable when running distributed systems. An annual subscription to Lightbend Reactive Platform enhances Akka cluster resilience and prevents data loss with predefined resolution strategies for recovering unreachable nodes during network partitions.