earthly/earthly

Features

• Containerized Build Environments - Executes every build step inside isolated containers to ensure environment consistency and portability across machines.
• Build Environment Isolation - Executes every build step inside a separate container to ensure complete environment consistency and portability.
• Reproducible Build Environments - Defines sequences of isolated build steps to ensure software compiles and tests identically on any machine.
• Build Artifact Caching - Persists temporary files and object directories between runs using mount-based caching to avoid recompiling.
• Reproducible - Ensures build consistency across different developer machines by executing all steps inside isolated containers.
• Build Orchestrators - Models build steps as a directed acyclic graph to orchestrate parallel execution and reuse cached results.
• Cross-Platform Build Pipelines - Automates the generation of build artifacts for multiple target architectures and platforms in a single execution flow.
• Multiplatform Build Pipelines - Generates software binaries and container images for multiple hardware architectures within a single coordinated execution flow.
• Remote Build Caches - Shares intermediate build artifacts across teams using a distributed cache to accelerate the development cycle.
• Build and Task Automation - Sequences build operations using explicit wait clauses to coordinate the execution order of interdependent tasks.
• Container Image Builders - Generates container images targeting multiple CPU architectures and platforms within a single execution flow.
• Container Image Management - Builds container images from definition files and manages their distribution to registries with platform manifest control.
• Container Image Packaging - Combines compiled binaries and application files into final container image targets for deployment.
• Container Image Registry Uploads - Constructs images from build outputs and sends them to remote registries for deployment.
• Dependency Tracking - Combines Dockerfile isolation with Makefile-style dependency tracking and parallel execution.
• Multi-Architecture Images - Generates container images targeting multiple CPU architectures using cross-compilation and emulation.
• Containerized Build Systems - Provides a build system where every step runs inside an isolated container for environment consistency.
• Hermetic Build Environments - Ensures reproducibility by isolating network access and managing secrets without leaking them into image layers.
• Hermetic Network Isolation - Ensures build reproducibility by restricting network access for specific commands to create a hermetic environment.
• Build Result Caching - Saves the output of build steps based on file hashes to avoid redundant computations across teams.
• Pipeline Definitions - Defines the build and release lifecycle as a sequence of targets that manage dependencies and commands within containers.
• Execution Graphs - Models build targets as a directed acyclic graph to optimize parallel execution and result reuse.
• Content-Addressable Caches - Uses content-addressable storage to deduplicate and retrieve intermediate build artifacts based on source input hashes.
• Build Cache Mounts - Declares persistent cache mounts using a dedicated command to optimize incremental builds.
• Task Execution Caches - Skips unnecessary execution steps by reusing cached intermediate artifacts when source changes do not affect targets.
• Persistent Cache Mounts - Implements dedicated cache mounts to persist object directories and temporary files across separate build executions.
• Artifact Dependency Management - Incorporates artifacts from multiple external repositories into a single unified build process.
• Remote Target Artifact Extraction - Clones remote repositories, executes specific build targets, and extracts resulting artifacts into the current environment.
• Build Artifact Exports - Saves files generated during the build process to a local directory for use outside the container.
• Remote Target Execution - References and executes build logic from different directories or remote repositories to share artifacts and images.
• Build Definition Importers - Provides the ability to fetch and utilize build target definitions from remote configuration files to share logic.
• Automated Test Execution - Triggers and runs unit and integration test suites within isolated containers to verify build consistency.
• Monorepo Build Tools - Coordinates build targets across multiple directories to assemble final applications from disparate monorepo components.
• Parallel Build Engines - Leverages multi-core concurrency to execute independent build targets in parallel, reducing total build time.
• Cross-Repository Artifact Sharing - References targets and files from different directories or remote repositories to reuse existing build logic.
• Unified Build Pipelines - Integrates artifacts from several different repositories into a single unified build pipeline.
• Build Artifact Management - Captures files produced during build steps for export to the local filesystem or use in subsequent targets.
• Build Execution Engines - Executes build pipelines on remote cloud infrastructure to maintain consistency across local and remote environments.
• Secure Secret Distribution - Securely distributes sensitive configuration and credentials across distributed runners and team members.
• Automated Testing Containers - Runs unit and integration tests within isolated containers to ensure consistent results across diverse hardware and OS.
• Dependency Version Locking - Ensures build reproducibility by specifying particular Git tags or branches for remote dependencies.
• Remote Build Orchestration - Executes build pipelines on remote cloud infrastructure with support for custom hardware sizes and HTTP proxies.
• Remote Build Logic Injection - Fetches and executes build definitions from remote version control systems to share logic across projects.
• Secret Management - Provides mechanisms to inject sensitive credentials into build commands without persisting them in container image layers.
• Secret Mounts - Injects sensitive data into build steps as ephemeral files or variables without persisting them in image layers.
• Project Structure Organization - Divides build processes across multiple sub-projects co-located in a single repository for better organization.
• Integration Test Suites - Executes reproducible integration test suites within containerized environments to ensure consistent results.
• Integration Testing - Runs automated test suites in isolated container environments that mimic production for pre-deployment verification.
• Test Orchestration - Coordinates the lifecycle and execution of interdependent containers using compose files for production-mimicking tests.
• Image Builders - Containerized build automation using Makefile-like syntax.

Star history