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.

Message-driven Runtime for 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.

We're delivering the future of money to over 148 million people worldwide. Using Scala and Akka, we can rapidly develop, test, and deliver services that are reliable and performant at massive scale.
- PayPal

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 Lightbend 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.

Learn how to leverage Akka actors on .NET and Mono here.


To get started with Akka, we recommend checking out the following resources:

Akka Code Samples & Tutorials

Hello Akka Activator Template

Akka is a toolkit and runtime for building highly concurrent, distributed, and fault tolerant event-driven apps. This simple application will get you started building Actor based systems in Java and Scala. This app uses Akka 2.2, Java 6, Scala 2.10, JUnit, and ScalaTest.


Hello Akka (Java 8) Activator Template

This simple Akka application uses Java 8 and Lambdas for a concise Reactive programming model with Actors.


Reactive Stocks Activator Template

The Reactive Stocks application uses Java, Play Framework, and Akka to illustrate a reactive app. The tutorial in this example will teach you the reactive basics including Reactive Composition and Reactive Push.


Akka Reading Materials

DZone Refcard for Akka

This Refcard covers theoretical issues briefly, then dives in to defining and creating actors and messages, actor hierarchies, fault-tolerance and self-healing, and more.


Akka In Action

Akka in Action is a comprehensive tutorial on building message-oriented systems using Akka. The book takes a hands-on approach, where each new concept is followed by an example that shows you how it works, how to implement the code, and how to (unit) test it.


Reactive Design Patterns

Reactive Design Patterns is a clearly-written guide for building event-driven distributed systems that are resilient, responsive, and scalable. Written by the authors of the Reactive Manifesto, this book teaches you to apply reactive design principles to the real problems of distributed application development.


Jonas Bonér on Reactive Systems Anti-Patterns

InfoQ asked Jonas Bonér, Lightbend CTO and original author of the first Reactive Manifesto, some questions about his vision of “Reactive” applications. Jonas offered his thoughts about both desirable features of reactive applications and what is not reactive programming.


Akka Videos & Webinars

Deep Dive into the Lightbend Reactive Platform - Akka and Scala

In this episode of the "Deep Dive in to the Lightbend Reactive Platform" series, Nilanjan Raychaudhuri walks you through building Reactive apps with Akka and Scala. He will expand on both projects and outline how they support the Lightbend Platform.


Tuning and Monitoring Akka

Jan and Alex show how they measured and tuned an actor system and a Play Framework application in a major financial services organization. The talk explores the challenges of monitoring mission-critical systems, especially under heavy load. Presenters show the driving principles of finding out what Akka and Play actually do, and how to ideally design and tune your code.


Intro To Akka Persistance

Patrik Nordwall hosts "Intro To Akka Persistence." Akka Persistence is a new module in Akka 2.3 that adds actor state persistence and at-least-once message delivery semantics to Akka.


Introducing Reactive Streams

In this webinar, Roland Kuhn presents Reactive Streams, showing you how to handle data flow the right way!


Akka Success Stories

Sub 20ms Response - Ticketfly

Ticketfly crafted a powerful reserved seating engine (something that is notoriously complicated to build because of its rapidly changing state), that could scale easily, handle bursty and unpredictable traffic patterns and compete with online ticket scalpers. The Reactive non-blocking system allows visitors to find and allocate seats, under load, in less than 20ms. The system has very good performance without having to try very hard to achieve it.


75% Faster - Lucidchart

Lucidchart is a fully functional diagramming application running inside the browser, which uses pure Javascript to create an experience that feels like a native app. Moving to Reactive is already paying off. Response times are down for processor intensive code - such as image and PDF generation – by around 75%.


1000 node 2400 Akka Cluster In 4 Minutes - Google

Lightbend has been working together with the Google Cloud Platform team to test our Akka Cluster on Google Compute Engine. The goal was to push our runtime to its limits and gain insight into how to scale systems on this platform. The results are jaw dropping—reaching 2400 nodes as well as starting up a 1000 node cluster in just over four minutes.


100x Bursty Traffic Increase - Gilt Groupe

Over the course of a few seconds, Gilt’s traffic can increase by as much as 100x. Essentially, they need to have the e-commerce infrastructure almost at Amazon scale for at least 15 minutes every day. Most days this happens exactly at noon EST, and until a couple of years ago, noon was a stressful time every day. Nowadays it’s usually a non-event—in part because of Lightbend. This Q&A with architect Eric Bowman describes Gilt Groupe's journey from Rails to Reactive.


Here are some additional ideas on how to get started:

Visit the Lightbend Resource Center
Read the full documentation
Visit the community website
Follow Akka on Twitter
Participate on Stack Overflow
Join the Mailing List
Contribute at GitHub


Ensure the Success of Your Akka Application

If you plan to develop a commercial application, your business could benefit from a relationship with Lightbend. The Lightbend annual subscription program is designed to mitigate risk and ensure the successful launch and operation of your application by delivering certified builds and amazing service throughout the entire project lifecycle—from prototyping to production.

Get In Contact with Lightbend
  • Report

    Going Reactive 2016

    How Microservices & Fast Data are driving adoption of Reactive systems

    Get Report
  • Video

    How is Typesafe Reactive

    Learn how Typesafe technologies are Reactive

    Watch Now
  • White Paper

    Microservices In Production

    What Ops Should Know About Reactive Systems

    Get White paper