sbt/sbt

Features

• Multi-Project Orchestration - Coordinates multiple related sub-projects within a single build through internal dependency tracking and task aggregation.
• Build Orchestrators - Orchestrates the entire build process for source code, including compilation and dependency management.
• Dependency Management - Resolves and manages external libraries from remote repositories to ensure a complete and correct build classpath.
• Dependency Graph Step Executions - Utilizes a directed graph of typed keys to determine the correct evaluation order for build tasks.
• Build and Compilation Tools - Acts as a complete build and compilation tool for Scala and Java, managing dependencies and binaries.
• Build Configuration Stores - Maintains a type-safe key-value store of settings that are dynamically computed or transformed during the build process.
• Build Task Parallelism - Executes independent build steps in parallel based on a dependency graph to significantly reduce total build time.
• Configuration Key Definitions - Creates named configuration keys to store fixed values used throughout the build process.
• Custom Build Configuration Definitions - Allows the creation of user-defined settings and keys to extend the build process with project-specific behaviors.
• Dependency Management Systems - Functions as a system for resolving and downloading external libraries into managed classpaths.
• Interactive Build Environments - Provides an interactive shell environment to execute build tasks and inspect the project state in real time.
• Parallel Task Execution - Runs repeatable units of work in parallel using dependency tracking to ensure stable and efficient execution.
• Programmable Build Logic - Implements a programmable scripting environment where build process logic is defined as code.
• Project Orchestration - Coordinates the build process and internal dependency tracking for complex applications split into multiple sub-projects.
• Read-Eval-Print Loops - Provides an interactive read-eval-print loop with pre-loaded dependencies for real-time code testing and inspection.
• Continuous Development Workflows - Integrates a REPL and continuous execution to enable a real-time interactive development feedback loop.
• Shell Execution Environments - Provides a full interactive shell environment with tab completion and history for build task execution.
• Build Task Definitions - Allows the definition of runnable build tasks with specific classpaths and arguments to execute application logic.
• Classpath Dependency Management - Creates isolated dependency graphs and dedicated classpaths to separate different build stages.
• Plugin Packaging - Bundles custom settings and tasks into reusable plugins for distribution across multiple projects.
• Binary Package Generators - Compiles source files into binaries and packages them into distributable archives for deployment.
• Build System Extensibility - Provides a configurable extension system to add custom tasks and platform support via plugins.
• Build Coordination - Orchestrates the compilation and dependency linking of multiple internal projects and plugins.
• Dependency Resolution & Validation - Resolves external libraries, generates dependency graphs, and enforces version rules.
• Incremental Compilation - Provides an incremental recompilation engine that tracks source changes to significantly reduce build times.
• Interpreter State Access - Provides an interactive interpreter for accessing and modifying project definitions and build state.
• JVM Build Automation - Provides comprehensive build automation including incremental compilation and packaging for Scala and Java projects.
• Project Classpath Management - Isolates tool dependencies from project source code using distinct classloaders to prevent version conflicts.
• Dynamic Value Computations - Evaluates expressions and logic to determine setting values in real-time based on other keys in the system state.
• Data Dependency Graph Composition - Uses a dependency graph of functions to ensure build settings and values are computed in the correct order.
• Internal Project Dependency Management - Coordinates the sharing of build outputs between internal projects and incorporates external libraries.
• Plugin-Based Extensibility - Enables adding new tasks and settings through an extensible plugin model that merges definitions into the build state.
• Modular Project Structures - Structures complex applications into decoupled sub-projects and external dependencies.
• Type-Safe State Management - Maintains a type-safe key-value store for build configurations to ensure predictable state transitions.
• Automated Test Execution - Executes specific test suites using filters and wildcards to verify logic and integration.
• Test Suite Execution - Runs combinations of unit, integration, and functional tests based on wildcards and previous failure states.
• Build Result Caches - Provides caching of build-system computations to avoid repeating expensive operations.
• Task Skipping - Bypasses redundant build steps when a valid cache hit is detected from previous task results.
• Cache Input and Output Specifications - Uses file attributes and timestamps to determine task validity and skip unnecessary re-execution.
• Build State Inspection - Allows users to query current setting values and task statuses via an interactive shell to verify configuration.
• Custom Command Definitions - Provides capabilities to define new interactive commands to extend the build tool's shell functionality.
• CLI Command Parsers - Uses parser combinators to define structured input patterns and provide tab completion for user commands.
• Code Quality and Analysis - Scans source code for style violations and coverage gaps to ensure a consistent codebase.
• Distributed - Shares incremental compilation state across different machines to accelerate build times in shared environments.
• Dependency Caching - Caches resolved dependency graphs locally to avoid redundant network requests and speed up library resolution.
• Dependency Groups - Organizes dependencies into named configurations so projects can import only required subsets of functionality.
• Artifact Publishing Utilities - Uploads compiled binaries and metadata to remote repositories or cloud storage.
• Runtime Command Registration - Registers new commands and manages task execution order to extend the build system's functionality.
• Global Configuration Transformations - Modifies dependencies, repositories, and compiler options globally by operating on the final set of settings.
• Project Configuration - Provides utilities to extract and inspect project metadata and build settings from the current environment state.
• Local Configuration Overrides - Allows user-specific local configuration files to override global build settings without altering version-controlled files.
• API and Site Generators - Generates structured project websites, API references, and technical documentation from source code and markdown.
• Project Task Execution - Allows for the execution of specific project classes or main methods within the current virtual machine.
• Version Locking - Ensures consistent build results across environments by locking the specific version of the build engine.
• Release Artifact Configuration - Specifies exactly which binaries, sources, and documentation files are bundled and managed for release.
• Shell Command Execution - Capabilities for triggering and controlling operating system shell commands from the build environment.
• Build Task Development - Allows the creation of specialized executable logic associated with keys to perform custom build actions.
• Source File Watching - Monitors the filesystem for source changes to automatically trigger the recompilation and testing pipeline.
• Application Packaging - Bundles projects into fat JARs, native OS packages, or container images for distribution.
• Save-Triggered Automations - Automatically re-executes build tasks upon saving source files to provide immediate developer feedback.
• Binary Publication Workflows - Automates the bundling of binaries and documentation into archives for publication to remote repositories.
• Library Version Resolution - Resolves binary-compatible library variants by appending language version strings to dependency names.
• File-Change-Triggered Restarts - Triggers specific build actions or methods automatically whenever source files are modified.
• Binary Versioning - Generates version-specific binaries to ensure compatibility and avoid classpath conflicts across different language versions.
• Language Version Context Switching - Executes specific commands against different language versions without permanently altering project configuration.
• Classpath Analysis - Tracks classpath metadata to enable efficient incremental recompilation and accurate dependency mapping.
• Compiler Version Managers - Retrieves and applies specific versions of the compiler and libraries from remote repositories.
• Multi-Version Target Compilation - Compiles and publishes projects against multiple language versions to ensure binary compatibility across environments.
• Interactive Read-Eval-Print Loops - Provides an interactive read-eval-print loop with access to the project classpath for real-time state inspection.
• Dynamic Version-Based Settings - Adjusts compiler options and plugins dynamically based on the targeted language version.
• Polyglot Build Management - Manages the compilation and packaging of projects written in multiple compatible languages.
• Runtime Classpath Expansion - Enables dynamic expansion of the JVM classpath during execution to incorporate additional library files.
• Dynamic Configuration Management - Updates, inspects, and applies configuration settings dynamically during an active build session.
• Build-Process - Applies compiler plugins via managed dependencies to modify the standard compilation process.
• Incremental Processing Caches - Uses metadata and content hashing to skip redundant processing on unchanged files.
• Build Tools - The standard interactive build tool for Scala projects.

Star history