<img height="1" width="1" src="https://www.facebook.com/tr?id=1076094119157733&amp;ev=PageView &amp;noscript=1">

Build Powerful, Distributed Software with Ease

Akka is the ideal runtime for building reactive applications on the JVM. Imagine building concurrent, distributed applications with ease and confidence. Akka, and the Actor model, ensures entire systems are not brought down by failures, but rather heal and adapt on their own. Akka decouples business logic from low-level mechanisms such as threads, locks and non-blocking I/O, and liberates developers from the hariest challenges of managing the state and location of services.

Reactive Applications

Akka is an Actor-based runtime for managing concurrency, elasticity and resilience on the JVM with support for both Java and Scala. In Akka, the communication between services is a first-class citizen, with messaging primitives that optimize for CPU utilization, low latency, high throughput and scalability (hardened from years of contributions from the open source community).

From its earliest origins powering high volume financial services environments, Akka’s footprint has grown across online gaming, retail/e-commerce, media and every major industry. Today, Akka is also highly leveraged in Internet of Things applications, where fine-grained failure management and messaging between microservices are table stakes for production deployments.

Message-Driven Runtime is the Foundation to Reactive Applications

In Akka, your 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, or a different datacenter—the semantics are the same. You focus on the business logic while Akka handles the lower level plumbing to give your applications Reactive characteristics:

Resilience is a core tenet of Reactive applications, yet is often the most overlooked. With Akka, you get resilience for free as part of the model. Akka provides fault-tolerance based on supervisor hierarchies. Every Actor can create other Actors, which it will then supervise, making decisions if they should be resumed, restarted, retired or if the problem should be escalated. Instead of trying all things possible to prevent an error from happening, this approach lets you embrace the reality of unplanned errors. It means you can adopt a pragmatic ‘Let It Crash’ philosophy, with the confidence that the impacted components will be reset to a stable state and restarted upon failure.

Simpler Concurrency
Threads and non-blocking I/O are complex and error-prone to build by hand, which means they waste your time. With Akka's implementation of the Actor concurrency model, you are freed to focus on your application's business logic and let Akka think about scaling up.

Scalability and Elasticity
Scale out on multicore servers and multiple nodes using Akka makes application elasticity and true scale on demand a reality. On commodity hardware, you might run several million Actors—a huge step up from mere thousands of threads in a traditional Java application.

Scala & Java APIs
In keeping with the pragmatism of the rest of the Typesafe Reactive Platform, Akka has a APIs for both Java and Scala. This means smooth interoperability, and no need to learn or adopt Scala at all. Akka can run standalone on a JVM or deployed in your existing Java Application Server.

Use Akka on the .NET Framework & Mono
The power of Akka is now available to developers wanting to build with the .NET Framework on both the CLR and on Mono. Offering full C# and F# support, the Akka.NET project is production-ready with stable APIs.

The Benefits

  • Simple Concurrency & Distribution
  • Resilient by Design
  • High Performance
  • Elastic & Decentralized
  • Extensible

Key Info

  • TBC
  • TBC
  • TBC
  • TBC
  • TBC
  • TBC

Latest Blogs MORE BLOGS>