Contents

• Install
• Getting Started
• Features of sbt
• Also

1. Getting Started with sbt
   1. Installing sbt
      • Tips and Notes
      1. Installing sbt on macOS
         • Install sbt with cs setup
         • Install JDK
           • SDKMAN!
         • Installing from a universal package
         • Installing from a third-party package
           • Homebrew
      2. Installing sbt on Windows
         • Install sbt with cs setup
         • Install JDK
         • Installing from a universal package
         • Windows installer
         • Installing from a third-party package
           • Scoop
           • Chocolatey
      3. Installing sbt on Linux
         • Install sbt with cs setup
         • Installing from SDKMAN
         • Install JDK
         • Installing from a universal package
         • Ubuntu and other Debian-based distributions
         • Red Hat Enterprise Linux and other RPM-based distributions
         • Gentoo
   2. sbt by example
      • Create a minimum sbt build
      • Start sbt shell
      • Exit sbt shell
      • Compile a project
      • Recompile on code change
      • Create a source file
      • Run a previous command
      • Getting help
      • Run your app
      • Set ThisBuild / scalaVersion from sbt shell
      • Save the session to build.sbt
      • Name your project
      • Reload the build
      • Add toolkit-test to libraryDependencies
      • Run tests
      • Run incremental tests continuously
      • Write a test
      • Make the test pass
      • Add a library dependency
      • Use Scala REPL
      • Make a subproject
      • List all subprojects
      • Compile the subproject
      • Add toolkit-test to the subproject
      • Broadcast commands
      • Make hello depend on helloCore
      • Parse JSON using uJson
      • Add sbt-native-packager plugin
      • Reload and create a .zip distribution
      • Dockerize your app
      • Set the version
      • Switch scalaVersion temporarily
      • Inspect the dist task
      • Batch mode
      • sbt new command
      • Credits
   3. Directory structure
      • Base directory
      • Source code
      • sbt build definition files
      • Build support files
      • Build products
      • Configuring version control
   4. Running
      • sbt shell
      • Batch mode
      • Continuous build and test
      • Common commands
      • Tab completion
      • sbt shell history
   5. IDE Integration
      • Using sbt as Metals build server
        • Interactive debugging on VS Code
        • Logging into sbt session
      • Importing to IntelliJ IDEA
        • Interactive debugging with IntelliJ IDEA
      • Using sbt as IntelliJ IDEA build server (advanced)
        • Logging into sbt session
      • Using Neovim as Metals frontend (advanced)
        • Go to definition
        • Hover
        • Listing diagnostics
        • Interactive debugging with Neovim
        • Logging into sbt session
   6. Build definition
      • Specifying the sbt version
      • What is a build definition?
      • How build.sbt defines settings
      • Keys
        • Types
        • Built-in Keys
        • Custom Keys
        • Task vs Setting keys
        • Listing all available setting keys and task keys
      • Defining tasks and settings
        • Types for tasks and settings
      • Keys in sbt shell
      • Imports in build.sbt
      • Bare .sbt build definition
      • Adding library dependencies
   7. Multi-project builds
      • Multiple subprojects
        • Build-wide settings
        • Common settings
      • Dependencies
        • Aggregation
        • Classpath dependencies
          • Per-configuration classpath dependencies
      • Inter-project dependencies
      • Default root project
      • Navigating projects interactively
      • Common code
      • Appendix: Subproject build definition files
   8. Task graph
      • Terminology
      • Declaring dependency to other tasks
      • Inlining .value calls
        • Inspecting the task
        • Defining a task that depends on other settings
        • Defining a setting that depends on other settings
      • What s the point of the build.sbt DSL?
        • Intro to Make
        • Rake
        • Benefits of hybrid flow-based programming
      • Summary
   9. Scopes
      • The whole story about keys
      • Scope axes
        • Scoping by the subproject axis
        • Scoping by the configuration axis
        • Scoping by Task axis
        • Zero scope component
      • Referring to scopes in a build definition
      • Referring to scoped keys from the sbt shell
      • Examples of scoped key notation in the sbt shell
      • Inspecting scopes
      • When to specify a scope
      • Build-level settings
      • Scope delegation
   10. Appending values
       • Appending to previous values: += and ++=
         • When settings are undefined
         • Tasks based on other keys values
       • Appending with dependencies: += and ++=
   11. Scope delegation (.value lookup)
       • Scope delegation rules
       • Rule 1: Scope axis precedence
       • Rule 2: The task axis delegation
       • Rule 3: The configuration axis search path
       • Rule 4: The subproject axis search path
         • Scope axis precedence, again
       • Inspect command lists the delegates
       • .value lookup vs dynamic dispatch
   12. Library dependencies
       • Unmanaged dependencies
       • Managed Dependencies
         • The libraryDependencies key
         • Getting the right Scala version with %%
         • Ivy revisions
         • Resolvers
         • Overriding default resolvers
         • Per-configuration dependencies
   13. Using plugins
       • What is a plugin?
       • Declaring a plugin
       • Enabling and disabling auto plugins
       • Global plugins
       • Available Plugins
   14. Custom settings and tasks
       • Defining a key
       • Implementing a task
       • Execution semantics of tasks
         • Deduplication of task dependencies
         • Cleanup task
         • Use plain Scala
       • Turn them into plugins
   15. Organizing the build
       • sbt is recursive
       • Tracking dependencies in one place
       • When to use .scala files
       • Defining auto plugins
   16. Getting Started summary
       • sbt: The Core Concepts
       • Advanced Notes
2. Frequently Asked Questions
   • Project Information
     • What does the name sbt stand for, and why shouldn t it be written SBT ?
     • How do I get help?
     • How do I report a bug?
     • How can I help?
   • Usage
     • My last command didn t work but I can t see an explanation. Why?
     • How do I disable ansi codes in the output?
     • How can I start a Scala interpreter (REPL) with sbt project configuration (dependencies, etc.)?
   • Build definitions
     • What are the := , += , and ++= methods?
     • What is the % method?
     • What does ThisBuild / scalaVersion mean?
     • What is ModuleID , Project , ?
     • How do I add files to a jar package?
     • How can I generate source code or resources?
     • How can a task avoid redoing work if the input files are unchanged?
   • Extending sbt
     • How can I add a new dependency configuration?
     • How do I add a test configuration?
     • How can I create a custom run task, in addition to run ?
     • How should I express a dependency on an outside tool such as proguard?
     • How would I change sbt s classpath dynamically?
     • Example of dynamic classpath augmentation
     • How can I take action when the project is loaded or unloaded?
     • Example of project load/unload hooks
   • Errors
     • On project load, Reference to uninitialized setting
   • Dependency Management
     • How do I resolve a checksum error?
     • I ve added a plugin, and now my cross-compilations fail!
   • Miscellaneous
     • Where can I find plugins for 1.9.8?
3. General Information
   1. Credits
   2. Community Plugins
      • sbt Organization
      • Community Ivy Repository
      • Cross building plugins from sbt 0.13
      • Plugins available for sbt 1.0 (including RC-x)
        • Code formatter plugins
        • Documentation plugins
        • One jar plugins
        • Release plugins
        • Deployment integration plugins
        • Utility and system plugins
        • IDE integration plugins
        • Test plugins
        • Library dependency plugins
        • Web and frontend development plugins
        • Database plugins
        • Framework-specific plugins
        • Code generator plugins
        • Static code analysis plugins
        • Code coverage plugins
        • Create new project plugins
        • In-house plugins
        • Verification plugins
        • Language support plugins
   3. Community Repository Policy
   4. Bintray For Plugins
   5. Using Sonatype
      • Sonatype setup
      • sbt setup
        • step 1: PGP Signatures
        • step 2: sbt-pgp
        • step 3: Credentials
        • step 4: Configure build.sbt
        • step 5: Publishing
      • Optional steps
        • sbt-sonatype
        • Publishing tips
        • Integrate with the release process
   6. Contributing to sbt
      • Documentation
   7. Changes
      1. Migrating from sbt 0.13.x
         • Migrating case class .copy(...)
         • SbtPlugin
         • sbt version specific source directory
         • Migrating to slash syntax
         • Migrating from sbt 0.12 style
           • Migrating sbt 0.12 style operators
           • Migrating from the tuple enrichments
           • Migrating when using .dependsOn , .triggeredBy or .runBefore
           • Migrating when you need to set Task s
           • Migrating with InputKey
         • Migrating from the Build trait
         • Migrating from Resolver.withDefaultResolvers
      2. sbt 1.4.x releases
         • sbt 1.4.1
         • sbt 1.4.0
         • Build server protocol (BSP) support
           • How to import to IntelliJ using BSP
           • How to import to VS Code + Metals
         • Native thin client
         • ThisBuild / versionScheme
         • VirtualFile + RemoteCache
         • Build linting
         • Conditional task
         • Incremental build pipelining
         • sbt-dependency-graph is in-sourced
         • Fixes with compatibility implications
         • Other updates
         • Participation
      3. sbt 1.3.x releases
         • sbt 1.3.0
           • Changes with compatibility implication
           • Library management with Coursier
           • Turbo mode with ClassLoader layering
           • IO improvements
           • Glob
           • Watch improvements
           • Build definition source watch
           • Custom incremental tasks
           • Super shell
           • Tracing
           • SemanticDB support
           • print command
           • Appending Function1
           • JDK 11 support
           • Other bug fixes and improvements
           • Participation
      4. sbt 1.2.x releases
         • sbt 1.2.1
           • Forward bincompat breakage
           • The project Foo references an unknown configuration bar
           • Other bug fixes
           • Contributors
         • sbt 1.2.0
           • SbtPlugin for plugin development
           • Cross JDK forking
           • scalaVersion-filtered aggregation
           • Composite project
           • Project matrix
           • Semantic Version selector API
           • addPluginSbtFile command
           • Extensible sbt server
           • Thin client(s)
           • Changes with compatibility implication
           • Other bug fixes and improvements
           • Internal
           • Contributors
      5. sbt 1.1.x releases
         • sbt 1.1.6
           • Bug fixes
           • Contributors
         • sbt 1.1.5
           • Bug fixes
           • Improvements
           • Watcher improvements
           • VS Code extension update
           • sbt by example
           • Contributors
         • sbt 1.1.4
           • Bug fixes
           • Improvements
           • Triggered execution on macOS
           • Running sbt with standby
           • Loading performance improvement
         • Contributors
         • sbt 1.1.2
           • Bug fixes
           • Improvements
           • Internal
           • Contributors
         • sbt 1.1.1
           • Bug fixes
           • Improvements
           • autoStartServer setting
           • Contributors
         • sbt 1.1.0
           • Features, fixes, changes with compatibility implications
           • Features
           • Fixes
           • Improvements
           • Unified slash syntax for sbt shell and build.sbt
           • sbt server
           • VS Code extension
           • Filtering scripted tests using project/build.properties
           • Contributors
      6. sbt 1.0.x releases
         • sbt 1.0.4
           • Bug fixes
           • Enhancement
           • Internal
           • Contributors
         • sbt 1.0.3
           • Bug fixes
           • Improvements
           • Alternative watch mode
           • Contributors
         • sbt 1.0.2
           • Bug fixes
           • Internal
           • Contributors
         • sbt 1.0.1
           • Bug fixes
           • WatchSource
         • sbt 1.0.0
           • Features, fixes, changes with compatibility implications
           • Features
           • Fixes
           • Improvements
           • Internals
           • Details of major changes
           • Zinc 1: Class-based name hashing
             • Zinc API changes
             • sbt server: JSON API for tooling integration
             • Static validation of build.sbt
             • Eviction warning presentation
             • sbt-cross-building
             • CopyOptions
             • Library management API and parallel artifact download
             • Binary format for Zinc s internal storage
             • Dependency locking
           • Contributors
4. Detailed Topics
   1. Using sbt
      1. Command Line Reference
         • Notes on the command line
         • Project-level tasks
         • Configuration-level tasks
         • General commands
         • Commands for managing the build definition
      2. Console Project
         • Description
         • Accessing settings
           • Examples
         • Evaluating tasks
           • Examples
         • State
           • Examples
      3. Cross-building
         • Introduction
         • Publishing conventions
         • Using cross-built libraries
         • Cross building a project using sbt-projectmatrix
         • Cross building a project statefully
         • Change settings depending on the Scala version
           • Scala-version specific source directory
           • Cross building with a Java project
           • Switching Scala version
           • Cross publishing
           • Overriding the publishing convention
           • Scala 3 specific cross-versions
           • More about using cross-built libraries
           • Note about sbt-release
      4. Interacting with the Configuration System
         • Selecting commands, tasks, and settings
           • Selecting the configuration
           • Task-specific Settings
         • Discovering Settings and Tasks
           • Value and Provided By
           • Related Settings
           • Dependencies
             • Requested Dependencies
             • Actual Dependencies
           • Delegates
      5. Triggered Execution
         • Compile
         • Testing
         • Running Multiple Commands
         • Build sources
         • Clearing the screen
         • Configuration
      6. Script mode
         • sbt Script runner
           • Example
      7. sbt Server
         • Configuration
         • Language Server Protocol 3.0
         • Server modes
         • Server discovery and authentication
         • Initialize request
         • textDocument/publishDiagnostics event
         • textDocument/didSave event
         • sbt/exec request
         • sbt/setting request
         • sbt/completion request
         • sbt/cancelRequest
      8. Understanding Incremental Recompilation
         • sbt heuristics
         • How to take advantage of sbt heuristics
   2. Configuration
      1. Classpaths, sources, and resources
         • Basics
           • Unmanaged vs managed
             • Excluding source files by name
           • External vs internal
           • Keys
           • Example
      2. Compiler Plugin Support
         • Continuations Plugin Example
         • Version-specific Compiler Plugin Example
      3. Configuring Scala
         • Automatically managed Scala
           • Configuring the scala-library dependency
           • Configuring additional Scala dependencies
           • Configuring Scala tool dependencies
           • Switching to a local Scala version
         • Using Scala from a local directory
           • Mixing with managed dependencies
           • Using unmanaged dependencies only
         • sbt s Scala version
      4. Forking
         • Enable forking
         • Change working directory
         • Forked JVM options
         • Java Home
         • Configuring output
         • Configuring Input
         • Direct Usage
      5. Global Settings
         • Basic global configuration file
         • Global Settings using a Global Plugin
      6. Java Sources
         • Usage
         • Known issues in mixed mode compilation
         • Ignoring the Scala source directories
      7. Mapping Files
         • Relative to a directory
         • Rebase
         • Flatten
         • Alternatives
      8. Local Scala
      9. Macro Projects
         • Introduction
         • Defining the Project Relationships
         • Common Interface
         • Distribution
      10. Paths
          • Constructing a File
          • Path Finders
            • Selecting descendants
            • get
            • Selecting children
            • Existing files only
            • Name Filter
            • Combining PathFinders
            • Filtering
            • Empty PathFinder
            • PathFinder to String conversions
            • Mappings
          • File Filters
      11. Parallel Execution
          • Task ordering
          • Practical constraints
            • Background
          • Configuration
            • Tagging Tasks
            • Defining Restrictions
              • Built-in Tags and Rules
            • Custom Tags
          • Future work
            • Tagging Tasks
            • Fractional weighting
            • Default Behavior
            • Adjustments to Defaults
            • Other characteristics
      12. External Processes
          • Usage
            • Examples
      13. Running Project Code
          • Problems
            • System.exit
            • Threads
            • Deserialization and class loading
      14. Testing
          • Basics
            • testOnly
            • testQuick
              • Tab completion
            • Other tasks
          • Output
            • Test Reports
          • Options
            • Test Framework Arguments
            • Setup and Cleanup
            • Disable Parallel Execution of Tests
            • Filter classes
            • Forking tests
          • Additional test configurations
            • Integration Tests
            • Custom test configuration
            • Additional test configurations with shared sources
              • Application to parallel execution
          • JUnit
          • Extensions
            • Custom Test Framework
            • Custom Test Reporters
            • Using Extensions
      15. In process class loading
          • Troubleshooting
      16. Globs
          • Constructing Globs
          • Path names
          • Filters
          • Depth
          • Regular expressions
          • Querying the file system with FileTreeView
            • File attributes
            • Filtering
            • Streaming
            • Implementation
          • Globs vs. PathFinder
      17. Remote Caching
          • Usage
          • Remote caching via Maven repository
          • ThisBuild / rootPaths
          • remoteCacheId
   3. Dependency Management
      1. Artifacts
         • Selecting default artifacts
         • Modifying default artifacts
         • Defining custom artifacts
         • Publishing .war files
         • Using dependencies with artifacts
      2. Dependency Management Flow
         • Background
         • Caching and Configuration
         • Notes on SNAPSHOTs
      3. Library Management
         • Introduction
         • Manual Dependency Management
         • Automatic Dependency Management
           • Inline Declarations
             • Dependencies
             • Resolvers
             • Override default resolvers
             • Override all resolvers for all builds
             • Explicit URL
             • Disable Transitivity
             • Classifiers
             • Exclude Transitive Dependencies
             • Download Sources
             • Extra Attributes
             • Inline Ivy XML
             • Ivy Home Directory
             • Checksums
             • Conflict Management
             • Eviction warning
             • Overriding a version
             • Unresolved dependencies error
             • Cached resolution
             • Publishing
             • Configurations
             • Forcing a revision (Not recommended)
             • Known limitations
      4. Proxy Repositories
         • Overview
         • sbt Configuration
         • ~/.sbt/repositories
         • Using credentials for the proxy repository
           • Launcher Script
           • sbt.override.build.repos
           • sbt.repository.config
         • Proxying Ivy Repositories
      5. Publishing
         • Skip publishing
         • Define the repository
         • Publishing locally
         • Credentials
         • Cross-publishing
         • Overriding the publishing convention
         • Published artifacts
         • Modifying the generated POM
         • Version scheme
      6. Resolvers
         • Maven resolvers
         • Local Maven resolvers
         • Predefined resolvers
         • Custom resolvers
           • Basic Examples
             • Filesystem
             • URL
             • SFTP and SSH Repositories
           • Custom Layout
      7. Update Report
         • Filtering a Report and Getting Artifacts
           • Filter Basics
           • ConfigurationFilter
           • ModuleFilter
           • ArtifactFilter
           • DependencyFilter
      8. Cached Resolution
         • Setup
         • Dependency as a graph
         • Cached Resolution
         • Caveats and known issues
           • First runs
           • Ivy fidelity is not guaranteed
           • SNAPSHOT and dynamic dependencies
         • Motivation
   4. Tasks and Commands
      1. Tasks
         • Introduction
         • Features
         • Defining a Task
           • Hello World example (sbt)
           • Define the key
           • Implement the task
             • Defining a basic task
             • Tasks with inputs
             • Task Scope
             • On precedence
           • Separating implementations
           • Modifying an Existing Task
         • Getting values from multiple scopes
           • Introduction
           • Example
           • ScopeFilter
             • Unspecified filters
             • More on filter construction
             • Combining ScopeFilters
           • More operations
             • Missing values
             • Multiple values from multiple scopes
         • Advanced Task Operations
           • Streams: Per-task logging
         • Conditional task
         • Dynamic Computations with Def.taskDyn
         • Using Def.sequential
         • Handling Failure
           • failure
           • result
             • andFinally
      2. Caching
         • Cache.cached
         • Previous value
         • Tracked.lastOutput
         • Tracked.inputChanged
         • Tracking file attributes
         • FileInfo
         • Tracked.inputChanged
         • Tracked.outputChanged
         • Tracked.diffInputs
         • Tracked.diffOutputs
         • Case study: sbt-scalafmt
         • Summary
      3. Input Tasks
         • Input Keys
         • Basic Input Task Definition
         • Input Task using Parsers
           • Constructing the Parser
           • Constructing the Task
         • The InputTask type
         • Using other input tasks
         • Preapplying input
         • Get a Task from an InputTask
      4. Commands
         • What is a command ?
         • Introduction
         • Defining a Command
           • General commands
           • No-argument commands
           • Single-argument command
           • Multi-argument command
         • Full Example
      5. Parsing and tab completion
         • Basic parsers
         • Built-in parsers
         • Combining parsers
         • Transforming results
         • Controlling tab completion
         • Dependent parsers
      6. State and actions
         • Command-related data
         • Project-related data
         • Project data
         • Classpaths
         • Running tasks
         • Using State in a task
         • Updating State in a task
      7. Tasks/Settings: Motivation
         • Application
   5. Plugins and Best Practices
      1. General Best Practices
         • project/ vs. ~/.sbt/
         • Local settings
         • .sbtrc
         • Generated files
         • Don t hard code
         • Don t mutate files
         • Use absolute paths
         • Parser combinators
      2. Plugins
         • Using an auto plugin
         • By Description
         • Plugin dependencies
           • Global plugins
         • Creating an auto plugin
           • projectSettings and buildSettings
           • Implementing plugin dependencies
           • Root plugins and triggered plugins
           • Controlling the import with autoImport
           • Example Plugin
           • Usage example
           • Global plugins example
         • Using a library in a build definition example
           • 1a) Manually managed
           • 1b) Automatically managed: direct editing approach
           • 1c) Automatically managed: command-line approach
           • 1d) Project dependency
           • 2) Use the library
         • Publishing a plugin
         • Best Practices
      3. Plugins Best Practices
         • Key naming convention: Use prefix
         • Artifact naming convention
         • (optional) Plugin naming convention
         • Don t use default package
         • Get your plugins known
         • Reuse existing keys
         • Use settings and tasks. Avoid commands.
         • Provide core feature in a plain old Scala object
         • Configuration advice
           • You probably won t need your own configuration
           • When to define your own configuration
           • Playing nice with configurations
           • Provide raw settings and configured settings
         • Scoping advice
           • Provide default values in globalSettings
           • Using a main task scope for settings
           • Rewiring existing keys in globalSettings
      4. Setting up GitHub Actions with sbt
         • Set project/build.properties
         • Read the GitHub Actions manual
         • Basic setup
         • Custom JVM options
         • Caching
         • Build matrix
         • Sample .github/workflows/ci.yml setting
         • sbt-github-actions
      5. Setting up Travis CI with sbt
         • Set project/build.properties
         • Read the Travis manual
         • Basic setup
         • Plugin build setup
         • Custom JVM options
         • Caching
         • Build matrix
         • Notification
         • Dealing with flaky network or tests
         • More things
         • Sample setting
      6. Testing sbt plugins
         • scripted test framework
         • step 1: snapshot
         • step 2: SbtPlugin
         • step 3: src/sbt-test
         • step 4: write a script
         • step 5: run the script
         • step 6: custom assertion
         • step 7: testing the test
         • step 8: get inspired
      7. sbt new and Templates
         • Trying new command
         • Giter8 support
           • Giter8 parameters
           • How to create a Giter8 template
           • Use CC0 1.0 for template licensing
         • How to extend sbt new
           • Template Resolver
           • templateResolverInfos
      8. Cross building plugins
         • Mixing libraries and sbt plugins in a build
5. How to…
   1. Classpaths
      • Include a new type of managed artifact on the classpath, such as mar
      • Get the classpath used for compilation
      • Get the runtime classpath, including the project s compiled classes
      • Get the test classpath, including the project s compiled test classes
      • Use packaged jars on classpaths instead of class directories
      • Get all managed jars for a configuration
      • Get the files included in a classpath
      • Get the module and artifact that produced a classpath entry
   2. Customizing paths
      • Change the default Scala source directory
      • Change the default Java source directory
      • Change the default resource directory
      • Change the default (unmanaged) library directory
      • Disable using the project s base directory as a source directory
      • Add an additional source directory
      • Add an additional resource directory
      • Include/exclude files in the source directory
      • Include/exclude files in the resource directory
      • Include only certain (unmanaged) libraries
   3. Generating files
      • Generate sources
      • Generate resources
   4. Inspect the build
      • Show or search help for a command, task, or setting
      • List available tasks
      • List available settings
      • Display tree of setting/task dependencies
      • Display the description and type of a setting or task
      • Display the delegation chain of a setting or task
      • Display related settings or tasks
      • Show the list of projects and builds
      • Show the current session (temporary) settings
      • Show basic information about sbt and the current build
      • Show the value of a setting
      • Show the result of executing a task
      • Show the classpath used for compilation or testing
      • Show the main classes detected in a project
      • Show the test classes detected in a project
   5. Interactive mode
      • Use tab completion
      • Show more tab completion suggestions
      • Modify the default JLine keybindings
      • Configure the prompt string
      • Use history
      • Change the location of the interactive history file
      • Use the same history for all projects
      • Disable interactive history
      • Run commands before entering interactive mode
   6. Configure and use logging
      • View the logging output of the previously executed command
      • View the previous logging output of a specific task
      • Show warnings from the previous compilation
      • Change the logging level globally
      • Change the logging level for a specific task, configuration, or project
      • Configure printing of stack traces
      • Print the output of tests immediately instead of buffering
      • Add a custom logger
      • Log messages in a task
      • Log messages in a setting
   7. Project metadata
      • Set the project name
      • Set the project version
      • Set the project organization
      • Set the project s homepage and other metadata
   8. Configure packaging
      • Use the packaged jar on classpaths instead of class directory
      • Add manifest attributes
      • Change the file name of a package
      • Modify the contents of the package
   9. Running commands
      • Pass arguments to a command or task in batch mode
      • Provide multiple commands to run consecutively
      • Read commands from a file
      • Define an alias for a command or task
      • Quickly evaluate a Scala expression
   10. Configure and use Scala
       • Set the Scala version used for building the project
       • Disable the automatic dependency on the Scala library
       • Temporarily switch to a different Scala version
       • Use a local Scala installation for building a project
       • Build a project against multiple Scala versions
       • Enter the Scala REPL with a project s dependencies on the classpath, but not the compiled project classes
       • Enter the Scala REPL with a project s dependencies and compiled code on the classpath
       • Enter the Scala REPL with plugins and the build definition on the classpath
       • Define the initial commands evaluated when entering the Scala REPL
       • Define the commands evaluated when exiting the Scala REPL
       • Use the Scala REPL from project code
   11. Generate API documentation
       • Select javadoc or scaladoc
       • Set the options used for generating scaladoc independently of compilation
       • Add options for scaladoc to the compilation options
       • Set the options used for generating javadoc independently of compilation
       • Add options for javadoc to the compilation options
       • Enable automatic linking to the external Scaladoc of managed dependencies
       • Enable manual linking to the external Scaladoc of managed dependencies
       • Define the location of API documentation for a library
   12. Define Custom Tasks
       • Define a Task that runs tests in specific sub-projects
   13. How to take an action on startup
   14. Track file inputs and outputs
       • File inputs
         • Incremental builds
       • File outputs
       • Filters
         • Cleaning outputs
       • File change tracking
         • Continuous build file monitoring
         • Partial pipeline evaluation / error handling
   15. Troubleshoot memory issues
   16. Sequencing
       1. Defining a sequential task with Def.sequential
          • project/build.properties
          • project/style.sbt
          • build.sbt
       2. Defining a dynamic task with Def.taskDyn
          • project/build.properties
          • project/style.sbt
          • build.sbt v1
          • build.sbt v2
       3. Doing something after an input task
          • src/main/scala/Greeting.scala
          • build.sbt v1
          • build.sbt v2
       4. Defining a dynamic input task with Def.inputTaskDyn
          • build.sbt v1
          • build.sbt v2
       5. How to sequence using commands
   17. How to define a custom dependency configuration
       • Cautions on custom dependency configurations
       • Example basic custom configuration
         • project/FuzzPlugin.scala
         • build.sbt
       • Example sandbox configuration
         • project/ScalafmtPlugin.scala
       • How do I add a test configuration?
   18. Examples
       1. .sbt build examples
       2. .sbt build with .scala files example
          • project/Resolvers.scala
          • project/Dependencies.scala
          • project/ShellPromptPlugin.scala
          • build.sbt
       3. Advanced configurations example
       4. Advanced command example
6. Index
   • Values and Types
     • Dependency Management
     • Settings and Tasks
     • Build Structure
   • Methods
     • Settings and Tasks
     • File and IO
     • Dependency Management
     • Parsing
7. Developer’s Guide (Work in progress)
   • Towards sbt 1.0
     • Concepts
     • Source compatibility of the build definition
     • Binary compatibility of the plugins
   1. Modularization
      1. Module summary
         • IO API ( sbt/io )
         • Serialization API ( sbt/serialization )
         • Util APIs ( sbt/util )
         • LibraryManagement API ( sbt/librarymanagement )
         • IncrementalCompiler API ( sbt/zinc )
         • Build API (tbd)
         • sbt Launcher ( sbt/launcher )
         • Client/Server (tbd)
         • Website ( sbt/website )
   2. sbt Coding Guideline
      • General goal
        • Clean up old deprecation
        • Aim for zero warnings (except deprecation)
      • Documentation
      • Modular design
        • Aim small
        • Public APIs should be coded against interfaces
        • Hide implementation details
        • Less interdependence
        • Hide external classes
        • Hide internal modules
        • Compiler flags
        • Package name and organization name
      • Binary resiliency
        • MiMa
        • Public traits should contain def declarations only
        • Abstract classes are also useful
        • Seal traits and abstract classes
        • Finalize the leaf classes
        • Typeclass and subclass inheritance
        • Avoid case classes, use sbt-datatype
        • Prefer method overloading over default parameter values
      • Other public API matters
        • Avoid Stringly-typed programming
        • Avoid overuse of def apply
        • Use specific datatypes ( Vector , List , or Array ), rather than Seq
        • Avoid calling toSeq or anything with side-effects on Set
        • Avoid calling toSeq on Map
        • Avoid functions and tuples in the signature, if Java interoperability is needed
      • Style matters
        • Use scalafmt
        • Avoid procedure syntax
        • Define instances of typeclasses in their companion objects, when possible
        • Implicit conversions for syntax (enrich-my-library pattern) should be imported
   3. sbt-datatype
      • Using the plugin
      • Datatype schema
        • Records
        • Interfaces
        • Enums
      • Using datatype to retain binary compatibility
      • JSON codec generation
      • Existing parameters for protocols, records, etc.
      • Settings
      • Syntax summary
   4. Compiler Interface
      1. Fetching the most specific sources
   5. sbt Launcher
      1. Getting Started with the sbt launcher
         • Overview
           • Applications
           • Servers
           • Resolving Applications/Servers
           • Creating a Launched Application
           • Running an Application
           • Execution
      2. Sbt Launcher Architecture
         • Module Resolution
         • Classloader Caching and Isolation
         • Caching
         • Locking
         • Service Discovery and Isolation
      3. sbt Launcher Configuration
         • Example
           • 1. Scala Configuration
           • 2. Application Identification
           • 3. Repositories Section
           • 4. The Boot section
           • 5. The Ivy section
           • 6. The Server Section
         • Variable Substitution
         • Syntax
   6. Notes
      1. Core Principles
         • Introduction to build state
         • Settings Architecture
         • Task Architecture
      2. Settings Core
         • Example
           • Setting up
           • Example Settings System
           • Example Usage
         • sbt Settings Discussion
           • Scopes
           • Constructing settings
           • Settings definitions
      3. Setting Initialization
      4. Creating Command Line Applications Using sbt
         • Hello World Example
           • Build Definition: build.sbt
           • Application: Main.scala
           • Launcher configuration file: hello.build.properties
8. Archived pages
   1. Hello, World
      • sbt new command
      • Running your app
      • Exiting sbt shell
      • Build definition
9. Contents in Depth
10. Combined Pages