Cloud Parts

Apache Pekko

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

What it is
Actor model
Type
Open source
Made by
Apache Software Foundation
License
Apache 2.0
Facts checked
6 October 2026
Website Source code

What it is

Pekko works the way Akka 2.6 did. Each JVM runs an ActorSystem that drives many lightweight actors, each with a mailbox, handling one message at a time under a parent that supervises it. Pekko Cluster joins JVMs into a membership group, Cluster Sharding places each entity actor by ID on exactly one node and moves it when nodes come and go, and Pekko Persistence keeps each entity’s events in a journal (Cassandra, JDBC, R2DBC for PostgreSQL, DynamoDB) to replay after a restart. Separate modules add Streams, HTTP, gRPC, Projections, Management (cluster bootstrap and health checks on Kubernetes) and Connectors, the renamed Alpakka, including Kafka. Messages between actors are delivered at most once.

The code started from Akka 2.6.20, the last line before Lightbend moved Akka to the Business Source License. It differs from Akka mostly in names: packages are org.apache.pekko, config keys start with pekko., node addresses use pekko:// and the default remoting ports changed. Data persisted by Akka can be read by Pekko and the other way round, and mixed Akka and Pekko clusters are experimental. Jars are on Maven Central with no licence key or fee. The 1.x line (1.7.1, September 2026) runs on Java 8 and later; 2.0, in milestones not meant for production, needs Java 17, drops Scala 2.12 and brings in Akka code as each Akka release turns Apache 2.0.

Why teams pick it

  • Apache 2.0 under the Apache Software Foundation: no licence keys, no fees, and no single company that can change the licence
  • A short path from Akka 2.6: mostly renamed packages, config keys and ports, and persisted data stays readable
  • The full Akka 2.6 toolkit, with more than 50 libraries released: Core, HTTP, gRPC, Connectors, Kafka, Management, Persistence plugins and Projections
  • Used by Apache Flink (since 1.18) and the Play Framework

Watch out for

  • Akka features added since 2022, such as Replicated Event Sourcing over gRPC, Akka Edge and Distributed Cluster, aren’t in released 1.x versions; the 2.0 line ports Akka code only once it turns Apache, three years after each Akka release
  • No vendor behind it: at incubation no company committed dedicated developers (Aiven and Altoo pledged to help as needed), so help comes from the community
  • Pekko 2.0 removes much deprecated code, so libraries built against 1.x are unlikely to work with it, and its milestones are for testing only
  • Apps already on Akka 2.7 or later may use APIs that Pekko 1.x doesn’t have, because the fork starts from 2.6
  • The usual actor-model costs: at-most-once delivery, versioned message serialization, cluster and split-brain operations, and JVM only

Alternatives

What all actor model have in common →
AkkaCommercialThe 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.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

Move an Akka 2.6 project to Pekko 1.x: dependencies, packages, config and ports · bash

# GNU sed and grep. 1. build.sbt: swap the organisation and artifact names
#    "com.typesafe.akka" %% "akka-cluster-sharding-typed" % "2.6.20"
#    "org.apache.pekko" %% "pekko-cluster-sharding-typed" % "1.7.1"
#    then set the versions by hand; Alpakka Kafka becomes "org.apache.pekko" %% "pekko-connectors-kafka"
sed -i -E 's/"com\.typesafe\.akka" %% "akka-/"org.apache.pekko" %% "pekko-/' build.sbt

# 2. packages: akka.* becomes org.apache.pekko.*, AkkaException becomes PekkoException
grep -rlE '\bakka\.' src --include='*.scala' --include='*.java' | xargs sed -i -E \
  -e 's/(import|package) akka\./\1 org.apache.pekko./' \
  -e 's/\bAkkaException\b/PekkoException/g'

# 3. config: akka { ... } and akka.actor.provider become pekko { ... } and pekko.actor.provider
sed -i -E 's/^(\s*)akka([ .{])/\1pekko\2/' src/main/resources/*.conf

# 4. anything left: addresses (akka:// is now pekko://) and ports (Artery 25520 is now 17355)
grep -rn 'akka://\|akka\.tcp://\|25520\|2552\b' src deploy || echo 'nothing left'
sbt test

Akka or Pekko?#

Both grew from the same code until Akka 2.6. The choice is mostly about licence and cost against the features Akka has added since.

AkkaApache Pekko
LicenceBSL 1.1 since 2.7 (October 2022); each release becomes Apache 2.0 three years after it shipsApache 2.0
Production useLicence key required; free for organisations under $25 million revenue, OSS and academia, otherwise a subscription with no public price listFree, no key
Where the jars come fromAkka’s own repository through a tokenized URL (since Akka 23.10)Maven Central, group org.apache.pekko
Current stable lineAkka core 2.10.23 (September 2026), part of the Akka 25.10 bundle1.7.1 (September 2026); 2.0.0 milestones for testing
Java versionsCertified on Java 8 to 251.x: Java 8 and later; 2.0: Java 17 and later
Added after the forkDistributed Cluster, Projections and Replicated Event Sourcing over gRPC (23.05), Akka Edge (23.10), licence keys (2024)Its own fixes and new stream operators; 2.0 milestones port Akka changes up to 2.8.4 so far
Higher-level toolsAkka SDK and managed Serverless or BYOC hostingNone: libraries only
Who’s behind itLightbend, doing business as Akka, with commercial supportApache committers; at incubation no company committed dedicated developers
Coming from Akka 2.6Upgrade in place; 2.7 and later need a licence key in productionMostly renames; persisted data readable both ways; mixed clusters experimental
  • Each Akka patch release has its own change date: 2.8.4 became Apache 2.0 on 15 August 2026, but 2.8.10 converts only in August 2029.

See it in a real stack

No architecture uses Apache Pekko yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2022–2026

In September 2022 Lightbend announced that Akka 2.7 and later would ship under the Business Source License instead of Apache 2.0, and that Akka 2.6 would get security fixes only until September 2023. Projects built on Akka, including Apache Flink, needed an open-source way forward.

A group of Akka users and contributors, among them Matthew de Detrich, PJ Fanning, He Pin and Josep Prat, with Aiven and Altoo offering support, proposed forking the last Apache-licensed code into the Apache Incubator. They argued it was not a hostile fork but a continuation of the existing licence, and that an ASF home would protect it from another licence change. After a community vote they named it Pekko, after the Finnish god of farming. It entered incubation on 24 October 2022, released Pekko 1.0 in July 2023, and Flink 1.18 switched to it that October.

Pekko became a top-level Apache project in March 2024, by which time more than 50 libraries had been released. Its 2.0 line, in milestones since 2025, raises the minimum to Java 17 and pulls in Akka code as each release passes its change date.

Why it’s built this way

Fork the last Apache-licensed release instead of rewriting
Many applications ran on Akka 2.6. Starting from the same code meant moving to Pekko could be mostly a matter of renaming, and data persisted by Akka stayed usable.
Rename everything, down to ports and addresses
The Akka name had to be removed from the code for trademark reasons. Pekko also changed the default remoting ports so they don’t clash with Akka’s, and uses pekko:// addresses.
A home at the Apache Software Foundation
The proposal argued that only foundation ownership would stop a repeat of the licence change, and that it would reassure Apache projects such as Flink that depended on Akka.
Take Akka code only after it turns Apache 2.0
BSL code can’t go into an Apache project. Because each Akka release converts after three years, the 2.0 milestones add Akka changes as they are relicensed, up to Akka 2.8.4 so far.

Timeline

  1. 2022

    Akka moves to the BSL; Pekko enters the Apache Incubator on 24 October

  2. 2023

    Pekko 1.0 released in July; Flink 1.18 switches to it in October

  3. 2024

    Graduates to a top-level Apache project in March

  4. 2025

    2.0 milestones begin, with Java 17 as the minimum

  5. 2026

    2.0.0-M4 ports Akka code up to 2.8.4; 1.7.1 ships in September

Sources26 · facts checked 6 October 2026

Improve this page on GitHub