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.

Akka

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

Scala

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

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
Slick Extensions—Integration with commercial databases for Slick, which eases relational database integration and query building with Functional Relational Mapping library for Scala
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 Enerprise and integrates via SPI with third-party or in-house monitoring solutions
Access to optional product: 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 Reactive Monitoring SPI, you have complete flexibility to integrate with third-party or in-house solutions.
Beta coming soon. Sign Up for details.

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.

Make Database Access More Reactive

Reactive Platform includes a set of Slick database extensions that deliver asynchronous stream processing with non-blocking back-pressure when accessing Oracle, IBM DB2, and MS SQL Server.

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.

Protect Apps Against Abuse

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

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.

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.

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.

or

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.

or

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 an Activator or sbt build with the Reactive Platform sbt plugin

Steps to install Typesafe Reactive Platform plugin

  1. Create a new file project/typesafe.properties (put this in .gitignore if the code will be released outside your organization):
    typesafe.subscription=YOUR_SUBSCRIPTION_ID
    
    (Click to obtain a subscription ID.)
  2. Update the sbt version to the 0.13.7 or above in project/build.properties:
    sbt.version=0.13.7
    
  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 = "15v09p01"
    
    // Update this when a major version of Reactive Platform is available
    val rpUrl = "https://repo.typesafe.com/typesafe/for-subscribers-only/AEE4D829FC38A3247F251ED25BA45ADD675D48EB"
    
    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",
      url(rpUrl))(Resolver.ivyStylePatterns)
    

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: _*).
      settings(
        // 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: _*).
      settings(
        libraryDependencies ++= Seq(
          TypesafeLibrary.akkaActor.value,
          typesafeAkkaTestkit.value % Test,
          scalaTest % Test)
      )
    

    Here is the list of all predefined TypesafeLibrary values:

    object TypesafeLibrary {
      lazy val playOrganization = "com.typesafe.play"
      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

15v09p01

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

Base versions for 15v09p01

Scala

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

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:

Play

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

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

Commercial features in 15v09p01

Akka

  • 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

Play SOAP 1.0 is included.

Slick

Slick Extensions 3.0.0 is included.

Reactive Platform Subscription

Launch like a startup, scale like an enterprise.

Standard
Prove your value to the business
Select
Get your initial project up and running
Premier
Expand your project team and deployment
Enterprise
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 - 50 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
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