Xmake is a cross-platform build utility and package manager, written in Lua and licensed under Apache-2.0, that takes a single xmake.lua project file and turns it into builds for desktop, mobile, BSD, Wasm and other targets — it is aimed at C, C++, Objective-C and mixed-toolchain developers who want Make/Ninja-style building, CMake/Meson-style project generation, and Vcpkg/Conan-style dependency handling from one tool.

What it is

Xmake is a cross-platform build utility based on the Lua scripting language. It is deliberately lightweight and has no dependencies outside the standard library, and it uses the xmake.lua file to maintain project builds with a simple, readable syntax. The project describes itself as a combination of build backend, project generator, package manager, remote or distributed build, and cache — roughly the equivalent of Make or Ninja, plus CMake or Meson, plus Vcpkg or Conan, plus distcc, plus ccache or sccache. It can be used to build source code directly, in the manner of Make or Ninja, or it can generate project source files in the manner of CMake or Meson. It sits in the C and C++ ecosystem, and its topic list — build, build-tool, c, c-plus-plus, cmake, cross-toolchains, lua, makefile, objective-c, package-manager, tbox — names the ground it covers.

The concrete problem it solves is toolchain sprawl. A C or C++ project commonly needs one tool to build, a second to generate IDE or project files, a third to fetch and version dependencies, and further machinery to cache or distribute compilation. Xmake folds those roles into one command and one configuration file, and it has a built-in package management system to help users integrate C and C++ dependencies. Dependency declarations sit next to build declarations in the same Lua file: add_requires("tbox 1.6.*", "zlib", "libpng ~1.6") requests tbox v1.6, zlib at any version, and libpng v1.6. The official package repository backing those recipes is xmake-repo.

Key capabilities

• Single-file project description using target("console"), set_kind("binary") and add_files("src/*.c"), which creates a target named console of kind binary and adds every .c file under src.
• Built-in package management with version constraints via add_requires("tbox 1.6.*", "zlib", "libpng ~1.6"), drawing on the official xmake-repo package repository.
• Direct building or project generation: source can be built straight through, like Make or Ninja, or project source files can be generated, like CMake or Meson.
• Short command workflow: xmake to build, xmake run console to run a target, xmake run -d console to debug it, and xmake test to run tests.
• Cross-compilation through one configure command: xmake f -p [windows|linux|macosx|android|iphoneos ..] -a [x86|arm64 ..] -m [debug|release], with a menu-driven alternative at xmake f --menu.
• Toolchain discovery through xmake show -l toolchains, which lists xcode, msvc, clang-cl, clang, yasm, go, dlang, dmd, ldc, gdc, gfortran, flang and zig.
• Broad target coverage: Windows (x86, x64, arm, arm64, arm64ec), macOS (i386, x86_64, arm64), Linux (i386, x86_64, arm, arm64, riscv, mips, 390x, sh4), FreeBSD, NetBSD, OpenBSD, DragonflyBSD, Solaris, Android, iOS, WatchOS, AppleTVOS, AppleXROS, MSYS, MinGW, Cygwin, Wasm (wasm32, wasm64), Haiku, Harmony, and cross-toolchains generally.

Who uses it and how

• C and C++ teams that ship to Linux, macOS and Windows and would rather keep one xmake.lua than maintain separate Makefile, Ninja and CMake setups.
• Native and mobile developers cross-compiling to Android (armeabi, armeabi-v7a, arm64-v8a, x86, x86_64), iOS (armv7, armv7s, arm64, i386, x86_64), WatchOS and AppleTVOS by switching the platform argument to xmake f -p rather than switching build systems.
• Projects whose C and C++ dependencies are awkward to source through an operating-system package manager, and which pull them directly through add_requires from xmake-repo.
• Mixed-language codebases that need assemblers or compilers beyond C and C++, using the listed toolchains such as yasm, go, dmd, ldc, gdc, gfortran, flang and zig.
• Unusual or embedded targets, including wasm32 and wasm64 WebAssembly output and Harmony or Haiku builds.

Getting started

Install with the shell script curl -fsSL https://xmake.io/shget.text | bash or wget https://xmake.io/shget.text -O - | bash, or on Windows with PowerShell irm https://xmake.io/psget.text | iex; other routes, including building from source and package managers, are listed in the Installation Guide. Then run xmake from the project root directory to build.

How it compares

Xmake positions itself against the tools it absorbs, naming Make, Ninja, CMake, Meson, Vcpkg, Conan, distcc and ccache or sccache as the separate pieces it replaces with one Lua-based binary. It is a build backend, project generator, package manager, remote or distributed build, and cache at once, rather than one layer in a multi-tool stack. Where Make and Ninja handle the build step and CMake or Meson handle generation, Xmake is intended to cover both along with dependency resolution.

When to use it — and when not to

It is a reasonable pick when a project wants one dependency-free build tool spanning desktop, mobile and cross-compilation targets, and when a permissively licensed Apache-2.0 build tool that needs nothing outside the Lua standard library is preferred over assembling several components. It is a harder sell for teams already standardized on CMake and its surrounding IDE and packaging ecosystem, or for developers unwilling to learn a Lua-based domain-specific language that differs from CMake syntax. The repository README excerpt is short and defers the real detail to the external documentation site at xmake.io, and the project carries 255 open issues, so a self-hoster should expect to read the full guide rather than rely on the README alone.

Xmake = Build backend + Project Generator + Package Manager + [Remote|Distributed] Build + Cache

Xmake ≈ Make/Ninja + CMake/Meson + Vcpkg/Conan + distcc + ccache/sccache

curl -fsSL https://xmake.io/shget.text | bash

wget https://xmake.io/shget.text -O - | bash

irm https://xmake.io/psget.text | iex

target("console")
    set_kind("binary")
    add_files("src/*.c")

add_requires("tbox 1.6.*", "zlib", "libpng ~1.6")

$ xmake

$ xmake run console

$ xmake run -d console

$ xmake test

$ xmake f -p [windows|linux|macosx|android|iphoneos ..] -a [x86|arm64 ..] -m [debug|release]
$ xmake

$ xmake f --menu

$ xmake show -l toolchains
xcode         Xcode IDE
msvc          Microsoft Visual C/C++ Compiler
clang-cl      LLVM Clang C/C++ Compiler compatible with msvc
yasm          The Yasm Modular Assembler
clang         A C language family frontend for LLVM
go            Go Programming Language Compiler
dlang         D Programming Language Compiler (Auto)
dmd           D Programming Language Compiler
ldc           The LLVM-based D Compiler
gdc           The GNU D Compiler (GDC)
gfortran      GNU Fortran Programming Language Compiler
flang         LLVM Fortran Compiler
zig           Zig Programming Language Compiler
zigcc         Use zig cc/c++ as C/C++ Compiler
sdcc          Small Device C Compiler
cuda          CUDA Toolkit (nvcc, nvc, nvc++, nvfortran)
ndk           Android NDK
rust          Rust Programming Language Compiler
swift         Swift Programming Language Compiler
llvm          A collection of modular and reusable compiler and toolchain technologies
cross         Common cross compilation toolchain
nasm          NASM Assembler
gcc           GNU Compiler Collection
mingw         Minimalist GNU for Windows
gnu-rm        GNU Arm Embedded Toolchain
envs          Environment variables toolchain
fasm          Flat Assembler
tinycc        Tiny C Compiler
emcc          A toolchain for compiling to asm.js and WebAssembly
icc           Intel C/C++ Compiler
ifort         Intel Fortran Compiler
ifx           Intel LLVM Fortran Compiler
muslcc        The musl-based cross-compilation toolchain
fpc           Free Pascal Programming Language Compiler
wasi          WASI-enabled WebAssembly C/C++ toolchain
nim           Nim Programming Language Compiler
dotnet        .NET SDK Toolchain
circle        A new C++20 compiler
armcc         ARM Compiler Version 5 of Keil MDK
armclang      ARM Compiler Version 6 of Keil MDK
c51           Keil development tools for the 8051 Microcontroller Architecture
icx           Intel LLVM C/C++ Compiler
dpcpp         Intel LLVM C++ Compiler for data parallel programming model based on Khronos SYCL
masm32        The MASM32 SDK
iverilog      Icarus Verilog
verilator     Verilator open-source SystemVerilog simulator and lint system
cosmocc       build-once run-anywhere
hdk           Harmony SDK
ti-c2000      TI-CGT C2000 compiler
ti-c6000      TI-CGT C6000 compiler
iararm        IAR ARM C/C++ Compiler
kotlin-native Kotlin Native Programming Language Compiler
filc          A memory safe implementation of the C and C++ programming languages (https://fil-c.org/)
ascendc       Huawei Ascend C (bisheng compiler driver)