Primcloud
Docs menu

Runtime versions

Which sbt and OpenJDK versions Primcloud supports, how to pin each via project/build.properties and system.properties, and how to upgrade.

On this page

A Scala app on Primcloud has two version dimensions: the sbt release that runs your build, and the OpenJDK version your app runs on. Scala itself is a third, but Primcloud doesn't install it. sbt pulls the compiler and standard library from Maven Central based on the scalaVersion in your build.sbt, so any Scala version sbt can resolve will build.

sbt#

Primcloud supports the 1.x and 2.x series. One release is rejected: 2.0.0, because upstream sbt has a bug in that exact version that stops global plugins from loading. Use 2.0.1 or later on the 2.x line.

Series Support Notes
sbt 1.x Supported Still maintained upstream. Use the latest patch for new projects.
sbt 2.0.0 Not supported Rejected: global plugins the build needs fail to load.
sbt 2.0.1+ Supported Use the latest available patch.
sbt 0.x Not supported End-of-life upstream.

OpenJDK#

The OpenJDK versions you can install are part of the Primcloud Runtime and move as the Runtime is updated. The build log for each deployment, in the Deployments tab, shows the version that build installed. It defaults to the latest LTS, and you pin a version via system.properties. Recent LTS majors (such as 17, 21, and 25) are all available to pin.

Pinning a version#

sbt is pinned in project/build.properties, and this file is required:

project/build.properties 
sbt.version=1.11.7

The value has to be a valid version. A missing, empty, or unparseable one fails the build with "No sbt version defined" or "Unexpected version parse error."

OpenJDK is pinned in system.properties at the repo root, via java.runtime.version:

system.properties 
java.runtime.version=25

Give a major (25) and Primcloud installs the latest patch of that major; give an exact patch and it installs that build. Without a system.properties, you get the latest LTS, and the build log prints a note recommending you pin one explicitly. An OpenJDK version that can't be matched fails the build with "Unsupported OpenJDK version."

Scala is set with scalaVersion in your build.sbt:

build.sbt 
scalaVersion := "2.13.18"

Scala 2.12, 2.13, and 3.x all build, as long as the version is compatible with the sbt release you pinned and the plugins you use.

Upgrading#

Bump the pin and redeploy:

  • sbt: edit project/build.properties, commit, push.
  • OpenJDK: edit java.runtime.version in system.properties, commit, push.
  • Scala: edit scalaVersion in build.sbt, commit, push. A cross-major jump (2.13 → 3.x) usually needs code and dependency changes; sbt won't make those for you.

The next build pulls the newer sbt or JDK and caches it, so a later deploy on the same version doesn't re-download. A jump across a major boundary means one longer build while the new sbt or JDK downloads, then normal speed from the deploy after that.

When a version drops out of support#

OpenJDK majors follow the upstream support tiers. When one goes end-of-life:

  • A pin to that major keeps working as long as the version is still available.
  • Once it's gone, a build pinning it fails with "Unsupported OpenJDK version" and can't redeploy without a version bump.
  • A build that pins no version keeps going, resolving to the current default LTS.

Bump to a supported major before your target's EOL date, so the upgrade happens on your schedule rather than under a broken deploy.

For sbt, only the 1.x and 2.x series are supported today. If sbt 3.x ships later, pinning it before Primcloud supports it fails with "Unsupported sbt version."