Release History & What’s New

Three things to read from the figure. First, Scala 3 was published in May 2021 and arrived in minor releases roughly every six to nine months. Second, the 3.3 LTS was the only Long Term Support line from 3.3.0 (May 2023) until 3.9.0 (September 2026), so Scala Next releases 3.4 to 3.8 were all published while 3.3 was the LTS. Third, the JDK floor moved to 17 with 3.8, so the lines before it (3.3 LTS and 3.4 to 3.7) are the only ones that still run on JDK 8 and 11.

The dates are the dates of the official release announcements. Maven Central usually has the artifacts a few days earlier (for example the 3.10.0 artifacts are dated 5 October 2026 and the announcement 12 October 2026), so a date read from a Maven repository can differ from the one on this page.

The latest patch release of each line on the official all-versions page at the check date were:

Sources: All Available Versions, Scala 3.10 released!, Scala 3.9 LTS released!

One row per release that changed the language or the tooling in a way the section teaches. The first column links to the official notes of the release.

The sections below go through the rows in order. Each one says what the release is remembered for, shows the changes that could be demonstrated with a compiler on this machine and says what comes only from the release note.

Scala 2.13.0 is the release whose library Scala 3 still uses. Its announcement lists four areas: the collections were overhauled for simplicity, performance and safety (the centerpiece), the standard library gained a faster and more robust Future plus new classes and methods, the language gained literal types, partial unification and by-name implicits, and the compiler became 5 to 10 percent faster with deterministic output.

What this means for a Scala 3 programmer today is that most of the standard library has not changed since 2.13: the collection hierarchy, LazyList, scala.util.Using and scala.util.chaining all come from this release. Three things were deprecated rather than removed in 2.13.0, and the deprecated forms still compile in Scala 3.10. A program that uses them, compiled with -deprecation:

On Scala 2.13.18 the compiler answers:

and Scala 3.10.0 says the same, in its own format, and also runs the program:

Source: Scala 2.13.0 is now available!

scala.collection.generic.CanBuildFrom behaves the same way: it is a deprecated type whose message points to scala.collection.BuildFrom ("Use scala.collection.BuildFrom instead"), and the apply method of BuildFrom is deprecated in favour of newBuilder. So the accurate statement for the books is that CanBuildFrom and Traversable are deprecated shims since 2.13.0, not removed, and new code should not use them.

The replacements, all run on 2.13.18 in one program, are LazyList, BuildFrom, Using, pipe, tap and literal types:

The collections themselves are taught in Collections Overview and Collections Architecture & Custom Collections, and LazyList in Views, Iterators & LazyList.

Source: Scala 2.13.0 is now available!

Scala 3 was announced after eight years of work, 28,000 commits and more than a hundred contributors. The announcement sends readers to the Scala 3 documentation, the "New in Scala 3" article, the Book and the migration guide, and says that one thing changed completely compared to Scala 2: macros. It also fixes the release policy: patch releases are forward and backward compatible with each other, minor releases add language features and library APIs, and "libraries built with Scala 3.0.0 will keep working with Scala 3.x.y". At the time of that post Scaladex listed 308 early adopter libraries on Scala 3 against 2597 on Scala 2.13; the 3.9 announcement says that roughly 56 percent of Scala 3 libraries now publish with 3.3 LTS.

What 3.0 contains is most of what the rest of this section teaches. Where each feature is taught:

Three of the dropped features are easy to demonstrate, because they are syntax errors on every Scala 3 compiler. This file uses the procedure syntax, do-while and a symbol literal; each is compiled on its own so that one error does not hide another. On 3.3.8 and on 3.10.0 the procedure syntax gives the same message:

The do-while loop fails with a message that does not name the feature (end of toplevel definition expected but 'do' found, then Illegal start of toplevel definition on the next line), which is why the form is worth recognizing, and a symbol literal such as 'sym fails with a message that tells you what to write instead: "use a string literal "sym" or an application Symbol("sym") instead". All three still need rewriting by hand when you port a Scala 2 file; see the incompatibilities page for the rewrite of each.

Source: Scala 3 is here!, New in Scala 3

The 3.1.0 announcement is the first one that explains the compatibility model of the 3.x series, and it explains it by admitting a limitation. Scala 3.1 is backward binary compatible, since dependencies compiled with 3.0 work in 3.1 projects, but it is not forward binary compatible, since dependencies compiled with 3.1 do not work in 3.0 projects. The advice at the time to library maintainers was to test with 3.1.0 and 3.0.2 but to publish with 3.0.2, so that downstream users on either version could use the library. The same rule, unchanged, is why 3.9 LTS is the recommended publishing target today.

Highlights of the release, all from the announcement:

The release also changed what compiler you can run on a current JDK. A 3.1.3 compiler started on JDK 26 stops with an error about the JDK’s own class files; on JDK 17 the same compiler works. This is the output on JDK 26, for any program:

The remedy is to run the old compiler on an older JDK (17 in the probes of this page). The JDK floor moves in the other direction in 3.8 (see below). Old compilers on new JDKs are covered in Versions, Compatibility & JDKs.

Source: Scala 3.1.0 released!

The headline of 3.2.0 is coverage: the compiler can now generate Scoverage data itself with the -coverage-out flag, without a compiler plugin, so it works for Scala 3 code (later releases added // $COVERAGE-OFF$ markers in 3.3.8 and 3.8.3). The release also allowed exports in extension clauses (export richInt.* as a way to add extension methods in bulk), code completion for refined Selectable types, better Mirror synthesis for local and inner classes and tuples up to 22 elements, given bindings in for generators, easier construction of classes whose first parameter list is a using clause, and the -Vprofile flags that report code complexity. The announcement also lists new experimental APIs (MainAnnotation, newMain, TupledFunction) and a list of APIs that were stabilised.

Two changes of 3.2 matter for ordinary code because they are warnings that every project meets:

Both are demonstrated here. This program has a pattern binding that the compiler cannot prove irrefutable:

On 3.1.3 (JDK 17) it compiles silently and prints (1,List(2, 3)). On 3.3.8 it warns, and the text of the advice changes again in 3.8, where : @unchecked is replaced by .runtimeChecked (SIP-57, see 3.8):

Source: Scala 3.2.0 released! and Scala 3 Reference: Pattern Bindings

The same program on 3.8.4 and on 3.10.0 prints the identical warning with "adding .runtimeChecked after the expression" and "-rewrite -source 3.8-migration". The non-local return is this program:

It prints -2 on every version, and compiles without a warning on 3.1.3. On 3.2.2 the warning points to the old API:

and from 3.3 on the advice is the one that the next section introduces ("use boundary and boundary.break in scala.util instead"). Both warnings are still warnings, not errors, on 3.10.0. See Exceptions, boundary & Early Exit and Extractors & Pattern Bindings.

Sources: Scala 3.2.0 released!, Scala 3 Reference: Pattern bindings, Scala 3 Reference: Deprecated nonlocal returns

3.3.0 is the first Long Term Support release and defines the model the section relies on. Scala 3.3.x is maintained for at least three years; new minor releases (3.4, 3.5 and so on) are called Scala Next, "equivalent to Java’s feature releases"; bug fixes and usability improvements from Scala Next are back-ported as 3.3.x patches, and apart from those forward and backward compatible changes the LTS is feature frozen. The LTS model does not change the compatibility guarantees: projects built with any future release can depend on a library compiled with 3.3.x.

What it added to the language and library:

Source: Scala 3.3.0 released!, More consistent braceless syntax

On 3.2.2 it does not compile (not a legal formal parameter for a function literal, then Not found: x on the next line); on 3.3.8 it prints List(2, 4, 6).

On 3.3.8 it prints -3. On 3.2.2 the import itself fails:

3.3 is also the line with the longest tail. The final LTS patch at the check date is 3.3.8 (10 June 2026), which adds JDK 26 support, the // $COVERAGE-OFF$ markers, an @uncheckedOverride annotation and a -Yfuture-lazy-vals option that produces lazy vals compatible with JDK 9 and later. The notes of 3.3.8 say that the next 3.3 release will include the updates introduced up to the last 3.9.x before 3.10. See Optional Braces & Indentation and Compiler Options, Linting & Errors.

Sources: Scala 3.3.0 released!, Scala 3.3.8 LTS is now available!

Scala 3.4.0 and 3.3.3 were released the same day, and the announcement is the clearest statement of the split. 3.3.3 "focused solely on bug fixes and usability improvements" and keeps full binary and source compatibility (the team checked that every one of more than a thousand projects that worked with 3.3.1 still worked with 3.3.3); 3.4.0 adds features and deprecates legacy mechanisms. 3.3.2 does not exist on the all-versions page: a bug in the TASTy reader made it emit TASTy files incompatible with 3.3.0 and 3.3.1, so the release was abandoned and users were told to bump to 3.3.3.

The changes of 3.4 are three groups:

The with type operator is the clearest example, because it is one of the few deprecations that was later promoted to an error. This file uses it for an intersection type:

On 3.3.8 it compiles without a message and prints Ana (41). On 3.4.3, and unchanged on 3.9.0, it prints a warning and still runs:

On 3.10.0 the same text is reported as an error and compilation fails:

Note that only Named with Aged as a type is affected: the new Named with Aged { ... } expression is the ordinary mixin syntax and was not flagged by any of the three compilers. The progression warning in 3.4, still a warning in 3.9, error in 3.10 is the timeline that Incompatibilities & Dropped Features and Upgrading Between Scala 3 Versions repeat for the other features.

Other items of the 3.4 notes, not run here: the improved message for an incompatible TASTy version, which now says which Scala version produced the file and which to use, a similar message for broken class files that points at the JDK compatibility of your Scala version, compilation progress in IDEs, exporting diagnostics (including unused warnings) to SemanticDB, the ported JVM backend parallelization, and the experimental @publicInBinary annotation that SIP-52 stabilised in 3.7.

Source: Scala 3.4.0 and 3.3.3 LTS released!

3.5.0 made Scala CLI part of the Scala distribution. The scala command installed by a package manager became the Scala runner implemented by Scala CLI (SIP-46): it compiles, runs, tests, packages and publishes single-module projects, with //> using directives and toolkits built in. On the Scala 3.10.0 distribution used for this page, the command reports:

This is the biggest shift for the first chapter of any Scala book: the scala program that older books describe runs a class from a classpath (scala -classpath ...), while today it runs source files. See Scala CLI. Coursier 2.1.10 or later is needed to install it.

Other changes in 3.5:

On 3.4.3 the import itself is reported (value namedTuples is not a member of object language.experimental) and so are Not found: x and value x is not a member of (Unit, Unit). On 3.5.2 and on 3.7.4 the program prints 3.

Source: Scala 3.5.0 released!

3.6.0 and 3.6.1 should never be used. While 3.6.0-RC1 was being released an accident published artifacts versioned as 3.6.0 to the immutable Maven repository, so 3.6.1 was released as a hotfix to stop automatic tooling from using the broken version, and 3.6.2 is "effectively 3.6.0 for all intents and purposes". The all-versions page lists 3.6.2 as the first 3.6 release, and a project that must pin 3.6 pins 3.6.2 or later (3.6.4 exists).

The 3.6 line is the one that changed how a type class instance is written:

On 3.5.2 it fails (an identifier expected, but 'def' found and Declaration of given instance Show not allowed here: only classes can have declared but undefined members); on 3.6.2 and on 3.10.0 it prints int:7. The old given Show[Int] with form still compiles. See Givens & Using Clauses and Context Bounds & Deferred Givens.

Source: Scala 3.6.2 is now available!

3.7.0 stabilised two SIPs, introduced the idea of a preview feature and changed given resolution.

SIP-58, named tuples, became stable: they give names to tuple elements for construction, destructuring and pattern matching, they allow matching a subset of case-class fields by name, and Selectable gained a Fields type member that can be a named tuple so that structural types can be computed without macros. The program of 3.5 above, without the import, is the stable form:

Source: Scala 3.7.0 released!, SIP-58: Named Tuples

It fails on 3.5.2 (Not found: x, Not found: y, value x is not a member of (Unit, Unit)) and prints 3 on 3.7.4 and on 3.10.0. See Tuples & Named Tuples.

SIP-52, binary APIs. @publicInBinary is stable. It lets an inline method access a non-public member without the compiler generating an accessor that is not subject to binary compatibility, and it allows an inline method to call a private constructor. -WunstableInlineAccessors (available since 3.4.0) reports the accessors that are generated.

Preview features. 3.7 introduced a stage between experimental and stable: "fully implemented and SIP-approved, but potentially subject to small refinements before becoming stable". Preview features are guaranteed to be standardised in a future minor release, may change in small and possibly binary incompatible ways, and are discouraged in published libraries; the -preview compiler option enables all of them at once. The first one was SIP-62, better fors. Without the option, 3.7.4 rejects it, and with the option it works:

Source: Scala 3.7.0 released!, SIP-62: For-comprehension improvements

(The ... stands for two lines of the compiler’s note about implicit conversions.) The -preview flag is the one that Scala 3.10 uses for its three preview SIPs, and the page on Language Evolution: SIPs, Preview & Experimental explains the whole experimental, preview, stable path.

Experimental in 3.7: SIP-61 (@unroll) and SIP-68 (referenceable package objects). Both became preview features in 3.10.

The given prioritization change. Announced in 3.5 and warned about in 3.6, the new rule applies from 3.7: given search now picks the most general instance that satisfies the request instead of the most specific one. The probe uses a covariant type class and asks for Pick[Animal] when both Pick[Animal] and Pick[Dog] are available:

Source: Scala 3.7.0 released!, New scheme for given prioritization

The result changed silently between 3.6.2 and 3.7.4 for this program, which is why -source:3.7-migration exists: it keeps the new rule but prints the warning above wherever the result differs, and -source:3.5 keeps the old rule.

Explicit arguments for implicit parameters. From 3.7 the compiler warns when an argument is passed to an implicit parameter list without using:

3.6.2 prints 30; 3.7.4 prints 30 after the warning Implicit parameters should be provided with a `using clause., which `-rewrite -source:3.7-migration fixes.

Other items from the release notes, not run here: the expression compiler behind the Metals and IntelliJ debug consoles moved into the compiler repository, the presentation compiler shows the expected type of a type hole on hover, the experimental subset of the Quotes API gained apply methods for import selectors and summonIgnoring, and the standard library moved to 2.13.16, where .tail and .init on the empty string throw instead of returning it.

Sources: Scala 3.7.0 released!, Scala 3.9 LTS released! (the section "Coming from Scala 3.3 LTS")

3.8 is the release that modernises the foundations. The announcement is dated 22 January 2026 and carries a warning that is part of the history: a runtime regression was detected after 3.8.0 was published (JVM linkage errors at runtime that could affect Scala 3 users who execute Scala 2.13 libraries and uses of specialized members of the standard library), so "please use Scala 3.8.1 instead"; two further bugs in 3.8.0 and 3.8.1 (incorrect behaviour of some for comprehensions and a compile failure with some Java standard library calls) were announced as fixed in 3.8.2, released on 24 February 2026. That is why this section tells you to use 3.8.2 or later; the last 3.8 release is 3.8.4 (5 June 2026), which includes fixes from the security audit of the Scala codebase (hardened TASTy parsing, a Scaladoc XSS fix).

What 3.8 changed:

Source: Scala 3.8 released!, Compiled with Scala 3

The fix is Array.empty(using ClassTag.Int) or, better, Array.empty[Int]. The migration is the reason that the notes recommend running 3.7.4 with -source:3.7-migration -rewrite before the bump. This is also the boundary at which Scala 2.13’s -Ytasty-reader stops being able to read Scala 3 libraries (it works up to 3.7), and at which scala.reflect.runtime.universe can fail when initialised against the Scala 3 standard library, the best-known case being Apache Spark; both are covered in Upgrading Between Scala 3 Versions. * App is deprecated. trait App has been deprecated since 3.8.0; on 3.10.0 and on 3.9.0 object Main extends App: with -deprecation prints trait App in package scala is deprecated since 3.8.0: Support for trait App is deprecated in Scala 3 and the program still prints its output. Use @main, see Hello World & @main Methods. * The REPL is a separate artifact (scala3-repl) rendered with fansi and pprint, so long values no longer dump as one unreadable line. * SIP-62, better fors, is stable. Aliases may start a for, and a final map is omitted when it would be the identity (see the probe in 3.7). 3.8.2 added a warning for a for with several val bindings and an overloaded map, because the result type can change: the 3.8.2 notes show a Map iterated with two aliases that yields List43,29), (43,30), (43,31 on 3.7 and Map(43 -> 31) on 3.8. * SIP-57, runtimeChecked, is stable. It replaces the : @unchecked ascription:

On 3.7.4 the compiler reports method runtimeChecked is marked @experimental and on 3.8.4 the program prints 80.

Sources: Scala 3.8 released!, Scala 3.8.2, Scala 3.8.3, Scala 3.8.4

3.9.0 opens the new LTS. It "succeeds Scala 3.3 LTS as the recommended baseline for library authors and conservative production users", it is guaranteed to be maintained for at least three years, and 3.3 LTS stays actively maintained for one year after 3.9.0 (3.3.9 is planned within a month of the announcement). Because the feature freeze held, 3.9 has the same feature set as 3.8 apart from what was promoted. Library authors should read one sentence of the announcement as a rule: artifacts built with 3.9 cannot be consumed by Scala 3.3 projects, so moving from 3.3 LTS to 3.9 LTS is a minor-version publishing decision for the libraries you maintain. The notes give the Open Community Build numbers behind the migration: about 1,780 of nearly 2,000 projects build on 3.9 with no or minimal changes.

Source: Scala 3.9 LTS released!

3.7.4: type into is marked @experimental. 3.8.4 without -preview: type into is marked @preview. 3.8.4 with -preview and 3.9.0 without any flag: List(1, 2, 3, 4). See Conversions, into & Implicit Resolution.

On 3.9, the older preview and experimental gates matter in a way that is easy to forget when reading 3.10 material: the three features that are preview features in 3.10 were still experimental in 3.9. @unroll on 3.9.0 is rejected with class unroll is marked @experimental: under review as part of SIP-61 and needs -experimental (or an experimental import), after which the same program prints Hello, Ana!; SIP-75 (xs.map: v => v + 1) fails on 3.9.0 with not a legal formal parameter for a function literal, and referenceable package objects fail too, as the next section shows.

Source: Scala 3.9 LTS released!

3.10.0 is the first release of the Scala Next series that follows 3.9 LTS, and the first release that removes legacy features. Binary compatibility is preserved (libraries compiled with earlier Scala 3 versions keep working, including those that used features now removed), but source that still uses the removed features must be updated. Because cross-compilation between Scala 2 and 3.10 is no longer supported, the notes expect cross-compiled libraries to stay on 3.9 LTS indefinitely; check a 3.10 artifact with MiMa 1.2.1 or later, which adds 3.9 and 3.10 support.

Stable: SIP-67. Under strictEquality, x == y still needs a CanEqual, but match on an enum or case object no longer does. The probe:

Source: Scala 3.10 released!, SIP-67: Strict-equality pattern matching

On 3.7.4 and on 3.9.0 it fails with Values of types Foo and Foo cannot be compared with == or != (under the case Foo.Bar pattern); on 3.10.0 it prints 1. See Pattern Matching and Multiversal Equality.

Preview features (-preview). SIP-61 (@unroll), SIP-75 (relaxed lambda syntax) and SIP-68 (referenceable package objects) moved from experimental to preview, and the experimental language imports that previously gated them are deprecated. SIP-74 (partial function literals with parentheses) is a fourth preview feature on 3.10.0: the SIP page says it is a preview feature in 3.10.0 and will be on by default in the next minor release, although the SIP list calls it "shipped" and the reference’s preview index does not list it yet. Three probes, each compiled without and with the flag:

The same probe with package lib and package object json (a val api = lib.json that treats the package object as a value) fails on 3.9.0 with package lib.json is not a value, on 3.10.0 with Preview package object values may only be used when compiling with the -preview compiler flag, and prints 42 on 3.10.0 with -preview. The SIP-74 probe xs.collect(case (a, b) if b > 2 => a) fails on 3.9.0 and on 3.10.0 with expression expected but case found and prints List(3) with -preview. @unroll behaves differently: on 3.10.0 the one-parameter probe compiled and printed Hello, Ana! without the flag, which is the same observation recorded in Versions, Compatibility & JDKs; pass -preview anyway.

Breaking changes. The notes list them; the ones demonstrated here:

New in the language and library. Java records can be used as extractor patterns, \s is a string escape for a space, and IArray has Factory, IsSeq and BuildFrom instances. The two probes:

(The second line is println(raw"a\sb"), where raw keeps the two characters.) For the record pattern, a Point.java holding public record Point(int x, int y) {}, compiled with javac and put on the class path, and the program Point(3, 4) match case Point(x, y) => println(s"point $x,$y") fail on 3.9.0 (Point cannot be used as an extractor in a pattern because it lacks an unapply or unapplySeq method with the appropriate signature) and print point 3,4 on 3.10.0. See Using Java from Scala.

Tools in 3.10. The distribution bundles Scala CLI 1.17.1 (Java instance main methods without a class on JDK 25 and later, //> using resource, and the lts version tag resolving to the 3.9 series), the REPL accepts //> using dep, //> using toolkit and //> using jar directives and gained :save and :replay, and Scala is now also published as .deb and .rpm packages. Scala CLI, the REPL and the packages are described in Scala CLI and Installing Scala; the REPL additions come from the release notes only and were not run here.

What is next. The notes say that 3.10.1 has its release branch cut and 3.10.2 will follow, and that development then moves to 3.11, expected around March or April 2027. 3.9 LTS remains the recommended publishing baseline.

Source: Scala 3.10 released!, SIP-74

The tools move on their own schedule. Those that the section teaches, with the dates that the official sources give:

The libraries and frameworks of the ecosystem, with their current versions, are collected in Ecosystem, and building with sbt, Mill and Scala CLI is described in sbt & Build Tools. The Toolkit modules are taught in Testing with MUnit, Files & Processes with OS-Lib, JSON with uPickle and HTTP Client with sttp.

Sources: sbt 2 is now available!, VirtusLab assumes responsibility for Scala 2 maintenance, Lagom repository notice, Akka license FAQ, Apache Pekko

The table maps what a Scala 2.13 programmer wrote to what Scala 3 offers, with the release in which the Scala 3 form arrived or changed. The old form usually still compiles for migration, unless the row says it is removed.

Each row is taught on its own page: start from Migrating from Scala 2 and Scala 2 & Scala 3 Compatibility.

The three books consulted for this section are Programming Scala 3rd edition (PS3), Learn Scala Programming (LSP) and Professional Scala (PRO). Each was written before some of the changes above. The table collects every outdated form with the current state on 3.10, the release where it changed, and the page that teaches the current form. Chapter references are the issue’s own mapping; the table contains no book text, only the forms and their replacements.

The rows show a pattern worth knowing before reading a book: the further a row is toward the top, the more likely the old form still compiles and only the style has changed; the further toward the bottom, the more likely the library or the tool itself has gone. The same statements are collected from the angle of the dropped features in Incompatibilities & Dropped Features.

The table repeats, as a release-history view, the stage of the features that moved during 3.5 to 3.10. The definitions of the three stages and the full lists are in Language Evolution: SIPs, Preview & Experimental.

A short decision list, taken from the release notes and the compatibility page:

Run on 2026-10-16 with Scala CLI 1.17.1 (scala run --server=false -S <version> File.scala, with the compiler fetched from Maven Central): the probes for binary literals (3.4.3 and 3.5.2), named tuples (3.4.3, 3.5.2, 3.7.4 and 3.10.0), better fors (3.6.4, 3.7.4 with and without -preview, 3.8.4), boundary (3.2.2 and 3.3.8), non-local returns (3.1.3, 3.2.2, 3.3.8 and 3.10.0), pattern bindings (3.1.3, 3.3.8, 3.8.4 and 3.10.0), fewer braces (3.2.2 and 3.3.8), A with B (3.3.8, 3.4.3, 3.9.0 and 3.10.0), the SIP-64 given syntax (3.5.2, 3.6.2 and 3.10.0), given prioritization (3.6.2, 3.7.4, 3.10.0 and with -source:3.5 and -source:3.7-migration), explicit arguments to implicit parameters (3.6.2 and 3.7.4), Array.empty(ClassTag.Int) (3.7.4 and 3.8.4), runtimeChecked (3.7.4 and 3.8.4), into (3.7.4, 3.8.4, 3.9.0), inaccessible companion givens (3.9.0 with and without -deprecation, 3.10.0), this at top level (3.9.0 and 3.10.0), the \s escape (3.9.0 and 3.10.0), SIP-67 (3.7.4, 3.9.0 and 3.10.0), @unroll (3.9.0 with and without -experimental, 3.10.0 with and without -preview), SIP-75, SIP-68 and SIP-74 (3.9.0 and 3.10.0 with and without -preview), Java record patterns (3.9.0 and 3.10.0 with the class compiled by javac), the Scala 2.13.18 program and the deprecations of Traversable, Stream and CanBuildFrom (2.13.18 and 3.10.0), the three dropped syntaxes (3.3.8 and 3.10.0), and scala --version. The 3.1.3 and 3.2.2 probes ran on JDK 17; the others on JDK 26.

Not run here, taken from the release notes and the official pages: the JDK 17 floor of 3.8 on a JDK older than 17 (no such JDK is installed on this machine), the REPL features of 3.8 to 3.10 (:dep, //> using in the REPL, :save, :replay), the Scala CLI features (JShell, JUnit 5, sbt 2 export, Sloth, WebAssembly), Scala.js 1.22 and its Wasm backend, native coverage and // $COVERAGE-OFF$, best-effort compilation, pipelined builds, the 3.8.3 optimizer, -Xmax-fuel, the Scala 2.13 TASTy-reader boundary, MiMa, sbt 2, the .deb and .rpm packages, and the statements about Akka, Pekko and Lagom, which are cited from their own pages.