Illustrative image: a terminal window — Scala programs are typically compiled and run from the command line. Image: Wikimedia Commons. This is not a Scala product image; the release itself has no product photograph.
TL;DR — Scala 3.10 new features explained in one line: Scala 3.10.0, released 12 October 2026, is the first release of the new Scala Next line — it stabilises strict-equality pattern matching, previews three new language features, and finally deletes Scala 2-era syntax that has been deprecated for years, so most apps upgrade cleanly but libraries with macros need a check, and teams wanting the longest support window should stay on Scala 3.9 LTS for now.
📌 KEY HIGHLIGHTS
- Released 12 October 2026: Scala 3.10.0 opens the Scala Next series, the fast-moving line that follows the Scala 3.9 LTS release of 3 September 2026.
- One feature goes stable: SIP-67 strict-equality pattern matching — match on enums and ADTs under strictEquality without proving CanEqual, while == itself stays strict.
- Three features in preview: @unroll default arguments (SIP-61), relaxed lambda syntax (SIP-75) and referenceable package objects (SIP-68), all behind the -preview flag.
- The breaking change that matters: Scala 2 compatibility syntax such as A with B is now an error, and cross-compilation between Scala 2 and 3.10 is no longer supported.
- What is next: Scala 3.10.1 reached release-candidate stage on 25 October 2026, with the stable 3.10.1 planned no earlier than 11 November — the 2 November Scala newsletter is the freshest roundup of the line.
Scala 3.10 new features explained: what actually shipped
Scala is a programming language that runs on the Java Virtual Machine and mixes object-oriented and functional programming. It is the language behind data tools such as Apache Spark and many backend services, so a new Scala release is a working-developer story, not a consumer one. Scala 3.10.0, announced by the Scala team on 12 October 2026, is the first release of what the team now calls Scala Next: the line that moves fast, adds features and drops old ones, sitting alongside Long-Term Support (LTS) releases that change only in patches.
The headline distinction is the one the announcement itself stresses. Scala 3.3 LTS and Scala 3.9 LTS put compatibility with Scala 2.13 first. Nearly five years after Scala 3.0, version 3.10 starts removing legacy syntax and features that have been deprecated for several minor releases. The standard library also starts using more Scala 3 features itself, such as inline and extension methods. Binary compatibility is preserved — libraries compiled with earlier Scala 3 versions keep working, including ones that used features now removed — but source code that still uses those features must be updated before it will compile under 3.10.
What is new: one stable feature, three previews
The stable addition is SIP-67. With strictEquality turned on, comparing two values with == requires a CanEqual instance, so you cannot compare unrelated types by accident. Until now that safety also got in the way of ordinary pattern matching: matching on an enum case is implemented with == under the hood, so the compiler demanded CanEqual even when you only wrote match. SIP-67, experimental since Scala 3.8, is now stable, so it applies whenever strictEquality is enabled — you can match on enums and algebraic data types without proving CanEqual, while == itself remains strict.
Illustrative image: a data centre — the kind of infrastructure Scala backend services run on. Image: Wikimedia Commons / BalticServers, CC BY-SA 3.0.
| Feature | Status in 3.10 | What it does |
|---|---|---|
| SIP-67 strict-equality pattern matching | Stable | Match on enums/ADTs under strictEquality without a CanEqual proof; == stays strict |
| SIP-61 @unroll default arguments | Preview (-preview) | Keeps old JVM method signatures as forwarders when a parameter with a default is appended, so old binaries still link |
| SIP-75 relaxed lambda syntax | Preview (-preview) | A lambda after : can sit on the same line (xs.map: v => v + 1), not just on an indented block |
| SIP-68 referenceable package objects | Preview (-preview) | Treat a package object itself as a value, where previously you could only call its members |
| Scala 2 legacy syntax (e.g. A with B) | Removed (error) | Write A & B instead; the -source:3.4-migration -rewrite flag rewrites it for you |
Two smaller changes are worth knowing. Scala is now also distributed as .deb and .rpm packages, which simplifies installation on Debian- and Red Hat-based Linux. And the compiler now reports "Recursion limit exceeded" instead of crashing with a StackOverflowError on very deep types — a clearer failure, though very deep types may now need the -Xmax-fuel flag raised.
What breaks, and who should wait
Most projects can upgrade without code changes, according to the announcement — but macros and compiler plugins are affected most. The announcement names the traps: givens hidden in a private companion object are no longer found by implicit search; the old RichInt-style wrappers are now extension methods; and the -> pair syntax is now an inline extension method rather than an implicit conversion, which changes how quote patterns match. Library maintainers shipping macros are told to add a CI job against Scala Next nightly builds. The announcement also gives concrete upgrade-first versions for the ZIO ecosystem: ZIO 2.1.26, zio-blocks 0.0.54, izumi-reflect 3.0.10 and neotype 0.7.2.
The other hard edge is Scala 2. Cross-compilation between Scala 2 and 3.10 is no longer supported because of the removed legacy features, and the announcement expects cross-compiled libraries to remain on Scala 3.9 LTS indefinitely. If you publish a library and want the longest support window, the announcement is explicit: Scala 3.9 LTS remains the recommended version to build against. Before checking a 3.10 artifact with the MiMa compatibility checker, upgrade to MiMa 1.2.1 or later, which adds Scala 3.9 and 3.10 support.
Why it matters for India readers
There is no India-specific Scala announcement here, and this post claims none. The relevance is practical: India has a large Java and JVM developer base, and Scala is one of the main languages that base meets in data engineering and backend work — Spark jobs, streaming pipelines and microservices. For a student or developer learning Scala today, 3.10 is the version whose syntax is the cleanest statement of where the language is going, and the preview features are the ones that will shape code written next year. For a team running Scala in production, the decision is the opposite of exciting: stay on 3.9 LTS unless you need a 3.10 feature, because LTS is where the support window is longest and where cross-compiled libraries will live. And if you are setting up a fresh Linux machine to try it, our Arch Linux November 2026 ISO explainer covers the current toolchain snapshot, while our GitHub pull_request_target December 2026 audit guide is the same "check your automation before a deadline moves" discipline applied to CI.
Should you care?
✅ Verdict: Yes, if you write or maintain Scala — but upgrade on purpose. Try 3.10 on a branch to learn the new syntax and to catch macro breakage early, especially if you use ZIO. ⏳ Keep production libraries on 3.9 LTS until 3.10.1 lands and your dependencies publish 3.10 builds — the Next line rewards early testers, not early migrators.
FAQs
What is Scala 3.10?
Scala 3.10.0, released 12 October 2026, is the first release of the Scala Next series — the fast-moving Scala 3 line that adds features and removes deprecated ones, as opposed to the LTS line, where only patch releases ship. It stabilises SIP-67 and previews three further SIPs.
Should I upgrade to Scala 3.10 or stay on Scala 3.9 LTS?
Stay on 3.9 LTS if you publish a library or want the longest support window — the Scala team itself recommends 3.9 LTS for that. Move to 3.10 if you want the newest language features, are learning Scala, or maintain a project whose dependencies already publish 3.10 builds.
Does Scala 3.10 break my existing code?
Most projects upgrade without changes, but code using long-deprecated Scala 2 syntax — such as A with B as a type — now fails to compile, and macros or compiler plugins may need adapting. Binary compatibility is preserved, so libraries compiled with earlier Scala 3 versions keep working.
What is Scala Next vs Scala LTS?
Scala Next gets new minor releases every few months with new features and removals; Scala LTS gets only patch releases that stay compatible in both directions. Scala 3.9, released 3 September 2026, is the current LTS; 3.10 is the first Next release after it.
When is Scala 3.10.1 coming?
The first release candidate of Scala 3.10.1 was published on 25 October 2026, bumping Scala CLI to 1.18.0, with the stable release planned no earlier than 11 November 2026. If you hit a 3.10.0 bug, the RC is the version to test against first.
Takeaway: Scala 3.10 is the language tidying its own house — one stable fix, three previews, and the Scala 2 past finally switched off. Learn it now, migrate production on the LTS timetable.
Follow World Tech on TechByCountry for tomorrow's update.
📸 Get tech in the last 24 hours on Instagram — follow @_techinlast24hrs for daily posts (9 AM–9 PM) and reels at 12:30 PM & 8:30 PM.
Comments
Post a Comment