TBOOX Open Source Project

• Xmake v2.6.2 released, Support building Linux kernel driver module

  2021-12-17

  xmake

  xmake  lua  C/C++  Linux  Driver

  Xmake is a lightweight cross-platform build utility based on Lua.

  It is very lightweight and has no dependencies because it has a built-in Lua runtime.

  It uses xmake.lua to maintain project builds and its configuration syntax is very simple and readable.

  We can use it to build project directly like Make/Ninja, or generate project files like CMake/Meson, and it also has a built-in package management system to help users solve the integrated use of C/C++ dependent libraries.

  Xmake = Build backend + Project Generator + Package Manager
  

  • Github
  • Document

  

  New version changes

  There are two major new features in this version:

  1. Linux kernel driver module construction support
  2. Support for group building and batch running, which can be used to realize the function of Run all tests

  The rest are mainly scattered function improvements and bugs fixes. You can see the details of the update content at the end of the following. Some of the larger changes will be explained one by one below.

  New feature introduction

  Build Linux kernel driver module

  Xmake may be the first third-party build tool that provides built-in support for Linux kernel driver development.

  Although there are also instructions on how CMake configures and builds Linux drivers on the Internet, most of them use add_custom_command to customize various commands, and then execute echo to splice and generate Linux Makefile files by themselves.

  In other words, it is actually a build that relies on the Makefile of the Linux kernel source code to execute, so if you want to add some compilation configuration and macro definitions yourself, it will be very troublesome.

  With Xmake, we can provide more flexible configurability, simpler configuration files, and features such as one-click compilation, automatic dependency pull integration, automatic download and integration of Linux kernel source code, and cross-compilation of kernel drivers.

  Hello World

  We intuitively feel it through one of the simplest character drivers.

  First, we prepare a Hello World driver code, for example:

  add_requires("linux-headers", {configs = {driver_modules = true}})
  
  target("hello")
      add_rules("platform.linux.driver")
      add_files("src/*.c")
      add_packages("linux-headers")
      set_license("GPL-2.0")
  

  Its configuration is very simple. You only need to configure the linux-headers package that supports the module, and then apply the platform.linux.driver build rule.

  Then directly execute the xmake command, compile with one key, and generate the kernel driver module hello.ko.

  $ xmake
  [20%]: ccache compiling.release src/add.c
  [20%]: ccache compiling.release src/hello.c
  [60%]: linking.release build/linux/x86_64/release/hello.ko
  [100%]: build ok!
  

  阅读中文 Read All

  ---

• xmake v2.6.1 released, Switch to Lua5.4 runtime, Support Rust and C++ mixed compilation

  2021-12-03

  xmake

  xmake  lua  C/C++  Rust  Lua5.4  C++20  Modules

  xmake is a lightweight cross-platform build tool based on Lua. It uses xmake.lua to maintain project builds. Compared with makefile/CMakeLists.txt, the configuration syntax is more Concise and intuitive, it is very friendly to novices, and you can get started quickly in a short time, allowing users to focus more on actual project development.

  In this version, we have added a lot of heavyweight new features, such as: Nim language project build support, Keil MDK, Circle and Wasi toolchain support.

  In addition, we have made major improvements to C++20 Modules, not only supporting the latest gcc-11, clang and msvc compilers, but also automatic analysis of inter-module dependencies to achieve maximum parallel compilation support.

  Finally, there is a more useful feature that is Unity Build support, through which we can greatly improve the compilation speed of C++ code.

  • Github
  • Document

  New feature introduction

  Switch to Lua5.4 runtime by default

  After several versions of iterative testing, we officially switched to the Lua5.4 runtime in version 2.6.1.

  However, this is completely unaware to users, and basically there is no compatibility problem, because xmake encapsulates most of the interfaces, which completely eliminates the compatibility problem between Lua versions.

  In terms of build performance, because the performance bottleneck of the build mainly comes from the compiler, the performance loss of Lua itself is completely negligible, and xmake rewrites all lua native io interfaces with c, and optimizes the time-consuming interfaces with c .

  Therefore, through comparative tests, whether it is using Lua or Luajit, the time-consuming to build the project is basically the same, and there is no significant difference.

  Why switch?

  Because Luajit basically does not support some new architectures, such as: riscv, lonngarch, and the author of luajit has basically not maintained it, some new architecture support and stability repair progress is in a stagnant state.

  In order to be able to better support more platforms and have obtained faster iterative maintenance, we choose to use Lua will bring many benefits.

  Add Cargo package dependency

  In this version, we have added support for the Cargo package dependency manager, but it is currently mainly used in Rust projects.

  Example: https://github.com/xmake-io/xmake/tree/dev/tests/projects/rust/cargo_deps

  add_rules("mode.release", "mode.debug")
  add_requires("cargo::base64 0.13.0")
  add_requires("cargo::flate2 1.0.17", {configs = {features = "zlib"}})
  
  target("test")
      set_kind("binary")
      add_files("src/main.rs")
      add_packages("cargo::base64", "cargo::flate2")
  

  Rust and C++ mixed compilation

  Use cxxbridge to call rust in c++

  Example: cxx_call_rust_library

  阅读中文 Read All

  ---

• xmake v2.5.9 released, Improve C++20 Modules and support Nim, Keil MDK and Unity Build

  2021-10-30

  xmake

  xmake  lua  C/C++  Nim  Keil  MDK  circle  Unity  Build  C++20  Modules  lua5.4

  xmake is a lightweight cross-platform build tool based on Lua. It uses xmake.lua to maintain project builds. Compared with makefile/CMakeLists.txt, the configuration syntax is more Concise and intuitive, it is very friendly to novices, and you can get started quickly in a short time, allowing users to focus more on actual project development.

  In this version, we have added a lot of heavyweight new features, such as: Nim language project build support, Keil MDK, Circle and Wasi toolchain support.

  In addition, we have made major improvements to C++20 Modules, not only supporting the latest gcc-11, clang and msvc compilers, but also automatic analysis of inter-module dependencies to achieve maximum parallel compilation support.

  Finally, there is a more useful feature that is Unity Build support, through which we can greatly improve the compilation speed of C++ code.

  • Github
  • Document

  New feature introduction

  Nimlang project construction

  Recently, we have added build support for the Nimlang project. For related issues, see: #1756

  Create an empty project

  We can use the xmake create command to create an empty project.

  xmake create -l nim -t console test
  xmake create -l nim -t static test
  xmake create -l nim -t shared test
  

  Console Program

  add_rules("mode.debug", "mode.release")
  
  target("test")
      set_kind("binary")
      add_files("src/main.nim")
  

  $ xmake -v
  [33%]: linking.release test
  /usr/local/bin/nim c --opt:speed --nimcache:build/.gens/test/macosx/x86_64/release/nimcache -o:b
  uild/macosx/x86_64/release/test src/main.nim
  [100%]: build ok!
  

  阅读中文 Read All

  ---

• xmake v2.5.8 is released, Support Pascal/Swig program and Lua53 runtime

  2021-10-08

  xmake

  xmake  lua  C/C++  pascal  swig  lua5.3

  xmake is a lightweight cross-platform build tool based on Lua. It uses xmake.lua to maintain project builds. Compared with makefile/CMakeLists.txt, the configuration syntax is more Concise and intuitive, it is very friendly to novices, and you can get started quickly in a short time, allowing users to focus more on actual project development.

  In this version, we mainly added support for the construction of Pascal language projects and Swig modules, and for the Vala language support added in the previous version, we have also made further improvements, adding support for the construction of dynamic and static libraries.

  In addition, xmake now also supports the optional Lua5.3 runtime, which provides better cross-platform support. At present, xmake has been able to run normally on the LoongArch architecture.

  • Github
  • Document

  New feature introduction

  Pascal language support

  Currently, we can use the cross-platform Free Pascal toolchain fpc to compile and build Pascal programs, for example:

  Console Program

  add_rules("mode.debug", "mode.release")
  target("test")
      set_kind("binary")
      add_files("src/*.pas")
  

  Dynamic library program

  add_rules("mode.debug", "mode.release")
  target("foo")
      set_kind("shared")
      add_files("src/foo.pas")
  
  target("test")
      set_kind("binary")
      add_deps("foo")
      add_files("src/main.pas")
  

  We can also add compilation options related to Pascal code through the add_fcflags() interface.

  For more examples, see: Pascal examples

  阅读中文 Read All

  ---

• xmake v2.5.7 released, Use lockfile to freeze package dependencies and Vala/Metal language support

  2021-08-29

  xmake

  xmake  lua  C/C++  lock  package  vala

  xmake is a lightweight cross-platform build tool based on Lua. It uses xmake.lua to maintain project builds. Compared with makefile/CMakeLists.txt, the configuration syntax is more Concise and intuitive, it is very friendly to novices, and you can get started quickly in a short time, allowing users to focus more on actual project development.

  In this version, we have added a lot of new features. Not only did we increase the compilation support for Vala and Metal languages, we also improved the package dependency management, which can support the locking and updating of dependent packages like npm/package.lock, so The user’s project will not be affected by the update and change of the upstream package repository.

  In addition, we also provide some more practical rules. For example, utils.bin2c allows users to easily and quickly embed some binary resource files into the code, and obtain relevant data in the form of header files.

  • Github
  • Document

  New feature introduction

  Added Vala language support

  In this version, we can already initially support the construction of Vala programs, just apply the add_rules("vala") rule.

  At the same time, we need to add some dependency packages, among which the glib package is necessary because Vala itself will also use it.

  add_values("vala.packages") is used to tell valac which packages the project needs, it will introduce the vala api of the relevant package, but the dependency integration of the package still needs to be downloaded and integrated through add_requires("lua").

  E.g:

  add_rules("mode.release", "mode.debug")
  
  add_requires("lua", "glib")
  
  target("test")
      set_kind("binary")
      add_rules("vala")
      add_files("src/*.vala")
      add_packages("lua", "glib")
      add_values("vala.packages", "lua")
  

  More examples: Vala examples

  Added package dependency lock support

  This feature is similar to npm’s package.lock and cargo’s cargo.lock.

  阅读中文 Read All

  ---