make (software)

make (software)
Name	make
Author	Stuart Feldman
Developer	GNU Project, Sun Microsystems, BSD, IBM
Released	1977
Programming language	C, Assembly
Operating system	Unix, Linux, macOS, Microsoft Windows
Genre	Build automation, Software tools
License	Public domain, GPL, BSD, Proprietary

make (software) is a build automation program originally created for the Unix operating system to control the compilation and linking of programs. It orchestrates commands based on file timestamps and dependency relationships to update targets efficiently. make has influenced numerous tools and projects across Free Software Foundation, GNU Project, BSD, and commercial ecosystems such as Sun Microsystems and Microsoft.

History

make originated at Bell Labs in 1977, written by Stuart Feldman during work on Research Unix and distributed with early Unix releases. Its design emerged amid contemporaneous tools at AT&T and influenced later build systems in projects from the Free Software Foundation to proprietary environments like IBM’s development toolchains. As the GNU Project expanded, GNU Make reimplemented the program with extensions to support POSIX conventions and integration with Autoconf, Automake, and Libtool. The Berkeley Software Distribution adapted variants for BSD releases, while corporate vendors such as Sun Microsystems and Microsoft produced platform-specific ports. Throughout the 1980s and 1990s, make became a standard component in Unix System V, System III, and many embedded toolchains for vendors including ARM Holdings and Intel.

Design and features

make is founded on a declarative model where a file called a makefile expresses dependencies between targets and prerequisites, together with rules that invoke shell commands. The original implementation relied on modification times to determine out-of-date targets, reflecting concepts formalized in Dependency graph theory and used in build systems for projects like X Window System, GCC, Linux kernel, Apache HTTP Server, and Perl. GNU Make introduced features such as pattern rules, functions, conditional directives, and parallel execution via the -j flag, enabling concurrency in environments like POSIX, Systemd, and FreeBSD build farms. make supports implicit rules, macros (variables), and file suffix rules, concepts shared with tools such as SCons, CMake, and Ninja. Integration with configuration utilities like Autoconf permits portability across platforms including macOS, Solaris, and Windows NT.

Usage and examples

Developers use make with projects ranging from small utilities to large systems including X.Org, KDE, GNOME, OpenSSL, and Kerberos. Typical usage involves invoking make to build a default target, often "all", or specified targets like "install", "clean", or "test". Common workflows combine make with continuous integration servers such as Jenkins, Travis CI, GitHub Actions, GitLab CI/CD, and build farms managed by OpenStack or Kubernetes. Example workflows interoperate with version control systems like Git, Subversion, and Mercurial to trigger builds on commits and pull requests in projects like Mozilla Firefox, Chromium, and LibreOffice. makefiles often call compilers and linkers from GNU Compiler Collection, Clang, or proprietary toolchains from Microsoft Visual Studio and Intel Parallel Studio.

Variants and alternatives

Numerous variants and replacements have arisen: GNU Make extended features and portability; BSD make (pmake) implemented portability for NetBSD and OpenBSD; Sun Make tailored builds for Solaris; and proprietary solutions appear in Microsoft ecosystems. Alternative build systems include CMake, Ninja, SCons, Meson, Bazel, Buck, Gradle, Maven, and Ant, each addressing scalability, language binding, hermetic builds, or reproducibility. Language-specific toolchains—Cargo for Rust, Go toolchain for Go (programming language), Maven and Gradle for Java, Leiningen for Clojure—offer dependency resolution and packaging beyond make's original scope. Meta-build tools like Autoconf, Automake, and Libtool generate makefiles to bridge portability gaps across varied platforms such as Android, iOS, and Windows CE.

Implementation details

make implementations parse a makefile into an internal dependency graph and traverse it to decide which targets need rebuilding, using file modification times and timestamp comparison algorithms. GNU Make includes a lexer and parser supporting conditionals, recursion, and user-defined functions implemented in C, leveraging system calls from POSIX APIs for file timestamps and process control. Performance optimizations in modern implementations involve parallel DAG scheduling, timestamp caching, and minimal rebuild algorithms used in large projects like Linux kernel and Chromium. Some systems augment timestamp checks with checksum or content-hash strategies employed by tools inspired by make, while others integrate with file system notification APIs from inotify on Linux or FSEvents on macOS to detect changes.

Criticism and limitations

Critics note that reliance on timestamps can cause incorrect incremental builds in distributed or networked file systems such as NFS or with clock skew across machines managed by NTP. The make macro and rule syntax is often described as arcane and error-prone compared with declarative or language-based systems like Bazel or Meson, and debugging complex makefiles in large projects like glibc or Qt can be difficult. make lacks built-in dependency management and artifact caching comparable to Gradle or Buck, and reproducible-builds initiatives point to nondeterminism risks in timestamp-based workflows. Efforts by communities including Debian, Fedora Project, and OpenEmbedded work around these limitations through tooling, wrappers, and standardized build environments.

Category:Build automation tools