Explore key insights from the Scala Survey 2026, including Scala 3 adoption rates, popular libraries, tooling preferences, and industry trends shaping the future of the Scala ecosystem.
Languages like Rust mitigate these problems through ownership and lifetimes. But how do we bring these ideas into a GC-based language like Scala in a way that doesn't break existing programs? In other words, we want to track access rights (capabilities) to resources (objects in the object-capability model), while leaving memory management to the GC. Scala 3's answer is Capture Checking + Separation Checking.
Concurrency in Scala has come a long way from the humble beginnings of scala.concurrent.Future. What started as a minimal abstraction over callbacks that allowed easy sequencing of operations, thanks to the monadic composition has since evolved into a rich ecosystem of effect systems, each trying to solve real-world problems around type and resource safety, composability, and performance.
The Cats library and the related Cats Effect were inspired by scalaz and scalaz-concurrent libraries (and, more broadly, by Haskell and its ecosystem). They represent the most widely adopted effect system in the Scala ecosystem. In this context, effects are values representing descriptions of computations that can be composed using typeclass-based abstractions like Functor, Monad, or Sync, as provided by Cats and Cats Effect. This approach promotes the use of pure functions and referential transparency - the principle that any expression can be replaced by its evaluated result without changing the program's behavior.
Kyo is one of the younger kids on the block - at the time of writing of this blogpost it has only reached its first release candidate for version 1.0. It is the brainchild of Flavio Brasil, a tenured Scala open source author and contributor who, in the past, created Quill, an SQL library based on Scala’s metaprogramming facilities and contributed to Twitter’s Finagle stack. Kyo attempts to take the idea of fused effects introduced in the ZIO monad and generalise it to provide a complete algebraic effects runtime and solve the “monads do not compose” problem at the same time. In practice, Kyo is also a purely functional, monadic solution but it’s built for the future and uses a lot of new features of Scala 3 to aggressively avoid allocations and inline common operations.
AI agents are powerful: they can execute many day-to-day tasks thanks to their understanding of the surrounding context. That's what sets them apart from ordinary automations. However, they can also go wrong in various ways. That's why giving an agent free access to your computer might not be the best idea. For many reasons: starting with agent incompetence, where a "photo cleanup" request ends up with all of your photos permanently removed, instead of neatly organized into folders. There are several options for restricting the actions an AI agent can perform. Safe Scala provides tools to achieve just that. Let's take a short overview of how Safe Scala works and what the alternatives are.
While being the best language out there, Scala isn't (yet?) the most ubiquitous language for developing business applications. But we're on a mission to change that! Starting with what everybody's doing right now, of course: generating applications using Claude Code or other LLMs. AIs have a strong understanding of the most popular application stacks, such as TypeScript, Java, and Python. But how does an AI agent fare when tasked with writing a Scala 3 application?
WebAssembly (Wasm) is a binary instruction format and low-level language that runs in various environments, including browsers. While it was originally designed for browser applications, its adoption is expanding beyond browsers into cloud and edge computing environments, due to Wasm's features. This article explains the advantages of compiling Scala to Wasm and future prospects.
Gatling proved to be an excellent tool for performance testing - especially in monolithic environments. It integrated well into traditional CI pipelines, and its DSL made writing tests both expressive and maintainable. But as our architecture evolved toward microservices and cloud-native deployments, performance testing became significantly more complex. In this article, we will look at an alternative approach to Gatling, one that overcomes its out-of-the-box limitations.
Test suites have grown in size and complexity. What used to be a quick validation step has become a bottleneck that can significantly impact development velocity. The solution is to distribute test execution across multiple machines, running different test groups in parallel.
Modern infrastructure as code (IaC) solutions have automated much of the cloud provisioning process, yet they still lack robust correctness guarantees, leading to costly misconfigurations and inefficiencies. TypeOps introduces the power of type systems to DevOps, enabling compile-time validation of infrastructure code, reducing errors before deployment, and ensuring more reliable and scalable cloud operations.
Companies, especially mid-sized and larger ones, face the challenge of structuring projects at scale. Arguably, almost every technology and paradigm can be used by a single developer to write a small piece of code, but obviously, this is not enough for any organization—engineering solutions must allow people from multiple disciplines to develop and maintain the application efficiently throughout the whole application lifecycle.
