Add Title Here

Heading Two

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit

Heading Three

Eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

  • Bullet
  • Bullet
  • Bullet
  • Bullet

Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Eiusmod tempor incididunt ut labore et dolore magna aliqua.

Edge Apps Architecture
Edge Apps Architecture

Responsive by Design

Akka is relied upon when application responsiveness must be guaranteed. Build transactional, durable, and real-time services with a simple SDK and powerful libraries. Akka apps maintain responsibility for their own outcomes in our fully automated operations environments. 

simple-platform graphic
mobile_model_image
large_platform
large_platform

Simple SDK

Create durable, real-time services exposed as APIs with an SDK that enables a rapid inner dev loop, integration with your favorite IDEs, and offline local development.

Entities

Build apps that act as their own in-memory, durable, and replicated database. 

Streaming

Streaming producers and consumers enable real-time data integration.

Endpoints

Design HTTP and gRPC APIs. 

Views

Access multiple entities or retrieve entities by attributes other than entity id.

Workflows

Execute durable, long-running processes with point-in-time recovery.

Timers

Execute actions with a reliability guarantee.

SDK-components-to-clean-code

 

Avoid technical debt

Create high velocity teams with an inner dev loop that separates domain logic from distributed dependencies. Your business logic is yours - build and test domain logic without decorators or leaky API pollution. Akka’s components inject distributed, responsive intelligence during the build.

placeholder

With Akka: Domain Separation
Keep your business logic yours. Build and test domain code like your first ‘Hello, World’ program. Akka components inject intelligence at build with an inner loop that moves as fast as your fingers.

separation-duties-clean-code

 

placeholder

Without Akka : Polluted Domain Logic
Decorating domain code or calling APIs to distribute data or improve resilience creates technical debt, cross-team friction, and coherence leaks.

separation-duties-polluted-code

 

No local cloud required

Developers locally create and debug chained, networked services that execute as local binaries without having to install local cloud infrastructure.

Binaries generated from SDK dependencies are included and compiled at build time enabling offline development.

  • Service-to-service local discovery and messaging
  • No packing
  • No Docker Compose
  • No database
  • No Kubernetes

 

SDK-sandbox

 

Local console and event debugger

Local console, event debugger, sandboxes, and separation of concerns ensures high dev velocity with minimal local configuration.

SDK-event-debugger-screenshot

 

 

Local operations console for visualizing distributed architecture components and their data flows. 

Track entity state changes and visualize modifications to the networked, durable event log. 

Leverage your favorite IDE’s build, run, debugger, and AI add-on to generate and test large blocks of Akka code with minimal prompting.

Fast unit and integration testing

Execute local unit and integration tests for components with a built-in Testkit that enables invocation and assertion comparisons of component responses.

Execute single-component unit tests embedded as binaries or with a built-in networked endpoint.

Execute multi-component integration tests by executing an entire service with component client and endpoint interactions.

 

what-test-kit

 

Automated operations

Operate apps with automation that does not require DevOps to understand the app’s infrastructure: clouds, regions, databases, Kubernetes, VMs, and proxies.

Monitor, log, and trace

Visualize logs, metrics, and traces in real-time with the Akka control tower or stream to a terminal.

Akka supports integration with your preferred observability protocols including, Open Telemetry, Prometheus remote write, and Splunk HEC. 

heat-maprequests-per-second

p99-processing

graph view

Replication

Elastic to workload changes

Akka operating environments perform cold start and automatic adjustment of app instances as traffic spikes or idles.

Logs, metrics and traces visualized within a per-service dashboard or exported to your preferred observability tooling.

sharding

 

Resilient to failures

Akka automatically snapshots app instances and executes change data capture of individual state changes for entities. Akka replays snapshots and entity events sequentially to automate restoration after a failure.  

 

empty-recovered-state

 

Akka apps run in an Akka operating environment, which provides automation for elasticity, agility, and resilience. Your apps can deploy into environments managed by us or you. Federate your private regions with public regions available at Akka.io to enable cross-region replication.

federate

 

Akka provides managed services and self-hosted software that automates the lifecycle of your applications enabling them to maintain their own SLA. Akka environments orchestrate microservices, handle elasticity scaling events, configure gateways and proxies as topologies change, and manage persistence access for entities, events and views.

 

Operate apps across clouds and geos

Multi-Master Replication of app data across regions with automated cutovers leverage location transparency to enable apps to move from one location to another without users experiencing downtime. 

Zero-downtime upgrades, cloud-to-cloud, serverless to BYOC, and repatriation migrations are all supported.

 

replicate

 

 

multi-cloud-replication-types

 

Freedom to move

Avoid lock-in and downtime during migrations. Akka apps move from one location to another without users experiencing downtime through replication of data across regions with automated cutovers. Support for cloud upgrades, cloud-to-cloud migrations, Serverless to BYOC, and repatriation migrations.

migrate

 

Start with one place

Design, build and deploy apps within a single location.

Regional migration

Add regions for apps to replicate across. 

Custodial migration

Retire an app in one place after movement to a second. Mix Akka-managed regions with self-managed.

Infrastructure upgrades

Promote read-only regions to writable for rolling infra updates. 

Version and schema updates

Apps automatically adapt to schema changes with end user traffic rerouting.

 

 

 

Clustering from within

The Akka runtime executes as an embedded kernel. Akka clustering, also from within, enables your apps to discover, join, participate, and leave a cluster automatically and across networking boundaries.

akka-runtime

 

The Akka runtime

  • Scheduling: compute, threads
  • Data: flows, shards, replication
  • Communication: cluster membership, I/O
  • Resilience: self-healing actions, split brain resolution
  • Akka creates a ring of physical nodes to execute instances
  • Akka places instances in more than 1 bucket for redundancy
  • Akka monitors service request traffic to add / remove nodes
  • Akka rebalances instances and data as ring size changes

Automated operations

 

Operate responsive applications with Akka automation embedded within our Serverless, BYOC, and Self-Hosted operating environments.

Elastic

Akka apps auto-scale to varying workloads while placing multi-master replicas in regions of your choice.

Agile

Akka updates, rebalances and repartitions data workloads as compute availability changes to enable no-downtime maintenance events.

Resilient

Akka recovers, migrates and replicates workloads to handle any potential failure.

Environments

Akka provides managed services and self-hosted software that automates the lifecycle of your applications enabling them to maintain their own SLA. Akka environments orchestrate microservices, handle elasticity scaling events, configure gateways and proxies as topologies change, and manage persistence access for entities, events and views.

Service Elasticity & Resilience

Cold start and automatic adjustment of app instances as traffic spikes or idles. Automatically snapshot storage of instances and change data capture of state changes for entities. Replay snapshots or entity events after failure for restoration. Data import / export for development or production services. Logs, metrics and traces visualized within a per-service dashboard or exported to your preferred observability tooling. Secure services, projects and organizations with ACLs, JWTs, and certificates.

Multi-Cloud, Multi-Region

Link different Akka operating environments with a global control plane that enables Akka apps to be elastic and resilient across locations. Akka federation is multi-cluster, multi-region, multi-cloud allowing apps to run, cluster and replicate across geographical, regulatory, or data center boundaries. Devs pack apps once and Akka automates multi-region image upload and deployment to Docker registries embedded within Akka or controlled by you. 

Migrations

Replication of app data across regions with automated cutovers leverage location transparency to enable apps to move from one location to another without users experiencing downtime. Support for upgrade, cloud-to-cloud, Serverless to BYOC, and repatriation migrations.

Microservices Automation

Cold start VMs and compute units when physical compute exceeds admin thresholds. Multi-region image uploads and activation. Reconfigure proxies, API gateways and databases for individual services per deployment. Database resizing and schema evolution management. Kubernetes cluster activation and sizing. You’ll never touch kubectl.

The G.O.A.T. libraries

Yes, after 1B downloads, we're comfortable claiming the Akka libraries are the Greatest Of All Time for building distributed systems. ;)

icon_service_mesh_yellow

Simpler concurrent & distributed systems

Actors and Streams let you build systems that scale up, using the resources of a server more efficiently, and out, using multiple servers.

icon_security_yellow

Resilient by Design

Building on the principles of The Reactive Manifesto Akka allows you to write systems that self-heal and stay responsive in the face of failures.

icon_dynamics_yellow

Elastic & decentralized

Distributed systems without single points of failure. Load balancing and adaptive routing across nodes. Event Sourcing and CQRS with Cluster Sharding. Distributed Data for eventual consistency using CRDTs.

icon-reactive_yellow

Reactive streaming data

Asynchronous non-blocking stream processing with backpressure. Fully async and streaming HTTP server and client provides a great platform for building microservices. Streaming integrations with Alpakka.

icon_launch_yellow

High performance

Up to 200 million msg/sec on a single machine. Small memory footprint; ~2.5 million actors per GB of heap.

Build and run responsive apps

Akka is a platform to build and run responsive apps across regions, clouds and devices. Transactional, durable, and real-time services are elastic, agile, and guaranteed resilient. Developers build with an SDK and can gain more granular control using a set of libraries. Fully automated operations for your Akka app are available in both serverless and BYOC options. A self-hosted option can be set up when your organization needs total control.

Home Responsive Model-1 1
Home Responsive Model Mobile (2) 1

Simple DevEx Simple OpsEx

Uniform Model

Akka provides a uniform, simple DevEx and OpsEx to build apps once and then continuously adapt to change. Build, test and debug locally, and deploy multi-regionally without code rewrites. Versioning, rolling updates, schema migrations, and infrastructure upgrades can all be done without downtime.

No Rewrites. No Downtime.
cpu
SCALE Up/Down Compute
data
Scale Data
app-1
Scale Out/In Servers
network
Scale Across Regions
  • Core
  • Socket
  • CPU
  • Container
  • Server
  • Rack
  • Data Center
  • Region
  • Global
One Application Abstraction

Developer building blocks

SDK and Libraries

The Akka SDK maximizes developer velocity and is built with proven, comprehensive libraries that have been downloaded 1B times.

akka_sdk_icon
SDK

Durable, transactional, and real-time services

  • endpoints
  • streaming
  • workflows
  • views
  • actions
  • entities
  • timers
Elastic Ops & Automated Infrastructure
  • Serverless @ Akka.io
  • Bring Your Own Cloud
  • Self-Managed
built with
akka_libraries_icon
Libraries

Foundational modules

  • actors
  • HTTP
  • gRPC
  • streams
  • event sourcing
  • persistence
  • clustering
  • durable state
  • messaging
  • integrations

Single control plane

Control Plane

Akka federates POPs to create a multi-cloud network with a single control plane. DevOps links diverse infrastructure to enable app operations across datacenter, geo, or custodial boundaries.

Federate
Serverless
@Akka.io
BYOC
@GCP, AWS, Azure
Self-Managed
@k8s, k3s

Specs

Modules
Endpoints: Expose and proxy HTTP & gRPC services
Actions: Dynamic logic with no cold start
Entities: Replicated, event-sourced and kv in-memory db
Views: Streaming projections and joined queries
Timers: Scheduled future executions
Workflows: Durable long-running processes
Runtime
  • Docker 20.10.14 or higher (to run locally)
  • Kubernetes 1.28+
  • K8s EKS, AKS, GKE, K3s
  • AWS, Azure, GCP
  • K3s for lightweight deployments
Persistence
  • Data import / export
  • Postgres-compatible stores
Distribution
  • Simultaneous deployment across regions
  • Runtime configuration of data replication
  • Multi-cloud and multi-region replication
  • HA per region
Testing
  • Local unit, integration, and end-to-end testing
  • Testing SDK
Clustering
  • Masterless, multi-node coordination
  • CRDT replication of cluster state
  • Split brain resolution
  • Automatic data sharding and user traffic routing
Akka Libraries Interop
  • Entity event propagation
  • Optional broker transport
SDK / IDE
  • Java SDK / IntelliJ / VSCode / Eclipse
  • Local development & runtime experience
  • Local step through of past events
  • Local step through debugging
SDLC
  • Container-based packaging
  • Docker DevFlow & integration
  • Integrated Docker registry
Security
  • Zero Trust configuration
  • Automated certificate provisioning
  • mTLS
  • OpenID
  • IAM / SSO
  • ACL with JWT
Multi-Region Federation
  • Reliable, brokerless gRPC
  • CRDT replication of entities
Observability
  • Built-in dashboards
  • Object observability (entities, views, etc)
  • Audit & operational logs
  • Infra & object performance stats
  • SIEM integration
  • Export to Open Telemetry, Splunk, Grafana
  • Replay event & state changes
  • Change logs on all entities
  • Seamless scale of underlying infrastructure
Brokers
  • Kafka
  • Google Pub/Sub
  • Azure Event Hubs
Hosting
  • Multi-tenant PAAS @ Akka.io
  • Bring your own hyperscaler, we manage
  • Self-managed on Kubernetes
Compliance
  • SOC2 Type 2 Certified
  • GDPR
  • NIST-CSF

Stay Responsive
to Change.