The sbt organization is available for use by any sbt plugin. Developers who contribute their plugins into the community organization will still retain control over their repository and its access. The goal of the sbt organization is to organize sbt software into one central location.

A side benefit to using the sbt organization for projects is that you can use gh-pages to host websites under the https://www.scala-sbt.org domain.

The sbt autoplugin giter8 template is a good place to start. This sets up a new sbt plugin project appropriately. The generated README includes a summary of the steps for publishing a new community plugin.

Lightbend has provided a freely available Ivy Repository for sbt projects to use. This Ivy repository is mirrored from the freely available Bintray service. If you'd like to submit your plugin, please follow these instructions: Bintray For Plugins.

See Cross Build Plugins.

[Edit] this page to submit a pull request that adds your plugin to the list.

• sbt-scalafmt: code formatting using Scalafmt.
• sbt-scalariform: code formatting using Scalariform.
• neo-sbt-scalafmt: code formatting using Scalafmt.
• sbt-java-formatter: code formatting for Java sources.
• sbt-source-format: code formatting for Java and clang (c/c++/objc) sources.
• safety-plugin: Enforce the use of style rules across your company

• tut: documentation and tutorial generator.
• Laika: Transform Markdown or reStructuredText into HTML or PDF with Templating.
• sbt-site: site generator.
• sbt-microsites: generate and publish microsites using Jekyll.
• sbt-unidoc: create unified API documentation across subprojects.
• sbt-ghpages: publish generated sites to GitHub pages.
• sbt-class-diagram: generate class diagrams from Scala source code.
• sbt-api-mappings: generate Scaladoc apiMappings for common Scala libraries.
• literator: generate literate-style markdown docs from your sources.
• sbt-example:  generate ScalaTest test suites from examples in Scaladoc.
• sbt-delombok:  delombok Java sources files that contain Lombok annotations to make Javadoc contain Lombok-generated classes and methods.
• sbt-alldocs: collect all the docs for a project and dependencies into a single folder.
• sbt-apidoc: A port of apidocjs to sbt, to document REST Api.
• sbt-github-pages (docs): publish a website to GitHub Pages with minimal effort - works well with GitHub Actions.
• sbt-docusaur (docs): build a website using Docusaurus and publish to GitHub Pages with minimal effort - works well with GitHub Actions.
• sbt-hl-compiler: compile the code snippets from documentation (to keep it consistent).
• sbt-scaladoc-compiler: compile the code snippets included in Scaladoc comments.

• sbt-assembly: create fat JARs.

• sbt-native-packager (docs): build native packages (RPM, .deb etc) for your projects.
• sbt-pack: create runnable distributions for your projects.
• sbt-bintray: publish artefacts to Bintray.
• sbt-sonatype: publish artefacts to Maven Central.
• sbt-release: create a customizable release process.
• sbt-pgp: sign artefacts using PGP/GPG and manage signing keys.
• sbt-docker: create and push Docker images.
• sbt-aether-deploy: publish artefacts using Eclipse Aether.
• sbt-rig: opinionated common release steps.
• sbt-s3: manage objects on Amazon S3.
• sbt-osgi: create OSGi bundles.
• sbt-github-release: publish Github releases.
• sbt-hadoop: publish artifacts to the Hadoop Distributed File System (HDFS).
• sbt-publish-more: publish artifacts to several repositories
• sbt-deploy: create deployable fat JARs.
• sbt-release-fossil: enhances sbt-release to support Fossil repositories
• sbt-autoversion: automatically set your next version bump based on patterns of your commit message since last release.
• sbt-gcs: manage objects on Google Cloud Storage.
• sbt-sourcebundler: merge all source code into one scala file.
• sbt-kubeyml: Create a typesafe kubernetes Deployment based on your project settings
• sbt-k8s: Create any manifest or use provided cookbooks using scala-k8s library
• sbt-release-notes: provide a Release Step for sbt-release to automatically update the release notes file.

• sbt-heroku: deploy applications directly to Heroku.
• sbt-docker-compose: launch Docker images using docker compose.
• sbt-appengine deploy your webapp to Google App Engine.
• sbt-marathon: deploy applications on Apache Mesos using the Marathon framework.
• sbt-riotctl: deploy applications as systemd services directly to a Raspberry Pi, ensuring dependencies (e.g. wiringpi) are met.
• sbt-kind: load built docker images into a kind cluster.

• sbt-revolver: auto-restart forked JVMs on update.
• sbt-conscript (docs): distribute apps using GitHub and Maven Central.
• sbt-git: run git commands from sbt.
• sbt-errors-summary: show a summary of compilation errors.
• MiMa: binary compatibility management for Scala libraries.
• sbt-groll: navigate git history inside sbt.
• sbt-dynver: set project version dynamically from git metadata.
• sbt-prompt: add promptlets and themes to your sbt prompt.
• sbt-crossproject: cross-build Scala, Scala.js and Scala Native.
• sbt-proguard: run ProGuard on compiled sources.
• sbt-structure: extract project structure in XML format.
• sbt-jni: helpers for working with projects that use JNI.
• sbt-jol: inspect OpenJDK Java Object Layout from sbt.
• sbt-musical: control iTunes from sbt (Mac only).
• sbt-travisci: integration with Travis CI.
• horder: cache compilation artefacts for future builds.
• sbt-javaagent: add Java agents to projects.
• sbt-jshell: Java REPL for sbt.
• sbt-check: compile up to, and including, the typer phase.
• sbt-mima-version-check: Automate which Mima Versions to Check
• sbt-tmpfs: utilize tmpfs to speed up builds.
• sbt-sh: run shell commands from sbt.
• sbt-ammonite-classpath: export classpath for Ammonite and Almond.
• sbt-version-scheme-enforcer-plugin: Derive Mima settings for your library from your declared versionScheme. This supports Early SemVer, Strict SemVer, and Package Versioning Policy (PVP).
• sbt-dotenv: load environment variables from .env into the JVM System Environment for local development.

• sbteclipse: Eclipse project definition generator.
• sbt-sublime: Sublime Text project generator.

• scripted: integration testing for sbt plugins.
• sbt-jmh: run Java Microbenchmark Harness (JMH) benchmarks from sbt.
• sbt-doctest: generate and run tests from Scaladoc comments.
• gatling-sbt: performance and load-testing using Gatling.
• sbt-multi-jvm: run tests using multiple JVMs.
• sbt-scalaprops: scalaprops property-based testing integration.
• sbt-testng: TestNG framework integration.
• sbt-jcstress: Java Concurrency Stress Test (jcstress) integration.
• sbt-stryker4s: Test your tests with mutation testing.
• sbt-cached-ci: Incremental sbt builds for CI environments.

• coursier: pure Scala dependency fetcher.
• sbt-dependency-graph: create dependency graphs using GraphML, graphviz or ASCII.
• sbt-updates: list updated versions of dependencies.
• fm-sbt-s3-resolver: resolve and publish artefacts using Amazon S3.
• sbt-s3-resolver: resolve dependencies using Amazon S3.
• sbt-dependency-check: check dependencies for known vulnerabilities/CVEs.
• sbt-lock: create a lock file containing explicit sbt dependencies.
• sbt-license-report: generate reports of licenses used by dependencies.
• sbt-duplicates-finder: detect class and resources conflicting in your project's classpath.
• sbt-google-cloud-storage: resolver and publisher for Google Cloud Storage.
• sbt-trace: find traces of the client or library usage in other projects.
• safety-plugin: Enforce the use of specified versions of dependencies across your company
• sbt-dependency-lock: generate dependency lockfiles and check for changes at build time.
• sbt-unzip: Extract zip dependencies where you want in your project.
• sbt-license-check: check and report on licenses used, fail build for disallowed licenses.
• sbt-pekko-version-check: check if the Apache Pekko modules match, fail build if they don't.

• Play Framework: reactive web framework for Scala and Java.
• Scala.js: Scala to JavaScript compiler.
• xsbt-web-plugin: Servlet support.
• sbt-web: library for building sbt plugins for the web.
• sbt-web-scalajs: use Scala.js with any web server.
• sbt-less: Less CSS compilation support.
• sbt-js-engine: support for sbt plugins that use JavaScript.
• sbt-typescript: TypeScript compilation support.
• sbt-uglify: JavaScript minifier using UglifyJS.
• sbt-terser: JavaScript (ES6+) minifier using terser.
• sbt-digest: generate checksums of assets.
• sbt-scalatra: build and run Scalatra apps.
• sbt-scala-js-map: Configure source mapping for Scala.js projects hosted on Github.
• sbt-gzip: gzip compressor for assets.
• sbt-stylus: Stylus stylesheet compiler.
• sbt-hepek: Render static websites directly from Scala code.
• sbt-puresass: sbt-web plugin for Sass styles compilation.
• sbt-scala-ts; generates TypeScript declaration files from ScalaJS sources and outputs Node modules.

• scalikejdbc-mapper-generator: Scala code generator from database schema.
• sbt-dynamodb: run a local Amazon DynamoDB test instance from sbt.
• sbt-migrations: database migrations manager.

• sbt-newrelic: NewRelic support for artefacts built with sbt-native-packager.
• sbt-spark: Spark application configurator.
• sbt-api-builder: support for ApiBuilder from within sbt's shell.

• sbt-buildinfo: generate Scala code from SBT setting keys.
• sbt-scalaxb: generate model classes from XML schemas and WSDL.
• sbt-protobuf: protobuf code generator.
• sbt-header: auto-generate source code file headers (such as copyright notices).
• sbt-boilerplate: TupleX and FunctionX boilerplate code generator.
• sbt-avro: Apache Avro schema and protocol generator.
• sbt-aspectj: AspectJ weaving for sbt.
• sbt-protoc: protobuf code generator using protoc.
• sbt-contraband (docs): generate pseudo-case classes from GraphQL schemas.
• sbt-antlr4: run ANTLR v4 from sbt.
• sbt-sql: generate model classes from SQL.
• sbt-partial-unification: enable partial unification support in Scala (SI-2712).
• sbt-i18n: transform your i18n bundles into Scala code.
• sbt-lit: build literate code with sbt.
• sbt-embedded-files: generate Scala objects containing the contents of glob-specified files as strings or byte-arrays.
• sbt-scala-ts: generate TypeScript code according compiled Scala types (case class, trait, object, ...).

• wartremover: flexible Scala linting tool.
• scalastyle-sbt-plugin: code style checking using Scalastyle.
• sbt-scapegoat: static analysis using Scapegoat.
• sbt-stats: generate source code statistics (lines of code etc).
• sbt-scalafix: refactoring and linting tool for Scala using Scalafix.
• sbt-explicit-dependencies: check that you have declared all your library dependencies correctly
• sbt-taglist: find tags within source files (such as TODO and FIXME).
• sbt-rewarn: always display compilation warnings, despite the incremental compilation.
• sbt-jcheckstyle: Java code style checking using Checkstyle.
• sbt-sonar: integration with SonarQube.
• sbt-scala2plantuml: generates PlantUML diagrams from Scala code.

• sbt-scoverage: Scala code coverage using Scoverage.
• sbt-jacoco: Scala and Java code coverage using JaCoCo.

• sbt-fresh: create an opinionated fresh sbt project.

• sbt-houserules: houserules settings for sbt modules.

• sbt-stainless: verify Scala or Dotty code using stainless.

• sbt-frege: build Frege code with sbt.
• sbt-cc: compile C and C++ source files with sbt.