Next Scala 3 LTS series will increase minimum required JDK version

TL;DR

The Scala 3 Next minors in 2025 Q4 and the next LTS will drop JDK 8 support. We are seeking feedback on whether the new minimum JDK should be 11 or 17.

Immediate motivation

The memory-access methods in sun.misc.Unsafe are scheduled for removal in a future JDK, as stated in the recent JEP 471. Currently, Scala 3 uses sun.misc.Unsafe in its implementation of lazy val. In order to support JDK 25+, we will need to drop usage of Unsafe. We are investigating the required changes under this issue.

It then started to dawn on the compiler team that we might consider dropping support for JDK 8 altogether in a future release of Scala 3.

Long term motivation

Switching to a newer version of the JDK would allow both the compiler and the Scala ecosystem to start using new features and standard library improvements brought in by JDK 9+. This might include a number of JEPs (JDK Enhancement Proposals), which the compiler team will investigate during the coming year. To check the current status, take a look at the issues marked with the JEP label.

Some of the features that might be interesting to the Scala community are:

• JEP 181 will allow classes that are logically connected, to access each other’s private members. This could be useful for representing nested classes and companion objects. (Currently, the Scala compiler has to insert public bridge methods to broaden the accessibility of those members.)
• JEP 409 introduces sealed classes. It would allow the compiler to better represent Scala’s sealed trait hierarchies.
• JEP 441 introduces new bytecode shapes for pattern matching in Java. With them, we may be able to optimize the code resulting from Scala pattern matches.
• JEP 471 adds a new API for memory access. We will use it to replace the usage of sun.misc.Unsafe in Scala 3.

Dropping JDK 8 will reduce the maintenance burden on tooling and library authors. They currently have to take into account a large number of different versions, both for correctness and performance. Thus, the benefits of this change will be felt ecosystem-wide.

JDK 8 was first published in 2014, over 10 years ago. JDKs have advanced greatly since then. In order to stay competitive, using those advancements is a must. A lot of the existing distributions, including Oracle’s own, have already stopped or will soon stop updating JDK 8 with security and other fixes. It is of course possible not to update your libraries and compiler version, to avoid having to switch to a newer JDK. However, that is highly discouraged, as it will make you vulnerable to potential security risks.

Some larger projects in the Java and Scala ecosystems have already dropped JDK 8 support in favor of JDK 11 or even 17.

Java examples include:

• Spring 6 requires JDK 17
• Hibernate requires JDK 11 and the next version will require JDK 17
• Jetty requires JDK 17
• Logback requires JDK 11
• JavaFX requires JDK 21
• Vaadin requires JDK 17
• Quarkus requires JDK 17
• TensorFlow requires JDK 11

Scala examples include:

• Spark 4 will require JDK 17
• Play Framework requires JDK 11 and will require JDK 17 in the next major release
• Akka requires JDK 11
• Apache Kafka requires JDK 11
• ZIO requires JDK 11
• Li Haoyi’s ecosystem requires JDK 11 across the board

This shows that the rest of the industry is already moving away from JDK 8.

Plan for making the switch

The current plan is to drop support of JDK 8 in one of the future minor releases of Scala 3 and in the next LTS. The new minimum JDK will be either 11 or 17, depending on the community feedback and our investigations. The current estimate for the next LTS is Q4 2025.

One major challenge will be to preserve backward compatibility. As we change the encoding of lazy vals, we must still be able to use libraries compiled with earlier Scala 3 versions.

How does it affect me?

The current line of LTS under 3.3.x will be supported for at least another year after the release of the next LTS version. That should give you plenty of time to migrate. After that, no more security fixes will be available for Scala 3 versions supporting JDK 8.

If you are using Scala 3 on JDK 8, do let us know! If it is not possible for you to switch, be sure to send us your feedback so that we can figure out a way to help you migrate.

Discussions and further reading

You can track the current work related to lazy values under this issue.

Discussion on the topic of dropping JDK 8 support is available on the Scala contributors forum