Reactive Platform

Typesafe provides a leading Reactive application development platform for the JVM that meets the demands of Internet-of-things (IoT), Web, and Mobile applications.

Reactive Platform makes it easy for development teams to build Reactive software applications that are massively distributed while reducing the headaches and risks associated with managing microservices-based apps in production.


Message-Driven Runtime

At the center of our Reactive Platform is Akka, a message-driven middleware or runtime with Scala and Java APIs.

Only In Reactive Platform

  • Akka Split Brain Resolver
  • Akka 2.3 Cluster Support for Docker
  • Akka 2.3.x extended support for Java 6 & 7

Scala or Java

Programming Languages

Reactive Platform fully supports both Java and Scala, so you can choose what’s best for you.

Only In Reactive Platform

  • Spark for Scala 2.11
  • Akka 2.4 on Java 6 & 7


Just-Hit-Reload Web Framework

Play Framework is the just-hit-reload the web development framework with Scala and Java APIs.

Only In Reactive Platform

  • Play User Quotas
  • Play SOAP


Fast Data Engine

Apache Spark, which is written in Scala and Akka, is a Fast Data engine to fuel Reactive applications.

Only In Reactive Platform

  • Spark for Scala 2.11

Get There Faster

It’s not about the big fish eating the small fish. It’s about the fast fish eating the slow fish. Our customers report up to 7x increases in development velocity for roll outs.

Integrate With Everything

Don’t have the luxury of building greenfield applications? Don’t worry. Our JVM-based platform is async and RESTful by default so you can integrate with your existing systems.

Delight Your Developers

We are in the midst of a major software revolution. A tremendous amount of development lays ahead. Unlock developer potential and productivity with tools that make programming fun again.

Reactive Platform Features

Reactive Platform includes extra enterprise features that extend functionality beyond what’s available in the open source projects to deliver an application development platform ready for your mission-critical deployment.

Features Matrix

Common Elements Community Projects Reactive Platform
Play Framework—Modern framework for easily building scalable, fast and real-time web applications with Java and Scala
Akka—Toolkit and runtime for building highly concurrent, distributed, resilient, message-driven applications on the JVM
Scala—Fast-growing, elegant, scalable and concise programming language that allows developers to use different programming paradigms (OO and Functional)
Java—Industry-leading, general-purpose programming language, supported by Akka and Play Framework
Activator—Browser-based, tutorial engine that helps get developers started quickly with a zero-friction install and 300+ code templates
sbt—Powerful, interactive build platform for Reactive applications (the power behind Activator)
Apache Spark—Scala-based, highly performant general computation engine for large-scale data processing
Massive ecosystem of tools, libraries, projects and APIs
Reactive Platform Features Community Projects Reactive Platform
Certified build—A certified stack of all Reactive Platform technologies, including all supported third-party APIs, tested under heavy load to speed development and improve the stability of your Reactive systems
Compatibility verifications—Friendly warnings about version incompatibilities eases development; you can drop in patches without fear of breaking anything
Build notifications—Alerts for newer versions or incompatible versions during builds to keep your development on track
Security alerts—Automated alerts for security issues, priority release of patches to ensure the ongoing health of your Reactive systems
Binary updates—Fast, secure artifact access available in binary format to ease maintenance
Long-term focus—An extended two-year period for support of older Java, Scala and Akka versions, plus backports and fixes for all software in RP so you can upgrade at your leisure
Legal protection—Audited commercial licensing with indemnification against IP issues to mitigate potential risk to your business
Akka Split Brain Resolver—Mitigate cascading node partitioning and potential data loss with advanced recovery scenarios for unreachable nodes in Akka Clusters
Akka 2.3 Cluster Support for Docker—Run Akka Clusters in Docker containers or NAT with complete hostname and port visibility on Java 6+ and Akka 2.3.11+
Long-Term Support for Akka—Receive Akka 2.3 support for Java 6, Java 7, and Scala 2.10 to extend the life of your existing applications
Play User Quotas—Mitigate risk of overloading servers by enforcing global limits on external websites, 3rd-party APIs and internal services based on user or IP address
Play SOAP—Create Reactive, non-blocking SOAP clients in Java and Scala to ease integration with existing enterprise systems
Monitoring for Reactive Apps—Gain deeper insight into your Reactive applications with Akka instrumentation that is built into Reactive Platform and integrates via SPI with third-party or in-house monitoring solutions
ConductR—Deploy and manage Reactive applications and microservices more conveniently with Reactive Application Manager purpose built for Operations

Reactive Platform Benefits

Monitor Message-Driven Apps

Reactive Platform provides instrumentation for monitoring message-driven, actor-based systems. With the Typesafe Monitoring SPI, you have complete flexibility to integrate with third-party or in-house solutions.

Resolve Network Partitions Decisively

Mitigate network partitions and the potential data loss that can occur with a set of advanced recovery scenarios for unreachable nodes in Akka Clusters with Akka Split Brain Resolver. Maintain consistency when sharing data across clusters with CRDTs and Akka Distributed Data.

Integrate Easily with Legacy Systems

Play SOAP makes accessing legacy systems Reactive with a message-driven approach. Unlike traditional SOAP clients, Play SOAP provides non-blocking clients as a first class feature.

Protect Apps Against Abuse

Protect backend servers from becoming overwhelmed by badly behaved (or overly-enthusiastic) users or bots. Play User Quotas ensure your app remains readily available for high-value users.

Eliminate Incompatibility & Security Risks

Reactive Platform provides automated alerts for security issues (with priority releases for patches) as well as friendly warnings about version incompatibilities and end of life dates, ensuring Dev or Ops can drop in patches without fear of breaking anything.

Reduce Production Guesswork

Reactive Platform is certified for production environments by validating all software—including third-party libraries—against a comprehensive suite of integration test cases that are benchmarked for scale and performance under heavy load.

Receive Longer-Term Support

Reactive Platform delivers certified software updates that include the back porting of fixes to previous Reactive Platform versions for an extended two-year period so you can upgrade to new technology when the timing is right for your business.

Get Started

Reactive Platform includes extra enterprise features that deliver extended functionality beyond what’s available in the open source projects. Getting started is simple. Just grab your developer license, and then apply it to your project.

Step 1 Grab Your Developer Trial License ID

The Reactive Platform is a set of JARs that integrates simply into your project build process.
It’s available free for development and requires a Subscription for production usage.
The first thing you need to do is grab a Developer Trial License ID.

If you are not yet a subscriber, simply sign up for a free Developer Account. Once signed up, grab your Developer License ID here.


If you have a Subscription, simply visit the products page of the customer portal for installation instructions.

Step 2 Apply The License ID To Your Project

Next, copy your Developer Trial License ID and apply it to your project.

If you have an existing project, just follow the installation documentation below.


If you don’t have a project, you can create one using a handy template and tutorial.

That’s it. You’re good to go.

Installation Documentation for Reactive Platform 15v09

How to set up a Maven build with Reactive Platform

Instructions for Reactive Platform with Maven

It is possible to use the Typesafe Reactive Platform (RP) in a limited fashion with Maven. Usage requires an import dependency for  Maven 2.0.9  or higher.

1) You will need to add a resolver for the version of RP you are using.

RP Version Resolver URL
15v09 - latest
The following will add a resolver for Reactive Platform version 15v09:
   <name>Typesafe Reactive Platform - 15v09</name>

2) Import the RP dependencies. Please note: RP dependencies are patch dependent.


3) To use RP, you need to specify a dependency without a <version>. For example:




Known limitations: Transitive dependencies that refer directly to open-source (OSS) versions of RP artifacts will pull in two versions of an artifact: both the RP version and the OSS version. A way to check to see if this problem affects you is to look at the results of mvn dependency:list and see if both RP artifacts and equivalent OSS artifacts appear. If so, you will need to find the dependency that has a transitive dependency on an OSS version of an RP artifact and add the appropriate <exclude> directive to tell Maven to not pull in the OSS artifact.

How to set up an Activator or sbt build with the Reactive Platform sbt plugin

Steps to install Typesafe Reactive Platform plugin

  1. Create a new file project/ (put this in .gitignore if the code will be released outside your organization):
    (Click to obtain a subscription ID.)
  2. Update the sbt version to the 0.13.7 or above in project/
  3. Create a new file project/project/typesafe.sbt with the following content. (Note: It is project/project with two "project".) The values of rpVersion and rpUrl are subject to change:
    // Update this when a new patch of Reactive Platform is available
    val rpVersion = "15v09p04"
    // Update this when a major version of Reactive Platform is available
    val rpUrl = ""
    addSbtPlugin("com.typesafe.rp" % "sbt-typesafe-rp" % rpVersion)
    // The resolver name must start with typesafe-rp
    resolvers += "typesafe-rp-mvn" at rpUrl
    // The resolver name must start with typesafe-rp
    resolvers += Resolver.url("typesafe-rp-ivy",

If you are converting an existing build, the above setting will add sbt-typesafe-rp plugin to both your meta build and your build, which will rewire library dependencies to Typesafe products that are included in the Reactive Platform like Scala, Akka, and Play. You can switch back to the OSS (non-Reactive Platform) version of the build by commenting out project/project/typesafe.sbt.

Steps to declare Typesafe Library dependencies

If you are starting a new project, here are some more tips to make your build work better with the Reactive Platform.

  1. Omit scalaVersion because it’s provided by the Reactive Platform.
    lazy val commonSettings = Seq(
      // scalaVersion := provided by Typesafe Reactive Platform
      organization := "com.example",
      version := "0.1-SNAPSHOT"
    lazy val root = (project in file(".")).
      settings(commonSettings: _*).
        // your settings here
  2. To include the modules included in the Reactive Platform, use the predefined values under TypesafeLibrary, and call .value on it, for instance TypesafeLibrary.akkaActor.value, and append them to libraryDependencies.

    Alternatively, declare vals for dependencies by calling typesafeLibrary(%org%, %name%), which returns a setting-like value:

    lazy val commonSettings = Seq(
      // scalaVersion := provided by Typesafe Reactive Platform
      organization := "com.example",
      version := "0.1-SNAPSHOT"
    lazy val typesafeAkkaTestkit =
      typesafeLibrary("com.typesafe.akka", "akka-testkit")
    lazy val scalaTest = "org.scalatest" %% "scalatest" % "2.2.1"
    lazy val root = (project in file(".")).
      settings(commonSettings: _*).
        libraryDependencies ++= Seq(
          typesafeAkkaTestkit.value % Test,
          scalaTest % Test)

    Here is the list of all predefined TypesafeLibrary values:

    object TypesafeLibrary {
      lazy val playOrganization = ""
      lazy val playSbtPlugin = TypesafeLibrary(playOrganization, "sbt-plugin")
      lazy val akkaOrganization = "com.typesafe.akka"
      lazy val akkaActor = TypesafeLibrary(akkaOrganization, "akka-actor")
      lazy val akkaAgent = TypesafeLibrary(akkaOrganization, "akka-agent")
      lazy val akkaCamel = TypesafeLibrary(akkaOrganization, "akka-camel")
      lazy val akkaCluster = TypesafeLibrary(akkaOrganization, "akka-cluster")
      lazy val akkaKernel = TypesafeLibrary(akkaOrganization, "akka-kernel")
      lazy val akkaMultiNodeTestkit = TypesafeLibrary(akkaOrganization, "akka-multi-node-testkit")
      lazy val akkaOsgi = TypesafeLibrary(akkaOrganization, "akka-osgi")
      lazy val akkaRemote = TypesafeLibrary(akkaOrganization, "akka-remote")
      lazy val akkaSlf4j = TypesafeLibrary(akkaOrganization, "akka-slf4j")
      lazy val akkaTestkit = TypesafeLibrary(akkaOrganization, "akka-testkit")
      lazy val slickOrganization = "com.typesafe.slick"
      lazy val slick = TypesafeLibrary(slickOrganization, "slick")
      lazy val slickCodegen = TypesafeLibrary(slickOrganization, "slick-codegen")
      lazy val slickExtensions = TypesafeLibrary(slickOrganization, "slick-extensions")
      lazy val slickTestkit = TypesafeLibrary(slickOrganization, "slick-testkit")
      lazy val scalaOrganization = "org.scala-lang"
      lazy val scalaCompiler = TypesafeLibrary(scalaOrganization, "scala-compiler")
      lazy val scalaReflect = TypesafeLibrary(scalaOrganization, "scala-reflect")
      lazy val scalaModulesOrganization = "org.scala-lang.modules"
      lazy val scalaSwing = TypesafeLibrary(scalaModulesOrganization, "scala-swing")
      lazy val scalaParserCombinators = TypesafeLibrary(scalaModulesOrganization, "scala-parser-combinators")
      lazy val scalaXml = TypesafeLibrary(scalaModulesOrganization, "scala-xml")

Release Notes for 15v09

Typesafe Reactive Platform


Improvements in 15v09p04


  • Upgraded to typetools 0.4.3 to ensure Java routing DSL works with JDK 1.8.0_u51 or later.


This release is based on the 2.3.14 open-source release,
however also these additional stability fixes in the Akka Cluster module:

Akka Remoting:

  • fix potential reliable re-delivery Actor leak when systems go silent (for days).
    Also introduces new quarantine-after-silence setting, which defaults to 5 days.
  • fix unexpected DeathPactException in ReliableDeliverySupervisor

Akka Cluster:

  • enable failure detection (heartbeating) of joining/down nodes, which solves an edge case
    in the cluster joining process (when a joining node is immediatly downed)
  • fix memory nepotism in AbstractNodeQueue, which would pull more objects than
    needed into the Old generation increasing likelyhood of longer GC pauses
  • stability improvement in ClusterSingleton (already fixed in 2.4 series)


Commercial features new in 15v09p03


  • Akka Configuration Checker

    This utility tries to help you by finding potential configuration issues.
    It is based on knowledge that the Akka Team has gathered from typical misunderstanding
    seen in mailing lists and customer consulting.

  • Akka Diagnostics Recorder

    The Akka Diagnostics Recorder writes configuration and system information
    to a file that can be attached to your Typesafe support cases.
    The information will help us at Typesafe to give you the best possible support.

    It will also register a MBean in the “akka” name space, which can be accessed
    from a JMX console such as JConsole. From JMX you can trigger thread dumps
    that will also be appended to the file.

Improvements in 15v09p03


The included Akka version has been updated to the 2.3.14 open-source release, including the following fixes and improvements:

  • fix infinite recursion in AbstractFSM.onTransition (#18364)
  • fix PermGen leak upon ActorSystem shutdown in JEE containers (#17729)
  • ClusterClient failure detection improvement (#18302)
  • Set tcpNoDelay on child channels (#18216)
  • fix ClusterClient reconnection when server restarts quickly (#18459)


  • Excluded unnecessary findbugs annotations dependency due to incompatible license


Commercial features in 15v09p02


  • Play SOAP plugin is included in RP with additional fixes
    • Fixed an error with primitive types
    • Fixed an error with generating port addresses

Improvements in 15v09p02


  • Added beta.akkaContrib to library


This version of the Reactive Platform was built entirely on JDK 8.
(Previous versions were built on JDK 6.)

Base versions for 15v09p01


The Scala programming language included in 15v09p01 is based on the 2.11.7 open source release.

Scala 2.11.7 is a bugfix release that is binary compatible with previous releases in the Scala 2.11 series.

See the 2.11.7 release announcement for further details.
The documentation is available in the following kinds and variants:

Scala modules

The version of scala-swing included has been patched to be buildable on JDK 8. It is otherwise based on open source version 1.0.2.


Akka included in 15v09p01 is based on the 2.3.12 open source release.
15v09p01 also includes the commercial features listed below and in previous 15v01 Reactive Platform releases.

  • Increased default system message buffer size to 20000 to increase remoting stability,
  • Fix rare race condition in CircuitBreaker #17415,
  • A complete list of resolved tickets is available on the 2.3.12 milestone.

The documentation is available in the following kinds and variants:


The Play web framework included in 15v09p01 is based on the 2.4.2 open source release.
15v09p01 also includes play-slick 1.0.1.


Slick included in 15v09p01 is based on the 3.0.1 open source release.
Here is documentation for Slick:

Commercial features in 15v09p01


  • Akka Split Brain Resolver (Akka SBR) is a new commercial feature available exclusively to Typesafe PSS subscribers. Akka SBR expands your system���s available actions when nodes in your cluster become unreachable, reacting in the best way to address the nature of the failure and selecting a recovery path.
  • Akka Persistence: Snapshots stored using Akka 2.3.x and Scala 2.10.x are binary compatible with Scala 2.11.x. This is achieved thanks to special hand-crafted serializers. Projects can safely upgrade to use Scala 2.11.x even in presence of Java Serialization serialized snapshots.


Play SOAP 1.0 is included.


Slick Extensions 3.0.0 is included.

Reactive Platform Subscription

Launch like a startup, scale like an enterprise.

Prove your value to the business
Get your project up and running
Expand your team and deployment
Go Reactive
Reactive Platform Term License Annual Annual Annual
We’ll create something that fits your unique needs
Project Development Team Size up to 5 6 - 10 11 - 25
Project Deployment Size up to 5 servers 6 - 25 servers 26 - 100 servers
Business Hours Developer Support Included Included Included
Business Hours Production Support Included Included Included
24/7 Production Support Optional Optional Optional
Best Practices Advice Unlimited Unlimited Unlimited
Developer Incidents Unlimited Unlimited Unlimited
Production Incidents Unlimited Unlimited Unlimited
Ask The Experts Webinars Yes Yes Yes
Job Board Posting Yes Yes Yes
Beta Program Access Yes Yes Yes
Add-On Products: ConductR Optional Optional Optional
Architectural Review Optional Optional Optional
Code Review Optional Optional Optional
Production Readiness Review Optional Optional Optional
Onsite Training Optional Optional Optional
Optional Commercial License Yes Yes Yes
Indemnification and Warranties Yes Yes Yes
Pricing Contact Sales

Our Subscription Philosophy

Include Expert Support

We are on this journey together and your success is our top priority. That’s why our subscription program provides an annual license for Reactive Platform that includes development and production support.

Provide Direct Access to Experts

Unlike other vendors that barricade their experts behind layers of escalation, your team receives direct access to the creators and committers of our amazing technology.

Keep Subscription Sizing Simple

Subscription levels are based on the size of your project: either the number of developers or number of servers, whichever is larger.

Deliver Context for Knowledge Transfer

Rather than terse answers, our team takes the time wrap their response with detailed background context to accelerate knowledge transfer.

Give Advice Early and Often

No need to wait for a blocker to arise. Our team of experts is here to answer how-to’s and what-if’s and is excited to share best practice tips. The more advanced your team becomes, the more value they will likely find engaging with our experts.

Encourage All Developers to Engage

We realize that funneling questions through a handful of named contacts doesn’t accelerate learning. That’s why we allow—and encourage—every developer on your project to engage directly with our experts.

White paper:

Introducing Typesafe Reactive Platform

A Platform for Building Message-Driven, Elastic, Resilient and Responsive Applications Leveraging the Java Virtual Machine

Get the Whitepaper