BuildKit

BuildKit converts source code into build artifacts and provides tools to define and run builds. Its architecture consists of the buildkitd daemon and buildctl client, with LLB—a binary format for process dependency graphs—used to describe builds. Build definitions can use Dockerfiles and other LLB-compatible frontends. BuildKit supports concurrent dependency resolution, instruction caching, cache import and export, nested build jobs, multiple output formats, and automatic garbage collection. Builds can run without root privileges, and workers can use OCI (runc) or containerd backends. Results can be exported as images, local directories, tarballs, Docker tarballs, or OCI tarballs. The daemon provides a gRPC API over a Unix socket by default and can also use TCP sockets. Binaries are available for Linux, macOS, and Windows. One macOS caveat is that the unofficial Homebrew formula omits buildkitd; Lima in a Linux virtual machine is offered as one way to run it. The project uses the Apache-2.0 license.

BuildKit offers configurable build definitions, caching, and a range of output formats. macOS users relying on the unofficial Homebrew formula should note that it does not include the daemon.

BuildKit suits developers and teams who need a build toolkit with cache controls, multiple output formats, and rootless execution. It is available for Linux, macOS, and Windows.

BuildKit is a build toolkit for developers and platform teams who need to define and run repeatable builds within container-oriented workflows. It is a strong fit for users who want control over build execution and caching, but less suited to anyone seeking a managed, turnkey service.

Overview

BuildKit separates the buildkitd daemon from its buildctl client. Builds are expressed as LLB process-dependency graphs, a vendor-neutral format that supports concurrent execution and cache reuse. That makes BuildKit useful beyond a single Dockerfile workflow, though operating the daemon and choosing how it fits into a pipeline call for technical ownership.

Docker Engine 23.0 and later use Buildx and BuildKit by default for docker build, so Docker users may already encounter it as part of their existing setup. The project identifies adopters including Moby and Docker, Tekton Pipelines, Gitpod, Dagger, and Depot. BuildKit is licensed under Apache-2.0.

Key features

Flexible definitions and reusable work

Frontends convert build definitions into LLB; Dockerfiles and other LLB languages are supported. Concurrent dependency resolution and instruction caching can reduce repeated work, while cache import and export let teams reuse results across environments. Export options include inline, registry, local directory, and GitHub Actions cache. GitHub Actions, S3, and Azure Blob cache options are marked experimental, so they are a less dependable foundation for workflows that require a settled cache path.

Build outputs can be exported as images, local directories, tarballs, Docker tarballs, or OCI tarballs. Automatic garbage collection helps manage build data, and nested jobs, distributable workers, and pluggable architecture give infrastructure teams more ways to shape execution. The trade-off is breadth: BuildKit offers building blocks, not a turnkey interface that makes those choices for the user.

Execution and security boundaries

BuildKit supports execution without root privileges, and its daemon can use OCI (runc) or containerd worker backends. Its default configuration restricts API access to the BuildKit state directory rather than the rest of the host filesystem; application and frontend containers cannot directly reach the host system, use privileged system calls, or access external devices. That is a meaningful safeguard when working with untrusted sources, though it does not remove the need to configure and operate the daemon responsibly.

The daemon exposes a gRPC API, using /run/buildkit/buildkitd.sock by default, with TCP sockets also supported. BuildKit consists of that daemon and the buildctl client, so API-driven use fits teams comfortable integrating build infrastructure rather than expecting a standalone desktop application.

Pricing

BuildKit is free under the BuildKit (Apache License 2.0) plan: free, perpetual, worldwide, non-exclusive, no-charge, and royalty-free. There are no paid tiers or usage limits stated, making it a practical option for individuals and teams that can supply their own build environment. Its low price does not include a hosted workflow; the daemon and surrounding infrastructure remain the user's responsibility.

Platforms

BuildKit supports Linux, Windows, and macOS, and binaries are available for all three. The macOS Homebrew formula is unofficial and does not include the buildkitd daemon; running it via a Linux virtual machine, such as Lima, is one route. Mac users should account for that extra setup rather than assume a native formula provides the complete build system.

Who it's for

BuildKit suits developers and platform teams who want cache-aware, configurable builds and are prepared to run a daemon or use Buildx within Docker. Rootless execution and host-isolation defaults are useful for teams handling untrusted build inputs. It is a poorer fit for people who want a managed build service, a simple desktop workflow, or a macOS installation with the daemon included out of the box.

Pros and cons

• Pros: Free Apache-2.0 licensing and no stated usage limits make it accessible for sustained use.
• Pros: Multiple frontends, output formats, workers, and cache paths support varied build pipelines.
• Pros: Rootless execution and default host-access restrictions help contain build activity.
• Cons: Users must operate and integrate the daemon and client rather than rely on a hosted, managed workflow.
• Cons: The unofficial macOS Homebrew formula omits the daemon, adding a Linux VM or equivalent setup step.
• Cons: Several cache options, including S3 and Azure Blob, are experimental.

Alternatives

Buildah is another free command-line option for readers who want an open-source alternative without paid tiers or stated usage limits. Kaniko is worth considering when the requirement is specifically to build container images from Dockerfiles and distribute the builder as a container image.

Cloud Native Buildpacks Pack offers a free CLI and Go library, making it a reasonable choice for readers who want those interfaces. Dagger may suit an individual seeking a freemium offering with a free trial; its Individual plan includes one user, 1,000,000 monthly events, one month of run history, and community support.

Paketo Buildpacks is a free option for readers specifically seeking open-source buildpacks for container images. Jib is the more focused choice for Java container building tools.

Earthly is another free option for readers comparing build tools. Depot is a paid alternative with a free trial; its Developer plan costs $20 a month, billed monthly, and includes one user, 500 Docker build minutes, 2,000 Depot CI minutes, and 2,000 GitHub Actions minutes.

Verdict

Choose BuildKit if you need a free, extensible build engine with reusable caching, multiple output formats, and control over execution. Its strongest case is flexibility within a pipeline you can operate; look elsewhere if you want a managed service or a macOS setup that includes the daemon without extra work.