Sbt (software)

sbt was originally released as an open-source project by Mark Harrah in 2008. Over the years, it has evolved significantly through numerous releases, each introducing new features, bug fixes, and enhancements. Here is an overview of the significant releases, along with the key changes and innovations they introduced: • sbt 0.3.2 (2008): This was the first official release of sbt. It introduced rudimentary features such as project definition, dependency management, and compilation. • sbt 0.7 (2009): Established the basic framework for constructing and managing Scala projects. Key features included incremental compilation, dependency management, and straightforward task execution. • sbt 0.10 (2011): Introduced a significant overhaul of the build definition syntax, making it more expressive and flexible. There were also enhancements in performance, dependency management, and configuration. • sbt 0.12 (2012): Improved support for multi-module projects, the ability to define custom configurations, and simplified plugin development. • sbt 0.13 (2013): Focused on usability and performance. This version introduced Activator, a web-based tool for creating and managing projects. Other features included incremental macro compilation, improved handling of build definition errors, and various performance optimizations. 0.13 remained the main sbt version for the next four years. • sbt 1.0 (2017): Introduced substantial changes to the sbt codebase, focusing on performance and stability, but also attempted to maintain compatibility with older versions as much as possible. New features included unified slash syntax for defining tasks and settings, improved dependency management, and Scala 2.12 as the language version used for build definitions. Furthermore, the switch to the new Zinc 1.0 incremental compiler further boosted incremental compilation performance. • sbt 1.1 (2018): This release launched the sbt server, enabling IDEs and other tools to interact with sbt via the Language Server Protocol (LSP). It also added cross-building support for Scala.js and Scala Native and improved the performance of various tasks. • sbt 1.3 (2019): This version significantly improved the user experience by speeding up dependency resolution by adopting Coursier as the default dependency manager. Further enhancements included improvements to the build caching mechanism and support for JDK 11. • sbt 1.5 (2021): Added support for Scala 3. Enhancements were also made to the BSP (Build Server Protocol) support, enabling better integration with IDEs. • sbt 1.8 (2022): This release brought updates to Coursier and improved Ivy support. • sbt 1.9 (2023): More updates to Coursier and a text-based menu to help with creating new projects. ==Build files==

An sbt build can be defined using a .sbt file Below is an example of build.sbt build definition: val scalaTest = "org.scalatest" %% "scalatest" % "3.2.14" val akkaVersion = "2.6.20" val akkaActor = "com.typesafe.akka" %% "akka-actor" % akkaVersion val akkaCluster = "com.typesafe.akka" %% "akka-cluster" % akkaVersion // Set the Scala version used by this build to 2.13.10. ThisBuild / scalaVersion := "2.13.10" ThisBuild / version := "0.1.0-SNAPSHOT" ThisBuild / organization := "com.example" lazy val root = (project in file(".")) .aggregate(helloCore) .dependsOn(helloCore) .settings( name := "Hello", // Add a single dependency, for tests. libraryDependencies += scalaTest % Test ) lazy val helloCore = (project in file("core")) .settings( name := "Hello Core", libraryDependencies += scalaTest % Test, // Add multiple dependencies. libraryDependencies ++= List(akkaActor, akkaCluster) ) ==Example use==

sbt may be invoked for each build command, or it may enter interactive mode if no command is given. To clean build products of the current build: $ sbt clean Multiple commands may be used on the same line. To run a single test named "Foo" and then publish exported jars: $ sbt "testOnly Foo" publish ==Extensibility and integration==

The functionality of sbt can be extended through a plugin architecture. Community-contributed plugins cover areas such as signing, packaging, publishing and releasing artifacts, connecting to other services such as blogs and databases, or integrating with other technologies. Both IntelliJ IDEA and VS Code support sbt through their Scala plugins. In both those IDEs, it is possible to create a new project with initial sbt build files, as well as if the project already includes an sbt build file, it can be used to generate the project's configuration for the given IDE. ==Comparisons==

The main alternatives for sbt among build tools are Gradle and Apache Maven, both established build tools for projects developed on the JVM platform. In the Scala ecosystem, another popular build tool is Mill. The choice between sbt, Gradle, Apache Maven, and Mill, depends on the specific requirements of your project and your familiarity with the tools. If you're working primarily with Scala, sbt or Mill might prove a better fit, while if you're working with multiple languages or technologies, one of the other two may be a better choice. == See also ==