Open-source project
sbt/sbt avatar
sbt/sbt

sbt 2.x is three repositories and a develop branch, and its README is a list of links

sbt, the interactive build tool

4,956 stars1,052 forksScalaApache-2.0

At a glance

What is it?
The interactive build tool for Scala and Java, whose source no longer lives in one place: this repository holds the modules that implement the tool, sbt/io holds sbt.io, sbt/zinc holds the Zinc compiler, and the README itself is four pointers to setup, help and the old 0.7 line.
Who is it for?
sbt is the right tool for a Scala or Java build where you want an interactive shell rather than a declarative script.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 4 days ago.
What is it written in?
Mainly Scala, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • sbt/sbt4,956 ★ · +2
Star history
Repository2026-09-232026-11-15
sbt/sbt5k5k

2 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

One tool, three repositories, and a branch called develop

sbt is a build tool for Scala, Java, and more, and the repository you are looking at is the 2.x series. The first thing the README settles is where the source lives, because it is no longer in one place. The source code of sbt is split across several GitHub repositories, including this one. sbt/io hosts the sbt.io module. sbt/zinc hosts Zinc, an incremental compiler for Scala. sbt/sbt, this repository, hosts the modules that implement the build tool. That split has an immediate effect on anyone filing a problem: a compilation issue belongs to Zinc, an I/O or file-watching issue belongs to sbt.io, and only what is left belongs here. Default branch is develop, not main, so a patch targets develop.

There is no install command, only a link to Setup

The README contains no installation command, no package manager snippet and no installer script, which is unusual for a tool distributed as a binary. What it offers instead is a Setup page on scala-sbt.org that describes getting started with the latest binary release, and a FAQ page for getting help. For anything older, the README names a third repository, sbt-zero-seven, which hosts sbt 0.7.7 and earlier versions. So moving off a very old sbt is a repository and documentation change, not only a download. The launcher and build entry points that exist inside this repository are these:

text
sbt
sbt.sh
sbt-allsources.sh
build.sbt

The two shell entry points and the all sources script are the parts a contributor touches; a user installing sbt has nothing to do with any of them. The practical consequence for a first run is that you take the binary from the Setup page and point it at your build definition.

Two release lines publish from the same branch

Recent tags show three lines shipping from one repository, all on 2026-10-28: v2.0.12 on the stable 2.0 line, v2.1.0-RC2 on the next line, and v1.13.1 on the 1.x line. The last push to the repository is dated 2026-10-31, three days after those tags. Two things follow for a build you intend to keep. A pre-release tag is a moving API with a version-shaped name, so pinning v2.1.0-RC2 means accepting that the next candidate can change behaviour under the same number with a different suffix. And the pairing of a stable 2.0 release with a 2.1 release candidate says the 2.1 line is where new work is landing while 2.0.12 is the conservative choice. Neither point is stated in the README, which covers neither release cadence nor a support window for either line.

sbt builds itself from a multi-module root

The top level of this repository is a build definition, and it is an sbt build. The modules are directories named after what they do: main/, tasks/, main-command/, main-settings/, tasks-standard/, core-macros/, internal/, client/, protocol/, util-cache/ and util-collection/, alongside project/ for the meta-build, buildfile/, launch/ and launcher-package/ for the launcher, notes/ for release notes, run/ and src/ for the runnable pieces. Testing has its own territory in testing/, scripted-sbt/ and server-test/, and community-build/ sits beside them. This arrangement is the practical answer to how a build tool stays consistent: it consumes itself, so a change to task evaluation has to survive sbt building sbt. The cost is onboarding, since a newcomer needs a working sbt, a matching JDK and knowledge of which of those directories owns the code they intend to touch.

Contributors are pointed at CONTRIBUTING.md before anything else

The README spends more of its length on how to contribute than on how to build, and it is specific: read CONTRIBUTING carefully before opening a GitHub issue or a pull request. For people looking for something to start on, it names two issue labels, good first issue and help wanted, as starting points. Questions are routed away from the tracker on purpose. If you want to ask a question about sbt there is an sbt channel on Scala Discord, and the README asks you to gather questions on Stack Overflow first, which is a reasonable division between answers worth keeping and conversation. The same care shows in the tree. CONTRIBUTING.md has a companion directory, contributing-docs/, and the root also carries SUPPORT.md, AGENTS.md, CLAUDE.md, an .agents/ directory and LLM_POLICY.md. That last file matters to anyone submitting machine-generated code: the project states a policy for it rather than leaving contributors to guess.

Toolchain and formatting live in root dotfiles

The build is pinned by files whose names do the talking. .java-version sits at the root for the JDK, alongside .jvmopts for JVM options and .sbtopts for options handed to sbt when it runs, which is the trio that decides whether your machine builds sbt the same way as everyone else's. Formatting and linting are configured too, with .scalafmt.conf and .scalafix.conf, and .prettierignore for files excluded from the other formatter. .scala-steward.conf configures the bot that keeps dependencies updated, .git-blame-ignore-revs records revisions to be skipped when git blame walks history, and .gitattributes with .gitmodules handle line endings and submodules. .devcontainer/ and .mailmap are there as well, and PROFILING.md at the root is where performance work is written down. For a contributor, the practical reading order is those dotfiles before build.sbt, because they decide what your editor will argue with you about.

Apache-2.0 with a NOTICE file and no stated support window

The licence is Apache-2.0, and the README's normative section is two lines long: see LICENSE. The tree carries LICENSE, NOTICE and a licenses/ directory, which is the standard shape for an Apache-2.0 project that carries third-party attributions, and it is where anyone redistributing sbt inside a product should start reading. This is not legal advice and the README does not interpret the licence. What the README does not state is just as relevant to an adopter: there is no support policy for a 2.x version, no list of versions still receiving fixes, and no migration note beyond the statement that this repository is the 2.x series. The older line is handled by pointing at sbt-zero-seven; the root does carry a SUPPORT.md file.

Editorial conclusion

sbt is the right tool for a Scala or Java build where you want an interactive shell rather than a declarative script. Before adopting the 2.x line, check two things against your own build: that whichever repository your problem actually lives in is the one you file it against, since sbt.io and Zinc are separate projects with their own trackers, and that the release you pin is a stable tag rather than a release candidate, because v2.1.0-RC2 was published on the same day as v2.0.12. Projects still on 0.7.7 or earlier need to read the Setup page for the current binary release before anything else, since that code now sits in the sbt-zero-seven repository.

Frequently asked questions

Where does the source of sbt 2.x actually live?

It is split across several GitHub repositories. sbt/io hosts the sbt.io module, sbt/zinc hosts Zinc, the incremental compiler for Scala, and sbt/sbt, this repository, hosts the modules that implement the build tool.

How do I get the latest binary release of sbt?

The README does not include an install command. It points to the Setup page on scala-sbt.org, which describes getting started with the latest binary release, while sbt 0.7.7 and earlier versions are hosted in the sbt-zero-seven repository.

What is the difference between sbt v2.0.12 and v2.1.0-RC2?

They are separate release lines: v2.0.12 is a stable 2.0 release and v2.1.0-RC2 is a release candidate for 2.1, both tagged on 2026-10-28 alongside v1.13.1. The README covers neither release cadence nor a support window for either line.

What is sbt testing?

The repository carries testing/, scripted-sbt/ and server-test/ directories alongside a community-build/ directory. The README does not document how to run them, so the build definition in build.sbt and the project/ meta-build are where that has to be worked out.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. README
  4. Releases
  5. sbt/sbt on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/sbt-sbt.svg)](https://hysenlabs.com/projects/sbt-sbt)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/sbt-sbt.svg)](https://hysenlabs.com/projects/sbt-sbt)

Was this useful?