The sbt 2 project has started the last mile process to lock down the 2.0.x branch. Depending on the bugs we discover, we are hopeful that a release candidate (currently 2.0.0-RC12) can graduate in a few weeks to a few months. www.scala-lang.org/blog/2026/0...

We've discovered and fixed a long-standing security vulnerability in sbt involving command injection on Windows - read more in the blog article:

Time to meet again 🥰 🙌 Scala Days 2026 🗓️ Conference 12 - 13 October 🛠️ Workshops 14 - 15 October 📍Berlin, Germany Looking forward to welcoming you this autumn! scala-lang.org/blog/...

🚀 The Scala bytecode optimizer just got ported to Scala 3! Write nice high-level code and let the optimizer make it faster. Try it out today in Scala 3.8.3-RC3!

🧪 Code coverage is a key part of maintaining high-quality Scala projects. We've recently made progress on making Scoverage more robust, expanding the way we test it, discovering and fixing new issues. Read more:

🛠️ sbt 2 is nearing stable release - let’s migrate the plugin ecosystem together! The new sbt2-compat plugin was developed by the Scala Center to simplify cross-building sbt plugins for sbt 1 and sbt 2. Learn more on how to migrate:

Please take a quick 5‑minute survey on Scala adoption and usage. Results will impact Scala’s roadmap, libraries, and tooling. Help shape the future of Scala! Brought to you by VirtusLab and the Scala Center. Survey: virtuslab.typeform.com/ScalaSurvey...

The Scala 2.13 TASTy reader remains useful for migrations and consuming Scala 3 artifacts, but it will never be able to consume Scala 3.8 and later artifacts. Scala 3.7 is the last minor version whose artifacts will remain consumable from Scala 2. details: scala-lang.org/blog/state-...

After a long freeze, the Scala 3 standard library is again open to contributions. The main place for contributing is now the Scala 3 repository. details and link to process document: www.scala-lang.org/blog/2026/0...

We’re happy to announce that Scala Workshop 2026 will take place in Brussels, co-located with ECOOP! 🎉 📍 Brussels, Belgium 🗓 Mon 29 Jun 2026 🎙️ Submit your 1–2 page talk proposal! 🕒 Deadline: 23 Mar 2026 👉 2026.workshop.scala-lang.org #Scala #ScalaLang #ProgrammingLanguages #ECOOP

Advent of Code 2025 recap and sample solutions with explanations: www.scala-lang.org/blog/2026/0... 💡 Consider recommending Advent of Code to Scala newcomers! There’s much learning in solving the puzzles, and further learning in comparing the published solutions to your own.

Postmortem on Scala 3.8.0: www.scala-lang.org/blog/post-m.... We are also working on a 3.8.2 release which will include a fix for scala/scala3#24673, which can cause some for comprehensions to behave incorrectly at runtime.

The Sovereign Tech Fund Invests in Scala: 🔐 security audits 🔧 sbt 2.0 📚 core library maintenance 💪 and long-term resilience for critical digital infrastructure Check out the announcement: www.scala-lang.org/b... 🙏 Huge thanks to @sovereign.tech

✨ Tracking effects and dependencies can quickly get subtle. This talk explores what it means to stay “on track” with tracked values and why it matters. Here’s "On track with tracked" by Kacper Korban

🔍 Growing functional programmers takes more than teaching syntax. This keynote reflects on how people actually learn FP and how to help that growth happen. Watch "Keynote: How to Grow More Functional Programmers" from Evan Czaplicki

🤖 Workflows tend to sprawl unless they’re designed carefully. This session looks at defining and running workflows in Scala with MeshCI. Check out "MeshCI: defining and running workflows in Scala" from Jakob Odersky

🧪 The Typelevel ecosystem has shaped how many of us write Scala today. This talk looks back at where it started, what it became, and what we learned along the way. Here’s "A Typelevel retrospective" by Arman Bilge

💡 Bridging the gap between code and business requirements is rarely clean or straightforward. This talk looks at Business4s to connect developers and business thinking. Watch "Business4s: Bridging the Gap Between Devs and the Business" from Voytek Pituła

✨ Large codebases don’t refactor themselves. This session explores Regenesca and how automated source-code refactoring can help keep Scala projects maintainable. Here’s "Regenesca - Refactoring Generator of Source Code for Scala" by Sakib Hadžiavdić

💡 Unsafe Rust raises strong opinions for a reason. This keynote digs into what “unsafe” really means, why it exists, and how to reason about it. Check out "Keynote: What's the deal with unsafe Rust?" from Ralf Jung

✨ Spec-first APIs don’t have to mean heavy code generation. This session shows how far you can get by leaning on imports and types instead. Here’s "Just Import 'N' Go: Spec-first APIs without codegen" by Tomas Mikula

🧪 Curious how compilers actually work under the hood? This talk makes a case for learning compiler engineering as a way to become a stronger programmer overall. Here’s "Become a Compiler Engineer (and a Better Programmer)" by Jan-Pieter van den Heuvel

🤖 sbt 2.0 is a major shift under the hood. This session dives into what’s changing, why it matters, and what “going big” really means. Check out "sbt 2.0: go big" from Eugene Yokota

🔍 Capture checking keeps moving from theory toward practice. This talk focuses on the first concrete steps and what they enable in real Scala code. Watch "The first steps towards practical capture checking" from Cao Nguyen Pham

💡 Building libraries that run at Netflix scale comes with very real constraints. This talk walks through designing a Scala 3 library that powers QoE systems in production. Watch "Designing the library powering Netflix's QoE with Scala 3" from Joan Goyeau

💡 Learning Scala isn’t always a straight line. This talk shares a personal journey through Scala and drumming, with all the parallels, struggles, and small wins along the way. Check out "From Paradigms to Percussion:" from Priyanka Bose

✨ Big-picture questions matter just as much as new features. This keynote reflects on where Scala stands today and how its capabilities are shaping real-world use. Here’s "Keynote: Where Are We With Scala's Capabilities?" by Martin Odersky

🔍 Some systems run on rules nobody ever writes down. This session explores how to model and implement those unspoken rules using Scala 3. Watch "Coding the game of unspoken rules in Scala 3" from Adrien Piquerez and Benoît Fouré

🤖 HTTP routing is one of those problems that looks simple until it isn’t. This talk walks through routing HTTP requests using Scala 3, focusing on clarity and correctness. Check out "Routing Http Requests with Scala 3" from Noel Welsh

🧪 Tooling makes a huge difference in how Scala feels day to day. This session dives into Metals and how to get the most out of it. Here’s "Unleashing the Full Potential of Metals" by Tomasz Godzik

🧪 Scala sometimes ends up far from traditional software. This talk dives into chip design and how Scala was used from early ideas to real hardware. Here’s "Scala Chip Design from Z1R0 to H1R0" by Oron Port

✨ Serializing closures sounds risky, but it doesn’t have to be. This session walks through a simple and safe approach to pickling closures in Scala 3. Here’s "Simple and Safe Pickling of Closures in Scala 3" by Jonas Spenger and Philipp Haller

💡 Effect safety often stays abstract until you see a concrete model. This talk introduces Capture Checking and shows how it changes the way effects are tracked and reasoned about in Scala. Check out the Scala Days talk from Oliver Bračevac

🔍 AI tools are starting to blend into everyday Scala workflows. This talk looks at what JetBrains is building and how it fits into real development. Watch "AI Tooling for Scala Developers: What JetBrains Brings to the Table" from Maciej Gorywoda

🤖 Many teams don’t live in a Scala-only world. This session shares what it’s like to use Scala inside a Go-first company and where it shines. Check out "Using Scala in a Go-First Company" from Christian Hollinger

📈 A decade of Scala in production was a big part of the conversation at Scala Days with Kpler. From high-performance systems to data-driven engineering, their presence reflected long-term commitment to building reliable software with Scala.

💡 Audio work in Scala goes deeper than you might expect. This talk explores audio processing using Scala Native and FS2, with a focus on performance and structure. Check out "Scala and Arpeggio: Audio processing with Scala Native and FS2" from Will Binzi

✨ Full-stack Scala sounds nice in theory, but what does it look like in practice? This session shares lessons learned from building a real ML platform end to end. Here’s "The power of full-stack Scala" by Olga Chuchuk and François Laroche

🤖 WebAssembly keeps opening new doors for Scala. This session walks through compiling Scala.js to WebAssembly and what that enables. Check out "Compiling Scala.js to WebAssembly" from Sébastien Doeraene

⚡ Faster feedback cycles were a key theme at Scala Days, and Gradle brought that conversation to sbt users. From build insights to performance metrics, their presence sparked thoughtful discussions around making Scala builds faster and more observable.

🔍 LLMs promise a lot, but can they actually help us write safer code? This talk takes a critical look at using LLMs in Scala with a focus on verification. Watch "Safe Coding with LLMs: Verifiable Scala Silver Bullet ?" from Andrei Kucharavy

🧪 Large builds get painful fast without good automation. This talk looks at using Scala Gazelle to keep Bazel builds on track with less manual work. Here’s "From Imports to Targets: Bazel on Autopilot with Scala Gazelle" by Wojciech Mazur

🤖 Direct-style programming can feel elegant until you try to compose it. This session explores what happens when flatMap enters the picture. Check out "Yo Dawg, Heard You Want To FlatMap Your Direct-Style" from Riccardo Cardin

🧪 Building APIs for real-world systems comes with constraints. This talk walks through designing and implementing gRPC APIs for autonomous driving in Scala. Here’s "gRPC APIs for Autonomous Driving from Design to Implementation in Scala" by Bendix Sältz

✨ Productivity isn’t just about tools, it’s about how you use them. This session looks at the intersection of Scala, developer productivity, and AI. Here’s "Scala, Productivity, and AI" by Krzysztof Romanowski

🛠️ Tooling and developer experience were front and center at Scala Days with JetBrains. From AI-assisted workflows to hands-on discussions around the IntelliJ Scala Plugin, their booth was a great place to talk Scala, IDEs, and what developers need next.

🔍 Performance problems often come from patterns that look fine at first glance. This talk explores common Akka anti-patterns and how to avoid them. Watch "Akka Unplugged" from Lukasz Marchewka

💡 Small workflow improvements add up fast. This talk digs into IntelliJ IDEA and the Scala plugin, with tips that actually make day-to-day work smoother. Check out "Boost Your Productivity with IntelliJ IDEA and Scala Plugin" from Dmitrii Naumenko

🔍 How does FP hold up once it leaves the whiteboard? This panel digs into where FP shines, where it struggles, and how it shows up in real teams. Watch "Panel: Functional Programming And the Real World" from Dimi Racordon and Evan Czaplicki

💡 Real-world GenAI gets messy. This talk looks at how streaming, RAG, and real-time systems come together at scale using Scala and FS2. Check out "LLMs in the Wild: Streaming, RAG, and Real-Time GenAI at Scale with Scala and FS2" from Muayad Sayed Ali