facebook/buck2

Features

• Hermetic Build Systems - A tool for compiling multi-language projects using a strict dependency graph to ensure reproducible and consistent build results.
• Hermetic Build Environments - Ensures reproducible builds by isolating the execution environment from the host system and strictly controlling dependencies.
• Incremental Build Computation - Recomputes only the specific nodes in a dependency graph that were invalidated by changes to input data.
• Content-Addressable Storage - Uses content-addressable storage to identify and reuse build artifacts based on their cryptographic hashes.
• Build Accelerators - Uses a persistent background daemon process to share caches and reduce total build time across commands.
• Build Action Execution - Executes build commands locally, remotely, or in hybrid mode to produce bound artifacts from source code.
• Build Artifact Caching - Stores generated build outputs in a dedicated directory structure to enable reuse across different build invocations.
• Build Caching Engines - Provides a core engine for storing and reusing build outputs via content-addressable storage to accelerate development.
• Custom Build Rules - Provides a system for specifying custom build actions and dependencies to control how source files are processed.
• Language Rule Definitions - Supports adding new programming languages by defining custom build rules and toolchains via a typed dialect.
• Dependency Graph Analysis - Provides deep analysis of project structures and dependencies across different build configurations.
• Build Graph Query Engines - Provides specialized query engines for analyzing complex project dependencies and target relationships.
• Build Procedure Definitions - Implements reproducible instructions to transform specific inputs into output build artifacts.
• Multi-Language Build Support - Provides comprehensive support for compiling source code from multiple languages into binaries within a single project.
• Build Rule Decoupling - Allows build rules to remain generic by defining compilers and flags separately from the logic of how targets are constructed.
• Build Action Specifications - Precisely specifies the toolchains, platforms, and dependencies required for every build action.
• Platform Rule Definitions - Provides platform rules to specify hardware and software constraints for target configuration.
• Platform Constraint Resolution - Applies constraints and selection logic to ensure build targets are compatible with the intended environment.
• Build Constraints - Adds configuration constraints to directories or targets to conditionally include or exclude build items.
• Build Target Definitions - Enables the definition of output artifacts such as executables, benchmarks, and tests across different platforms.
• Target Identification Systems - Uses a unique combination of name, cell, and path to consistently identify and reference targets across a monorepo.
• Target Labeling - Addresses items within the build graph using labels to identify targets and their specific sub-components.
• Build Variant Configuration - Resolves constraints and modifiers to build the same target across different CPU architectures.
• Hermetic Action Isolation - Executes cacheable build actions in isolated environments to ensure strictly reproducible results.
• Language Support Extensions - Integrates new programming languages into the build system through the registration of custom rules and toolchains.
• Monorepo Build Tools - Provides a programmable build system specialized for handling the scale and complexity of large multi-package monorepos.
• Monorepo Dependency Managers - Manages large-scale projects with complex target relationships and visibility constraints to enforce architectural boundaries.
• Multi-Language Build Systems - Coordinates the compilation and packaging of source code written in multiple programming languages within a single project.
• Package Dependency Management - Manages access to source files by assigning them to the nearest ancestor build file within the project.
• Source Package Boundaries - Implements strict boundaries that associate source files with specific build packages to prevent undeclared dependencies.
• Project Cell Mapping - Aggregates multiple directory trees into a single build project by mapping cell aliases to filesystem paths.
• Build Execution Environments - Configures isolated environments where build tools and compilers run to enable cross-compilation and remote execution.
• Target Dependency Definitions - Defines requirements between build targets within rules to establish necessary completion orders.
• Toolchain Abstractions - Decouples compiler specifications and build flags from build rules to enable reuse across different toolsets.
• Custom Computation Scripts - Executes custom computation scripts during the build process with result caching to avoid redundancy.
• Module Dependency Graphs - Tracks connections between targets to ensure correct build ordering and support architectural dependency queries.
• Build Dependency Graphs - Constructs an acyclic directed graph of targets to determine optimal build order and enable parallel execution.
• Dependency Chaining - Creates a structured execution graph by piping outputs from one build rule into subsequent rules.
• Transitive Mapping - Maps all actions and transitive dependencies required to produce a specific software output.
• Remote Build Orchestration - Distributes build tasks across remote worker clusters to scale parallel execution and share cached artifacts.
• Remote Execution Frameworks - Distributes build tasks across remote worker clusters to enable massive parallel execution and shared artifact caching.
• Build and Test Toolchains - Integrates the compilation of source code and execution of automated test suites into a unified toolchain.
• Library Compilation - Transforms source files into reusable libraries by defining target names, source roots, and visibility levels.
• Build Configuration Constraints - Maps abstract build rules to platform-specific configurations using constraints and modifiers to determine final artifacts.
• Build Target Types - Combines attribute specifications with implementation functions to create new types of buildable targets.
• Dependency Hermeticity Enforcement - Strictly tracks dependencies to prevent missing requirements and ensure consistent results across different environments.
• Build Result Caching - Utilizes action digests and content-addressable storage to identify and reuse previously computed build outputs.
• Environment Detection - Detects the operating system and processor architecture of the machine performing the build.
• Toolchain Execution Resolution - Ensures build tools are compiled for the correct execution platform and compatible environment.
• Dependency Graph Analyzers - Provides utilities for querying and inspecting the relationships between build targets to optimize execution.
• Invalidation Graph Tracking - Maintains a graph of reverse dependencies between leaf data and computed values to automate build invalidation.
• Directed Acyclic Graph Engines - Implements a build system based on a directed acyclic graph to orchestrate parallel task execution.
• Multi-Repository Build Coordination - Orchestrates build processes that aggregate source changes from multiple distinct directory trees into one project.
• Reproducible Build Environments - Ensures software binaries are generated identically regardless of the host machine by using isolated build environments.
• Controlled Environment Test Executions - Executes defined test targets within a controlled, isolated environment to verify code quality.
• Test Target Definitions - Defines test source files and dependencies to compile them into standalone, executable test binaries.
• Test Execution Engines - Provides a runner to execute compiled test binaries and report individual test case pass/fail results.
• Computational Result Caching - Caches the outputs of expensive internal functions associated with specific keys to avoid redundant computation.
• Script Operation Caches - Stores operation outputs based on attributes and platform to avoid redundant computations across different build commands.
• Artifact Materialization - Physically downloads specific build outputs to the local machine after remote execution to make them available for tasks.
• Artifact Path Resolution - Retrieves precise filesystem locations for build artifacts without requiring them to be physically materialized.
• Asset Hashing and Deduplication - Employs content-based hashing in file paths to ensure the same build action is shared across different target configurations.
• Daemon-Based State Persistence - Maintains a persistent background daemon to share caches and reduce startup overhead between command invocations.
• Affected Target Detection - Identifies affected components after a commit to minimize the number of targets that need rebuilding or testing.
• Build Script Execution Engines - Provides a command-line interface to execute typed build script functions with automated help documentation.
• Custom Build DSLs - Uses a specialized language to define executable scripts for performing build graph queries and generating artifacts.
• Build Action Materialization - Defines build actions that guarantee the physical generation of specific files on the local disk.
• Configuration Transitions - Provides mechanisms to alter build settings for sub-graphs relative to their parent targets.
• Build Artifact Isolation - Stores generated build outputs in dedicated directories to prevent them from cluttering the source tree.
• Build Variable Propagation - Defines and propagates configuration variables through a hierarchy of package files for nested builds.
• Dynamic Action Definitions - Provides mechanisms for defining executable command actions and parameters at runtime during the build.
• Dynamic Build Action Execution - Executes build actions where dependencies are determined at runtime based on the actual content of artifacts.
• Conditional Build Attributes - Modifies target attributes and dependencies dynamically based on active configuration constraints.
• Execution vs Target Platform Isolation - Implements a strict logical separation between the host environment where build tools execute and the target architecture where code runs.
• Configuration Transformations - Applies functions to transform platform information and alter build configurations for specific dependencies.
• Custom Build Configuration Definitions - Offers capabilities for creating user-defined settings and keys to specify project-specific build behaviors.
• Package Metadata Querying - Provides utilities for inspecting and retrieving package-level values and visibility constraints.
• External Dependency Imports - Generates build configuration files for third-party packages using external registries to ensure dependency availability.
• File Pattern Matching - Uses wildcard and recursive glob patterns to automatically include or exclude sets of files.
• Target Visibility Controls - Restricts which targets can be declared as dependencies for other targets within the project.
• Intersection-Based Visibility - Restricts target access using intersection-based visibility to ensure only authorized packages can depend on specific targets.
• Rule-Based Visibility Restrictions - Limits which build targets can depend on a specific rule using target patterns.
• Project Configuration - Extracts values from local or root configuration files to influence build logic and settings.
• Build Rule Generators - Provides programmable functions that generate actual build rule logic during the build process.
• Target Attribute Filtering - Allows including or excluding build targets during queries or test execution using tag-like attributes.
• Target Pattern Resolution - Resolves strings or recursive patterns to identify and act upon sets of build targets.
• Build Process Standardization - Ensures consistent tooling versions and build process normalization across different projects and teams.
• Tool Version Management - Manages build system versions on a per-project basis to ensure seamless tool upgrades and consistency.
• Dynamic Dependency Coordination - Orchestrates asynchronous output generation and shared targets to parallelize work across multiple build scripts.
• Build Artifact Management - Produces build files that are materialized and cached independently from the underlying script logic.
• Build Rule Provider Propagation - Uses provider types to share structured metadata and artifacts between build rules and their dependents.
• Recomputation Versioning - Skips the execution of invalidated nodes if their dependencies recompute to the same values as before.
• Internal Dependency Linking - Links binaries and libraries to internal build targets to ensure all required code is available during compilation.
• Build Logic Extensions - Provides scripts to query and manipulate the build graph across the configuration and action stages.
• Remote Execution Racing - Simultaneously executes build actions locally and remotely, returning the result from whichever process finishes first.
• Target Set Generation - Programmatically creates groups of build targets from lists of configured or unconfigured nodes.
• Filesystem Change Monitors - Tracks modifications to project files in real time to trigger efficient incremental build updates.
• Target Execution Orchestration - Orchestrates the building of specific targets and patterns to produce required build artifacts.
• Affected Component Detection - Identifies specific project components affected by changes to optimize continuous integration and test cycles.
• Build-Systeme - Large-scale build tool optimized for performance.
• Build Tools - Build tool focused on small, reusable modules.

Star-Verlauf