Cloud Parts

Akka

The JVM toolkit that brought Erlang-style actors, clustering and sharding to Java and Scala; source-available since 2022, with a paid licence for most production use.

What it is
Actor model
Type
Commercial product
Made by
Akka (Lightbend, Inc., doing business as Akka)
License
Business Source License 1.1 since 2.7 (October 2022): free outside production, and each release becomes Apache 2.0 three years after it ships; Apache 2.0 up to 2.6.x
Facts checked
6 October 2026
Website Source code

What it is

An Akka application is one or more JVMs, each running an ActorSystem: a thread pool that drives many lightweight actors, each with a mailbox and a behavior that handles one message at a time. Actors form a tree, and a parent supervises its children, restarting or stopping one that fails. Akka Cluster joins the JVMs into one membership group, and Cluster Sharding spreads entity actors by ID over the nodes, so cart-4812 runs in exactly one place and every message for it is routed there. Akka Persistence stores each entity’s events or state in a database (PostgreSQL through R2DBC, Cassandra, DynamoDB, JDBC) and replays them when the entity starts on another node. Around the core sit Akka Streams, Akka HTTP, Akka gRPC, Projections and the Alpakka connectors, including Kafka. Messages between actors are delivered at most once, in order per sender and receiver.

Every module has been under the BSL 1.1 since Akka 2.7: you may read, change and run the code outside production, but production needs a commercial licence. Since 2.10 (and patch releases 2.9.6, 2.8.7 and 2.7.1) that is enforced by a licence key: without one, the ActorSystem shuts itself down after 15 minutes. Keys are free for evaluation (45 days), open-source projects, academia and organisations under $25 million in annual revenue or operating budget; everyone else needs a subscription. There’s no public price list; the licence FAQ, checked October 2026, says paid subscriptions start at $0.25 per core hour. Since Akka 23.10 the jars come from Akka’s own repository through a tokenized URL rather than Maven Central. In November 2024 Lightbend renamed itself Akka and added the Akka SDK and managed hosting; the open-source fork of Akka 2.6, with a side-by-side comparison, is on the Apache Pekko page.

Why teams pick it

  • Over 15 years of production use, with typed actor APIs for both Java and Scala and thorough documentation
  • Cluster Sharding, Persistence and Projections give each entity one writer, in-memory state and a durable event log, without hand-built locking
  • Features added since the 2022 fork, such as Replicated Event Sourcing over gRPC for active-active entities across regions and Akka Edge, aren’t in any released Pekko 1.x version; Pekko ports Akka code only once it turns Apache 2.0
  • A wide set of modules from one vendor: Streams with backpressure, HTTP, gRPC, Kafka and other connectors, Kubernetes cluster bootstrap
  • Commercial support, security patches and an optional higher-level SDK with managed hosting

Watch out for

  • Not open source by the OSI definition until each release turns three years old; production use needs a licence key, organisations above $25 million in revenue must pay, and prices aren’t published
  • A missing or expired key stops the ActorSystem after 15 minutes, and builds need Akka’s tokenized repository, so CI, mirrors and air-gapped builds need extra setup
  • The actor model is a steep climb: at-most-once delivery, versioned serialization of messages and events, cluster membership and split-brain handling all need care
  • JVM only; other languages talk to it over HTTP, gRPC or Kafka
  • Apps built on the libraries can’t move to Akka’s managed Serverless or BYOC environments, which run only Akka SDK services; the company now markets itself as an agentic AI platform

Alternatives

What all actor model have in common →
Apache PekkoOpen sourceThe Apache-licensed fork of Akka 2.6: actors, cluster sharding, persistence, streams and HTTP for Java and Scala, run by a foundation instead of a company.celldBetaOpen sourceA self-hosted, distributed implementation of Cloudflare Durable Objects that runs an unchanged Workers app across your own machines, with its durable state in an object storage bucket you own.Durable ObjectsCommercialSingle-threaded JavaScript objects on Cloudflare’s network, each with a globally unique name and its own private SQLite database, that any Worker can call to coordinate state.+1 Cloudflare Agents SDK

How it fits with other technologies

A three-node Akka Cluster on Kubernetes that finds its peers through the Kubernetes API · yaml

# application.conf (HOCON) in the image sets:
#   akka.management.cluster.bootstrap.contact-point-discovery.discovery-method = kubernetes-api
#   akka.license-key = ${?AKKA_LICENSE_KEY}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: carts
spec:
  replicas: 3
  selector:
    matchLabels: { app: carts }
  strategy:
    rollingUpdate: { maxSurge: 1, maxUnavailable: 0 }  # one node at a time; shards move off it
  template:
    metadata:
      labels: { app: carts }
    spec:
      containers:
        - name: carts
          image: registry.example.com/carts:1.8.0
          ports:
            - { name: management, containerPort: 8558 }  # Akka Management: bootstrap, health
            - { name: remoting, containerPort: 25520 }   # Artery: messages between nodes
            - { name: http, containerPort: 8080 }
          readinessProbe: { httpGet: { path: /ready, port: management } }
          livenessProbe: { httpGet: { path: /alive, port: management } }
          env:
            - name: AKKA_CLUSTER_BOOTSTRAP_SERVICE_NAME  # peers are pods with the same app label
              valueFrom: { fieldRef: { fieldPath: "metadata.labels['app']" } }
            - name: AKKA_LICENSE_KEY
              valueFrom: { secretKeyRef: { name: akka-license, key: key } }
---
# let the pods list each other through the API server
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata: { name: pod-reader }
rules:
  - { apiGroups: [""], resources: [pods], verbs: [get, watch, list] }
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata: { name: read-pods }
subjects: [{ kind: ServiceAccount, name: default }]
roleRef: { kind: Role, name: pod-reader, apiGroup: rbac.authorization.k8s.io }

Akka libraries or the Akka SDK#

Since Akka 3 (November 2024) the company sells two ways to build on Akka. The SDK is built on the libraries, and services made with either can exchange events and messages.

Akka librariesAkka SDK
What you writeActors, streams, cluster and persistence setup, with full control over eachA fixed set of components: event-sourced and key-value entities, views, workflows, HTTP, gRPC and MCP endpoints, consumers, timed actions and AI agents
LanguagesJava and ScalaJava
Where it runsWherever you deploy it; you operate itLocally, self-hosted on Kubernetes, or in Akka’s managed Serverless or BYOC (your VPC on AWS, Google Cloud or Azure) environments
LicenceBSL 1.1 with a licence key in productionBSL 1.1
SuitsCustom protocols, embedded actors, existing Akka code, fine control over clusteringNew services where the opinionated structure and managed operations are worth the lock-in
  • Akka recommends the SDK for new projects; there is no automated way to convert a libraries app to it.

When each Akka release becomes Apache 2.0#

Each release’s LICENSE file names its own change date, three years after that release shipped. Later patch releases of the same line get later dates.

ReleaseReleasedApache 2.0 from
2.6.x2019 to June 2023 (2.6.21)Always Apache 2.0
2.7.0October 2022October 2025
2.8.0March 202316 March 2026
2.8.4August 202315 August 2026
2.9.0October 202323 October 2026
2.10.0October 202416 October 2027
2.10.23 (latest)September 202630 September 2029
  • Akka checks the build date at startup and skips the licence-key check for builds more than three years old.

See it in a real stack

No architecture uses Akka yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2009–2025

By 2009 Scala was attracting server developers, but concurrency on the JVM still meant threads sharing memory behind locks. Jonas Bonér, a Swedish programmer, wanted the Erlang approach on the JVM: lightweight actors, asynchronous messages and supervisors that restart what fails. He started Akka in February 2009 and tagged version 0.5 that July. The name comes from a mountain in Swedish Lapland and a Sámi goddess, and the letters also stand for Actor Kernel.

Akka 1.0 arrived in February 2011 with location-transparent actors for Scala and Java. That May, Bonér and Scala’s creator Martin Odersky launched Typesafe to sell support for both; it was renamed Lightbend in 2016. Akka grew clustering, persistence, streams and HTTP, and projects such as Play and Apache Flink built on it.

In September 2022 Lightbend moved Akka from Apache 2.0 to the BSL, starting with 2.7, arguing that large companies relied on it while a small company carried the maintenance. Users who wanted to stay on open source forked 2.6 as Apache Pekko. In November 2024 Lightbend renamed itself Akka and launched Akka 3, adding an SDK and managed hosting.

Why it’s built this way

Erlang’s actors and supervisors, on the JVM
Bonér saw actors as one abstraction for both concurrency and distribution. Supervisors restart a crashed actor while its mailbox is left untouched, which is how Erlang systems stay up.
Location-transparent actor references
In Bonér’s words, “it doesn’t matter if the actor reference you hold on to represents an actor in-process or on another physical machine”, which lets the runtime rebalance a cluster and move actors around.
At-most-once delivery by default
A message that is being processed when an actor crashes is lost “by design”, as in Erlang. Guaranteed delivery costs extra round trips and storage, so Akka leaves it to explicit acknowledgements and persistence where it’s needed.
A source-available licence that turns into Apache 2.0
Bonér said Apache 2.0 had become “increasingly risky when a small company solely carries the maintenance effort”. The BSL makes larger production users pay while every release still becomes Apache-licensed three years later.

Timeline

  1. 2009

    Bonér starts Akka in February and tags 0.5 in July

  2. 2011

    Akka 1.0 in February; Bonér and Odersky launch Typesafe in May

  3. 2012

    Akka 2.0 released in March

  4. 2016

    Typesafe is renamed Lightbend

  5. 2022

    Akka 2.7 ships in October under the Business Source License

  6. 2024

    Licence keys required in production; Lightbend renames itself Akka

  7. 2025

    Akka 2.7 code converts to Apache 2.0 in October

Sources32 · facts checked 6 October 2026

Improve this page on GitHub