TBOOX Open Source Project

• xmake v2.3.5 released, Multi-toolchain flexible switching support

  2020-06-28

  xmake

  xmake  lua  C/C++  toolchains  cross-compilation

  The main work of this version is to continue to improve the support of the tool chain. Although the previous version achieved modular tool chain extension through refactoring, for one compilation, I want to flexibly switch the compilation on the cross tool chain/Host tool chain. Not very good support, so this version focuses on improving the support of this piece.

  In addition, this version also improves the problem of slow downloading of remote dependent packages integrated using add_requires, adding proxy settings and local package retrieval multiplexing support to improve this problem. Of course, the best way is to get a domestic CDN to speed up the download, but this cost is too high, for the time being not toss.

  There are some minor changes and bug fixes, you can see the updated content at the bottom of the article.

  • Github
  • Documents

  Introduction of New Features

  Multi-toolchain flexible switching

  For an example of this, please refer to the luajit project. The compilation process needs to first compile the two targets minilua/buildvm under the host platform, and then generate the jit code corresponding to the target platform through minilua/buildvm to participate in the compilation of the overall luajit library.

  Therefore, the entire compilation process needs to use the host tool chain for a specific target, and then use the cross tool chain to complete the compilation for other targets.

  So how should we configure xmake.lua to achieve this way, one is to set the specified host toolchain for a specific target through the set_toolchains interface, for example:

  target("buildvm")
      set_kind("binary")
      add_files("src/*.c")
      set_toolchains("xcode", {plat = os.host(), arch = os.arch()})
  
  target("luajit")
      set_kind("static")
      add_deps("buildvm")
      add_files("src/*.c")
  

  If you are currently in cross-compilation mode, even if you execute the following command to configure the android compilation platform, its buildvm is still using xcode to compile the macOS target program, only the luajit library is compiled using the ndk toolchain:

  $ xmake f -p android --ndk=/xxxx
  

  However, this is not particularly convenient, especially when cross-platform compilation, pc tool chains of different platforms are different, there are msvc, xcode, clang, etc., you need to judge the platform to specify.

  We can also continue to generalize and let xmake automatically select the currently available Host toolchain for different platforms, instead of explicitly specifying a specific toolchain, and improve it to the following version:

  target("buildvm")
      set_kind("binary")
      add_files("src/*.c")
      set_plat(os.host())
      set_host(os.arch())
  
  target("luajit")
      set_kind("static")
      add_deps("buildvm")
      add_files("src/*.c")
  

  By using set_plat and set_arch interface, directly set a specific target to the host platform, you can automatically select the host tool chain internally.

  For a complete configuration example of this piece, you can refer to: https://github.com/xmake-io/xmake-repo/blob/master/packages/l/luajit/port/xmake.lua

  阅读中文 Read All

  ---

• xmake v2.3.4 released, better toolchain support

  2020-06-05

  xmake

  xmake  lua  C/C++  toolchains  cross-compilation

  In order to make xmake better support cross-compilation, this version I refactored the entire tool chain, making the tool chain switching more convenient and fast, and now users can easily extend their tool chain in xmake.lua.

  With regard to platform support, we have added support for *BSD systems. In addition, this version also adds a ninja theme style to achieve ninja-like compilation progress display, for example:

  

  • Github
  • Documents
  阅读中文 Read All

  ---

• LTUI v1.7 released, A cross-platform terminal ui library based on Lua

  2020-05-06

  ltui

  ltui  curses  lua  xmake  ui

  LTUI is a cross-platform character terminal UI interface library based on lua.

  This framework originates from the requirement of graphical menu configuration in xmake, similar to the menuconf of linux kernel to configure the compilation parameters, so based on curses and lua, a complete set of cross Character terminal ui library of the platform. The style and style are basically completely referenced by kconfig-frontends. Of course, users can also customize different ui styles.

  In addition, LTUI is completely cross-platform, and the terminal terminal on Windows is also fully supported. On Windows, ltui will use pdcurses to draw windows.

  • Github

  Changelog

  However, the previous version did not support the layout adjustment with the size of the terminal window to automatically adjust the layout. If the window becomes larger, the entire view there will still retain the original size. In the current v1.7 version, I have carried out partial refactoring to support the window Resize and adaptive adjustment of all views layout.

  previous version:

  

  new version:

  

  阅读中文 Read All

  ---

• xmake v2.3.3 released, Support for building iOS/MacOS Framework and App

  2020-04-27

  xmake

  xmake  lua  C/C++  framework  bundle  app  codesign

  This version mainly expands the built-in build rules, and adds relevant rules to support the construction of iOS / MacOS related App application projects, Framework and Bundle programs.

  It also supports App signing, and provides related engineering templates to quickly create applications. In addition, this version has also made many improvements to Qt development and construction, adding support for Qt5.14.0 new version SDK and packaging and deployment support for Android It has also improved a lot.

  In addition to processing, xmake also provides a special xmake.cli build rule, through the integration of libxmake engine library to expand the development of xmake engine-based programs, such as: make a customized version of xmake, you can also write some lua based on this Script program.

  • Github
  • Documents
  阅读中文 Read All

  ---

• xmake-gradle v1.0.7 released, Integrate xmake to quickly build Android JNI program

  2020-04-17

  xmake

  xmake  lua  C/C++  android  jni

  xmake-gradle is a gradle plugin that integrates xmake seamlessly.

  At present, there are two ways to do integrated development of android jni in gradle. It is supported by ndkBuild or CMake. Gradle also has built-in integration of these two tools.

  However, maintaining Android.mk is still very tedious, especially for large projects, and the dsl syntax of cmake is not simple and intuitive, and I personally don’t like it very much. Therefore, I have used xmake to implement cross-platform development. It’s simple, fast, friendly to novices, and it’s also very powerful. You can go to the xmake project homepage to see the introduction.

  In the past, if you want to use xmake to compile the android so library, you can only use the command line, such as:

  xmake f -p android --ndk=xxxx
  xmake
  

  Although it is very simple, but if you want to package and integrate with android apk/aar, still need a lot of extra work. In order to improve the efficiency of developers, I recently reorganized this gradle plugin to seamlessly integrate into the entire gradle build System.

  In this way, users can easily use xmake to compile the jni library in android studio, and automatic integration.

  In addition, the relevant gradle configuration is basically the same as cmake and ndkbuild, most of them are compatible, and the switching cost will also be reduced a lot.

  Everyone is welcome to try it, the newly released plugin, if you want to know more, please refer to:

  • 项目源码
  • 官方文档

  Prerequisites

  XMake installed on the system. Available here.

  Apply the plugin

  plugins DSL

  plugins {
    id 'org.tboox.gradle-xmake-plugin' version '1.0.7'
  }
  

  Legacy plugin application

  buildscript {
    repositories {
      maven {
        url "https://plugins.gradle.org/m2/"
      }
    }
    dependencies {
      classpath 'org.tboox:gradle-xmake-plugin:1.0.7'
    }
    repositories {
      mavenCentral()
    }
  }
  
  apply plugin: "org.tboox.gradle-xmake-plugin"
  

  Configuation

  Simplest Example

  We add xmake.lua to projectdir/jni/xmake.lua and enable xmake in build.gradle.

  build.gradle

  android {
      externalNativeBuild {
          xmake {
              path "jni/xmake.lua"
          }
      }
  }
  

  阅读中文 Read All

  ---