Xmake

https://github.com/xmake-io/xmake
Admin
Xmake is a cross-platform build utility based on the Lua scripting language, serving as a modern...
Tokens:192,928
Snippets:1,609
Trust Score:7.7
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Complete xpack configuration example

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.6-released,-New-Packaging-Plugin:-XPack

A comprehensive example showing how to configure a complex source-based installation package.

```lua
xpack("xmakesrc")
     set_formats("runself")
     set_basename("xmake-v$(version)")
     set_prefixdir("xmake-$(version)")
     before_package(function (package)
         import("devel.git")

         local rootdir = path.join(os.tmpfile(package:basename()) .. ".dir", "repo")
         if not os.isdir(rootdir) then
             os.tryrm(rootdir)
             os.cp(path.directory(os.projectdir()), rootdir)

             git.clean({repodir = rootdir, force = true, all = true})
             git.reset({repodir = rootdir, hard = true})
             if os.isfile(path.join(rootdir, ".gitmodules")) then
                 git.submodule.clean({repodir = rootdir, force = true, all = true})
                 git.submodule.reset({repodir = rootdir, hard = true})
             end
         end

         local extraconf = {rootdir = rootdir}
         package:add("sourcefiles", path.join(rootdir, "core/**|src/pdcurses/**|src/luajit/**|src/tbox/tbox/src/demo/**"), extraconf )
         package:add("sourcefiles", path.join(rootdir, "xmake/**"), extraconf)
         package:add("sourcefiles", path.join(rootdir, "*.md"), extraconf)
         package:add("sourcefiles", path.join(rootdir, "configure"), extraconf)
         package:add("sourcefiles", path.join(rootdir, "scripts/*.sh"), extraconf)
         package:add("sourcefiles", path.join(rootdir, "scripts/man/**"), extraconf)
         package:add("sourcefiles", path.join(rootdir, "scripts/debian/**"), extraconf)
         package:add("sourcefiles", path.join(rootdir, "scripts/msys/**"), extraconf)
     end)

     on_installcmd(function (package, batchcmds)
         batchcmds:runv("./scripts/get.sh", {"__local__"})
     end)
```

--------------------------------

### Install basic packages

Source: https://github.com/xmake-io/xmake/wiki/Xmake-and-Cplusplus--Package-Management

Install one or more packages from the repository.

```bash
$ xrepo install zlib tbox
```

--------------------------------

### Install Application

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.3-released,-Support-for-building-iOS-MacOS-Framework-and-App

Install the application to the device or system directory.

```console
$ xmake install
```

--------------------------------

### Install xmake via Ubuntu PPA

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.7-released,-Add-tinyc-and-emscripten-toolchains

Install xmake on Ubuntu by adding the xmake-io PPA and then updating and installing the package.

```bash
sudo add-apt-repository ppa:xmake-io/xmake
sudo apt update
sudo apt install xmake
```

--------------------------------

### Install with custom configurations

Source: https://github.com/xmake-io/xmake/wiki/Xmake-and-Cplusplus--Package-Management

Pass configuration flags to the package installation.

```bash
$ xrepo install -f "vs_runtime=MD" zlib
$ xrepo install -f "regex=true,thread=true" boost
```

--------------------------------

### XMake and Vcpkg Integration

Source: https://github.com/xmake-io/xmake/wiki/C-and-Cplusplus-build-system,-I-use-xmake

Example of integrating a Vcpkg package in XMake, which handles automatic installation.

```lua
add_requires("vcpkg::zlib", {alias = "zlib"})
target("test")
    set_kind("binary")
    add_files("src/*.c")
    add_packages("zlib")
```

```bash
$ xmake
note: try installing these packages (pass -y to skip confirm)?
-> vcpkg::zlib
please input: y (y/n)

=> install vcpkg::zlib .. ok
[25%]: compiling.release src\main.cpp
[50%]: linking.release test
[100%]: build ok!
```

--------------------------------

### Install Xmake with Wget

Source: https://github.com/xmake-io/xmake/blob/dev/README.md

Installs Xmake using a Wget command that downloads and pipes the installation script to bash.

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

--------------------------------

### Install pkgconfig import files with utils.install.pkgconfig_importfiles

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.5.3-Released,-Support-to-build-Linux-bpf-program-and-integrate-Conda-packages

Installs pkgconfig/.pc import files via the `utils.install.pkgconfig_importfiles` rule. Useful for library detection by tools like autotools.

```lua
target("test")
    set_kind("binary")
    add_files("src/*.c")
    add_rules("utils.install.pkgconfig_importfiles")
```

--------------------------------

### Platform matching pattern examples

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.7-released,-Add-cosmocc-toolchain-support,-build‐once-run‐anywhere

Various examples of platform and host filtering syntax.

```lua
-- `@linux`
-- `@linux|x86_64`
-- `@macosx,linux`
-- `android@macosx,linux`
-- `android|armeabi-v7a@macosx,linux`
-- `android|armeabi-v7a@macosx,linux|x86_64`
-- `android|armeabi-v7a@linux|x86_64`
```

--------------------------------

### Complete linkorders example with add_linkorders and add_linkgroups

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.5-released,-Support-for-link-sorting-and-unit-testing

Complete example combining add_linkorders, add_linkgroups, add_frameworks, and add_packages across multiple targets. Demonstrates sorting frameworks, link groups, and dependencies in a real project.

```lua
add_rules("mode.debug", "mode.release")

add_requires("libpng")

target("bar")
     set_kind("shared")
     add_files("src/foo.cpp")
     add_linkgroups("m", "pthread", {whole = true})

target("foo")
     set_kind("static")
     add_files("src/foo.cpp")
     add_packages("libpng", {public = true})

target("demo")
     set_kind("binary")
     add_deps("foo")
     add_files("src/main.cpp")
     if is_plat("linux", "macosx") then
         add_syslinks("pthread", "m", "dl")
     end
     if is_plat("macosx") then
         add_frameworks("Foundation", "CoreFoundation")
     end
     add_linkorders("framework::Foundation", "png", "foo")
     add_linkorders("dl", "linkgroup::syslib")
     add_linkgroups("m", "pthread", {name = "syslib", group = true})
```

--------------------------------

### Debug xmake install command with EmmyLua debugger

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.3-Released,-Improve-Wasm-and-Support-Xmake-Source-Debugging

Example of debugging a different xmake command, here `xmake install -o /tmp`, by changing the arguments after `--`.

```bash
$ xrepo env -b emmylua_debugger -- xmake install -o /tmp
```

--------------------------------

### Install Xmake with cURL, Wget, or PowerShell

Source: https://github.com/xmake-io/xmake/wiki/Home

Install Xmake using the official scripts. The cURL and Wget commands work on Unix-like systems, while the PowerShell command is for Windows. Each downloads and runs the installer directly.

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

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

```sh
Invoke-Expression (Invoke-Webrequest 'https://xmake.io/psget.text' -UseBasicParsing).Content
```

--------------------------------

### Customize build and install scripts

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.6-released,-New-Packaging-Plugin:-XPack

Use on_buildcmd and on_installcmd to define custom build and installation logic for the package.

```lua
xpack("test")
     set_homepage("https://xmake.io")
     set_license("Apache-2.0")
     set_description("A cross-platform build utility based on Lua.")

     set_formats("srpm")
     add_sourcefiles("(src/**)")
     add_sourcefiles("./configure")

     on_buildcmd(function (package, batchcmds)
         batchcmds:runv("./configure")
         batchcmds:runv("make")
     end)

     on_installcmd(function (package, batchcmds)
         batchcmds:runv("make", {"install", "PREFIX=%{buildroot}"})
     end)
```

--------------------------------

### Resign Examples

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.3-released,-Support-for-building-iOS-MacOS-Framework-and-App

Examples of re-signing with different levels of parameter specification.

```console
$ xmake l utils.ipa.resign test.ipa
$ xmake l utils.ipa.resign test.app "Apple Development: waruqi@gmail.com (T3NA4MRVPU)"
$ xmake l utils.ipa.resign test.ipa "Apple Development: waruqi@gmail.com (T3NA4MRVPU)" iOS Team Provisioning Profile: org.tboox.test" org.tboox.test
```

--------------------------------

### Install Xmake with cURL

Source: https://github.com/xmake-io/xmake/blob/dev/README.md

Installs Xmake using a cURL command that fetches and executes the installation script from xmake.io.

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

--------------------------------

### Install Xmake with PowerShell

Source: https://github.com/xmake-io/xmake/blob/dev/README.md

Installs Xmake using a PowerShell command that downloads and executes the installation script.

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

--------------------------------

### Install package with mirror acceleration

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.5.5-released,-Support-to-download-and-install-precompiled-packages

Install a package using xrepo, which will automatically apply the mirror proxy configuration to the download URL.

```console
$ xrepo install libpng
> curl https://hub.fastgit.org/glennrp/libpng/archive/v1.6.37.zip -o v1.6.37.zip
```

--------------------------------

### Install generated package

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.6-released,-New-Packaging-Plugin:-XPack

Installs the program by executing the generated shell script.

```bash
$ sh ./build/xpack/test/test-macosx-src-v1.0.0.gz.run
```

--------------------------------

### Install xmake via winget

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.7-released,-Add-tinyc-and-emscripten-toolchains

Install xmake on Windows using the winget package manager.

```bash
winget install xmake
```

--------------------------------

### Install from third-party managers

Source: https://github.com/xmake-io/xmake/wiki/Xmake-and-Cplusplus--Package-Management

Install packages using external managers like brew, vcpkg, or conan.

```bash
$ xrepo install brew::zlib
$ xrepo install vcpkg::zlib
$ xrepo install conan::zlib/1.2.11
```

--------------------------------

### Start Xmake Remote Build Server with Verbose Logs

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.5-released,-Support-remote-compilation

Starts the remote build service with detailed log output shown; still listens on 0.0.0.0:9690.

```console
$ xmake service -vD
<remote_build_server>: listening 0.0.0.0:9690 ...
```

--------------------------------

### Install package from Homebrew repository

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.3-released,-Support-Vcpkg-manifest-mode

Installs a package from the Homebrew third-party repository by prefixing the package name with 'brew::'. No version is specified in this example.

```cmake
xrepo_package("brew::gflags")
```

--------------------------------

### Install package from Vcpkg repository

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.3-released,-Support-Vcpkg-manifest-mode

Installs a package from the Vcpkg third-party repository by prefixing the package name with 'vcpkg::'. No version is specified in this example.

```cmake
xrepo_package("vcpkg::gflags")
```

--------------------------------

### Create Framework Project

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.3-released,-Support-for-building-iOS-MacOS-Framework-and-App

Quickly initialize a framework project using xmake templates.

```console
$ xmake create -t xcode.framework -l objc test
```

--------------------------------

### CMake and Conan Integration

Source: https://github.com/xmake-io/xmake/wiki/C-and-Cplusplus-build-system,-I-use-xmake

Example of using Conan with CMake, requiring a conanfile.txt and manual installation steps.

```cmake
cmake_minimum_required(VERSION 2.8.12)
project(Hello)

add_definitions("-std=c++11")

include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()

add_executable(hello hello.cpp)
target_link_libraries(hello gtest)
```

```text
[requires]
gtest/1.10.0

[generators]
cmake
```

--------------------------------

### CMake and Vcpkg Integration

Source: https://github.com/xmake-io/xmake/wiki/C-and-Cplusplus-build-system,-I-use-xmake

Example of using Vcpkg with CMake, requiring manual toolchain configuration and package installation.

```cmake
cmake_minimum_required(VERSION 3.0)
project(test)
find_package(unofficial-sqlite3 CONFIG REQUIRED)
add_executable(main main.cpp)
target_link_libraries(main PRIVATE unofficial::sqlite3::sqlite3)
```

--------------------------------

### Show basic project and xmake information

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.4-released,-Better-toolchain-support

Displays environment and project-specific configuration details.

```bash
$ xmake show
The information of xmake:
    version: 2.3.3+202006011009
    host: macosx/x86_64
    programdir: /Users/ruki/.local/share/xmake
    programfile: /Users/ruki/.local/bin/xmake
    globaldir: /Users/ruki/.xmake
    tmpdir: /var/folders/32/w9cz0y_14hs19lkbs6v6_fm80000gn/T/.xmake501/200603
    workingdir: /Users/ruki/projects/personal/tbox
    packagedir: /Users/ruki/.xmake/packages
    packagedir(cache): /Users/ruki/.xmake/cache/packages/2006

The information of project: tbox
    version: 1.6.5
    plat: macosx
    arch: x86_64
    mode: release
    buildir: build
    configdir: /Users/ruki/projects/personal/tbox/.xmake/macosx/x86_64
    projectdir: /Users/ruki/projects/personal/tbox
    projectfile: /Users/ruki/projects/personal/tbox/xmake.lua
```

--------------------------------

### Configure XPack in xmake.lua

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.6-released,-New-Packaging-Plugin:-XPack

Example configuration for XPack, defining package formats, metadata, and custom installation/uninstallation commands.

```lua
set_version("1.0.0")
add_rules("mode.debug", "mode.release")

includes("@builtin/xpack")

target("test")
     set_kind("binary")
     add_files("src/*.cpp")

xpack("test")
     set_formats("nsis", "zip", "targz", "runself")
     set_title("hello")
     set_author("ruki")
     set_description("A test installer.")
     set_homepage("https://xmake.io")
     set_licensefile("LICENSE.md")
     add_targets("test")
     add_installfiles("src/(assets/*.png)", {prefixdir = "images"})
     add_sourcefiles("(src/**)")
     set_iconfile("src/assets/xmake.ico")

     after_installcmd(function (package, batchcmds)
         batchcmds:mkdir(package:installdir("resources"))
         batchcmds:cp("src/assets/*.txt", package:installdir("resources"), {rootdir = "src"})
         batchcmds:mkdir(package:installdir("stub"))
     end)

     after_uninstallcmd(function (package, batchcmds)
         batchcmds:rmdir(package:installdir("resources"))
         batchcmds:rmdir(package:installdir("stub"))
     end)
```

--------------------------------

### Show toolchains list

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.4-released,-Better-toolchain-support

Lists available toolchains configured in the environment.

```bash
$ xmake show -l toolchains
xcode         Xcode IDE
vs            VisualStudio IDE
yasm          The Yasm Modular Assembler
clang         A C language family frontend for LLVM
...
```

--------------------------------

### Server authentication configuration for remote build

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.6-Released,-Support-Distributed-Compilation-and-Build-Cache

Example server configuration file at ~/.xmake/service/server.conf. It defines known_hosts, logfile, remote_build listen address and workdir, and a list of tokens for user authentication.

```bash
$ cat ~/.xmake/service/server.conf
{
    known_hosts = { },
    logfile = "/Users/ruki/.xmake/service/server/logs.txt",
    remote_build = {
        listen = "0.0.0.0:9691",
        workdir = "/Users/ruki/.xmake/service/server/remote_build"
    },
    tokens = {
        "e438d816c95958667747c318f1532c0f"
    }
}
```

--------------------------------

### Install debug version

Source: https://github.com/xmake-io/xmake/wiki/Xmake-and-Cplusplus--Package-Management

Install the debug build of a package.

```bash
$ xrepo install -m debug zlib
```

--------------------------------

### Build Zig project with xmake

Source: https://github.com/xmake-io/xmake/wiki/Use-xmake-to-build-Zig-project

Run `xmake` to build the Zig project. This is the standard build command.

```console
$ xmake
```

--------------------------------

### Configure server password authentication with xmake service --add-user and --rm-user

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.6-Released,-Support-Distributed-Compilation-and-Build-Cache

Server-side password authentication setup: add a user with `xmake service --add-user=ruki`, which prompts for a password and then updates the server config file `~/.xmake/service/server.conf` with a generated token. The config shows the token list and other server settings. To remove a user, use `xmake service --rm-user=ruki`; it also prompts for the password and confirms removal.

```bash
$ xmake service --add-user=ruki
Please input user ruki password:
123456
Add user ruki ok!

```

```bash
$ cat ~/.xmake/service/server.conf
{
    known_hosts = { },
    logfile = "/Users/ruki/.xmake/service/server/logs.txt",
    remote_build = {
        listen = "0.0.0.0:9691",
        workdir = "/Users/ruki/.xmake/service/server/remote_build"
    },
    tokens = {
        "e438d816c95958667747c318f1532c0f",
        "7889e25402413e93fd37395a636bf942"
    }
}

```

```bash
$xmake service --rm-user=ruki
Please input user ruki password:
123456
Remove user ruki ok!

```

--------------------------------

### Deploying Qt applications on Windows

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.5.1-released,-Support-for-Apple-Silicon-and-more-powerful--package-management

Commands to compile and install a Qt application, triggering windeployqt automatically.

```bash
$ xmake
$ xmake install -o d:\installdir
```

--------------------------------

### Install Specific Package

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.3-released,-Support-for-building-iOS-MacOS-Framework-and-App

Install a specific IPA or APP file to the device.

```console
$ xmake l utils.ipa.install test.app
$ xmake l utils.ipa.install test.ipa
```

--------------------------------

### Initiate Xmake build for detected library

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.7.2-released,-build-third-party-libraries-more-intelligently

Run the xmake command in the library directory. Xmake will detect the library and prompt for confirmation to proceed with the build.

```bash
ruki-2:libjpeg-turbo-2.1.4 ruki$ xmake
note: libjpeg-turbo 2.1.4 in xmake-repo found, try building it or you can run ``xmake f --trybuild=` to set buildsystem (pass -y or --confirm=y/n/d to skip confirm)?
please input: y (y/n)
```

--------------------------------

### Install dynamic library version

Source: https://github.com/xmake-io/xmake/wiki/Xmake-and-Cplusplus--Package-Management

Install the shared library version of a package.

```bash
$ xrepo install -k shared zlib
```

--------------------------------

### Install specific package versions

Source: https://github.com/xmake-io/xmake/wiki/Xmake-and-Cplusplus--Package-Management

Supports Semantic Versioning for package installation.

```bash
$ xrepo install "zlib 1.2.x"
$ xrepo install "zlib >=1.2.0"
```

--------------------------------

### Import configuration with menu

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.5.5-released,-Support-to-download-and-install-precompiled-packages

Import configuration using the menu interface.

```console
$ xmake f --menu --import=/tmp/config.txt
$ xmake f --menu -m debug --xxx=y --import=/tmp/config.txt
```

--------------------------------

### Exclusion pattern examples

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.7-released,-Add-cosmocc-toolchain-support,-build‐once-run‐anywhere

Examples of using the '!' operator to exclude specific platforms or architectures.

```bash
@!linux
@!linux|x86_64
@!macosx,!linux
!android@macosx,!linux
android|!armeabi-v7a@macosx,!linux
android|armeabi-v7a,!iphoneos@macosx,!linux|x86_64
!android|armeabi-v7a@!linux|!x86_64
!linux|*
```

--------------------------------

### Force source code compilation with xrepo install --build

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.5.5-released,-Support-to-download-and-install-precompiled-packages

Use the --build parameter with xrepo install to force source code compilation and installation instead of using precompiled packages.

```console
$ xrepo install --build openssl
```

--------------------------------

### Connect to Xmake Remote Server

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.5-released,-Support-remote-compilation

Creates a new Xmake project, enters its directory, and connects to the remote server. Output shows file sync progress and confirms success.

```console
$ xmake create test
```

```console
$ cd test
```

```console
$ xmake service --connect 
<remote_build_client>: connect 192.168.56.110:9690 ...
<remote_build_client>: connected!
<remote_build_client>: sync files in 192.168.56.110:9690 ...
Scanning files ...
Comparing 3 files ...
    [+]: src/main.cpp
    [+]: .gitignore
    [+]: xmake.lua
3 files has been changed!
Archiving files .
Uploading files with 1372 bytes ...
<remote_build_client>: sync files ok!
```

--------------------------------

### Connect to remote server with xmake service --connect (token auth)

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.6-Released,-Support-Distributed-Compilation-and-Build-Cache

Connect to a remote server with token authentication: create a project, enter its directory, and run `xmake service --connect`. No password is required; the client connects, syncs files, and uploads changed files. Output shows the sync progress and success message.

```console
$ xmake create test
$ cd test
$ xmake service --connect
<remote_build_client>: connect 192.168.56.110:9091 ..
<remote_build_client>: connected!
<remote_build_client>: sync files in 192.168.56.110:9091 ..
Scanning files ..
Comparing 3 files ..
    [+]: src/main.cpp
    [+]: .gitignore
    [+]: xmake.lua
3 files has been changed!
Archiving files ..
Uploading files with 1372 bytes ..
<remote_build_client>: sync files ok!

```

--------------------------------

### First execution output of native_module example

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.9.1-released,-Add-native-lua-modules-support

Shows the first execution of xmake for the native_module example: it builds the native modules (foo and bar) and then runs the test target, printing the results. The output includes build progress and the final "build ok" messages.

```bash
ruki-2:native_module ruki$ xmake
[50%]: cache compiling.release src/foo.c
[50%]: cache compiling.release src/bar.c
[75%]: linking.release libmodule_foo.dylib
[75%]: linking.release module_bar
[100%]: build ok, spent 1.296s
foo: 1 + 1 = 2
foo: 1 - 1 = 0
bar: 1 + 1 = 2
[100%]: build ok, spent 0.447s

```

--------------------------------

### Install xmake via dnf from Copr

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.8-released,-Add-Intel-Compiler-Support

Installs xmake on Fedora, RHEL, OpenSUSE, CentOS and similar distributions using the Copr repository. The first command enables the waruqi/xmake Copr repo, then dnf installs xmake.

```bash
sudo dnf copr enable waruqi/xmake
sudo dnf install xmake
```

--------------------------------

### Install Xmake on Fedora

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.6-released,-New-Packaging-Plugin:-XPack

Command to install Xmake using the dnf package manager on Fedora 39.

```bash
$ sudo dnf install xmake
```

--------------------------------

### Client authentication configuration for remote build

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.6-Released,-Support-Distributed-Compilation-and-Build-Cache

Example client configuration file at ~/.xmake/service/client.conf. It specifies the remote_build connect address and the token to authenticate with the server.

```bash
$ cat ~/.xmake/service/client.conf
{
    remote_build = {
        connect = "127.0.0.1:9691",
        token = "e438d816c95958667747c318f1532c0f"
    }
}
```

--------------------------------

### Configure platform, architecture, and mode

Source: https://github.com/xmake-io/xmake/blob/dev/README.md

Configures the build with platform, architecture, and mode options, then builds. The first command sets the configuration; the second builds the project.

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

```bash
$ xmake
```

--------------------------------

### View xmake client.conf

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.6-Released,-Support-Distributed-Compilation-and-Build-Cache

Shows the client configuration file. The hosts list contains server addresses and tokens. Use token authentication for distributed compilation to avoid entering a password for each connection.

```console
$cat ~/.xmake/service/client.conf
{
    distcc_build = {
        hosts = {
            {
                connect = "127.0.0.1:9693",
                token = "590234653af52e91b9e438ed860f1a2b"
            }
        }
    }
}
```

--------------------------------

### Download Xmake source code

Source: https://github.com/xmake-io/xmake/blob/dev/CONTRIBUTING.md

Clone the repository and navigate to the directory to begin development.

```bash
git clone --recursive https://github.com/xmake-io/xmake.git
cd xmake
```

--------------------------------

### PAC configuration rule example

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.5-released,-Multi-toolchain-flexible-switching-support

A Lua function example for defining proxy routing rules in a PAC file.

```lua
function main(url, host)
    if host:find("bintray.com") then
        return true
    end
end
```

--------------------------------

### Android BPF build output with package installation

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.5.3-Released,-Support-to-build-Linux-bpf-program-and-integrate-Conda-packages

Shows the output of reconfiguring for Android with clean cache and then building. It lists the packages xmake will install (libcap, zlib, libelf, linux-tools, ndk, libbpf) and prompts for confirmation, then installs them and builds successfully.

```bash
$ xmake f -p android -c
checking for architecture ... armeabi-v7a
checking for Android SDK directory ... no
checking for NDK directory ... no
note: try installing these packages (pass -y to skip confirm)?
in local-repo:
  -> libcap 2.27 [linux, x86_64, from:linux-tools]
  -> libelf 0.8.13 [linux, x86_64, from:linux-tools]
  -> zlib 1.2.11 [linux, x86_64, from:linux-tools]
  -> linux-tools 5.9.16 [bpftool:y]
  -> ndk 22.0
  -> libelf#1 0.8.13 [toolchains:@ndk, from:libbpf]
  -> zlib#1 1.2.11 [toolchains:@ndk, from:libbpf]
  -> libbpf v0.3 [toolchains:@ndk]
please input: y (y/n)

  => install libcap 2.27 .. ok
  => install zlib 1.2.11 .. ok
  => install libelf 0.8.13 .. ok
  => install ndk 22.0 .. ok
  => install linux-tools 5.9.16 .. ok
  => install libelf#1 0.8.13 .. ok
  => install zlib#1 1.2.11 .. ok
  => install libbpf v0.3 .. ok
ruki@010689392c4d:/mnt/bpf_minimal$ xmake
[20%]: compiling.bpf src/minimal.bpf.c
[40%]: ccache compiling.release src/minimal.c
[60%]: linking.release minimal
[100%]: build ok!
```

--------------------------------

### Open menu configuration with xmake f --menu

Source: https://github.com/xmake-io/xmake/blob/dev/README.md

Opens an interactive menu for configuring the project. Use this command to access the graphical configuration interface.

```bash
$ xmake f --menu
```

--------------------------------

### Upgrade MSBuild Projects during Installation

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.8.1-Released,-Lots-of-Detailed-Feature-Improvements

Using the tools.msbuild module to automatically upgrade legacy vcproj/sln files during package installation.

```lua
package("test")
    on_install(function (package)
        import("package.tools.msbuild").build(package, configs, {upgrade={"wolfssl64.sln", "wolfssl.vcxproj"}}))
    end)
```

--------------------------------

### Start Xmake Remote Build Server

Source: https://github.com/xmake-io/xmake/wiki/Xmake-v2.6.5-released,-Support-remote-compilation

Starts the remote build service on a specific address; by default listens on 0.0.0.0:9690.

```console
$ xmake service
<remote_build_server>: listening 0.0.0.0:9690 ...
```

--------------------------------

### Build Qt/Wasm project with xmake f -p wasm

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.8-released,-Add-Intel-Compiler-Support

Switch to the wasm platform and build the Qt/Wasm project. Optionally specify the Qt SDK path with --qt. After compilation, xmake generates demo.html, demo.js, and demo.wasm in the build directory.

```bash
$ xmake f -p wasm [--qt=~/Qt]
$ xmake
```

--------------------------------

### List supported policy configurations

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.3.4-released,-Better-toolchain-support

Execute this command to view all available policy configurations and their descriptions.

```bash
$ xmake l core.project.policy.policies
{
  "check.auto_map_flags" = {
    type = "boolean",
    description = "Enable map gcc flags to the current compiler and linker automatically.",
    default = true
  },
  "build.across_targets_in_parallel" = {
    type = "boolean",
    description = "Enable compile the source files for each target in parallel.",
    default = true
  },
  "check.auto_ignore_flags" = {
    type = "boolean",
    description = "Enable check and ignore unsupported flags automatically.",
    default = true
  }
}
```

--------------------------------

### Create Zig project

Source: https://github.com/xmake-io/xmake/wiki/xmake-v2.5.1-released,-Support-for-Apple-Silicon-and-more-powerful--package-management

Command to initialize a new Zig console project.

```bash
$ xmake create -l zig console
```
Tokens:
Raw