update readme

1 files changed, 240 insertions, 217 deletions

diff --git a/README.md b/README.md
index 53826e9ad..cbc727dca 100644
--- a/README.md
+++ b/README.md
@@ -51,176 +51,126 @@ Support this project by [becoming a sponsor](https://xmake.io/#/about/sponsor).
 <a href="https://opencollective.com/xmake#sponsors" target="_blank"><img src="https://opencollective.com/xmake/sponsors.svg?width=890"></a>
 <a href="https://opencollective.com/xmake#backers" target="_blank"><img src="https://opencollective.com/xmake/backers.svg?width=890"></a>
 
-## Technical Support
+## Technical support
 
-You can also consider sponsoring us to get extra technical support services via the [Github sponsor program](https://github.com/sponsors/waruqi),
-This gives you access to the [xmake-io/technical-support](https://github.com/xmake-io/technical-support) repository, where you can get more information on consulting.
+You can also consider sponsoring us to get extra technical support services via the [Github sponsor program](https://github.com/sponsors/waruqi). If you do, you can get access to the [xmake-io/technical-support](https://github.com/xmake-io/technical-support) repository, which has the following bennefits:
 
-- [x] Handling Issues with higher priority
-- [x] One-to-one technical consulting service
-- [x] Review your xmake.lua and provide suggestions for improvement
+- [X] Handling Issues with higher priority
+- [X] One-to-one technical consulting service
+- [X] Review your xmake.lua and provide suggestions for improvement
 
 ## Introduction ([中文](/README_zh.md))
 
-Xmake is a lightweight, cross-platform build utility based on Lua.
+What is Xmake?
 
-It is very lightweight and has no dependencies due to the integration of the Lua runtime.
+1. Xmake is a cross-platform build utility based on the Lua scripting language.
+2. Xmake is very lightweight and has no dependencies outside of the standard library.
+3. Uses the `xmake.lua` file to maintain project builds with a simple and readable syntax.
 
-It uses xmake.lua to maintain project builds with a very simple and readable syntax.
-
-We can use it to build projects directly like Make/Ninja or generate project files like CMake/Meson. It also has a built-in package management system to help users integrate C/C++ dependencies.
+Xmake can be used to directly build source code (like with Make or Ninja), or it can generate project source files like CMake or Meson. It also has a *built-in* package management system to help users integrate C/C++ dependencies.
 
 ```
 Xmake = Build backend + Project Generator + Package Manager + [Remote|Distributed] Build + Cache
 ```
 
-Although not very precise, we can still understand Xmake in the following way:
+Although less precise, one can still understand Xmake in the following way:
 
 ```
 Xmake ≈ Make/Ninja + CMake/Meson + Vcpkg/Conan + distcc + ccache/sccache
 ```
 
-If you want to know more, please refer to: [Documents](https://xmake.io/#/getting_started), [Github](https://github.com/xmake-io/xmake) and [Gitee](https://gitee.com/tboox/xmake). You are also welcome to join our [community](https://xmake.io/#/about/contact).
+If you want to know more, please refer to: the [Documentation](https://xmake.io/#/getting_started), [GitHub](https://github.com/xmake-io/xmake) or [Gitee](https://gitee.com/tboox/xmake). You are also welcome to join our [community](https://xmake.io/#/about/contact).
+
+The official Xmake repository can be found at [xmake-io/xmake-repo](https://github.com/xmake-io/xmake-repo).
 
 ![](https://github.com/xmake-io/xmake-docs/raw/master/assets/img/index/xmake-basic-render.gif)
 
 ## Installation
 
-#### via curl
+### With cURL
 
 ```bash
 curl -fsSL https://xmake.io/shget.text | bash
 ```
 
-#### via wget
+### With Wget
 
 ```bash
 wget https://xmake.io/shget.text -O - | bash
 ```
 
-#### via powershell
+### With PowerShell
 
-```powershell
+```sh
 Invoke-Expression (Invoke-Webrequest 'https://xmake.io/psget.text' -UseBasicParsing).Content
 ```
 
-#### Other installation methods
+### Other installation methods
 
-If you don't want to use the script to install xmake, see [Installation Guide](https://xmake.io/#/guide/installation) for other installation methods.
+If you don't want to use the above scripts to install Xmake, visit the [Installation Guide](https://xmake.io/#/guide/installation) for other installation methods (building from source, package managers, etc.).
 
-## Simple description
+## Simple Project Description
 
 ```lua
-target("hello")
+target("console")
     set_kind("binary")
-    add_files("src/*.cpp")
+    add_files("src/*.c")
 ```
 
+Creates a new target `console` of kind `binary`, and adds all the files ending in `.c` in the `src` directory.
+
 ## Package dependences
 
 ```lua
 add_requires("tbox 1.6.*", "zlib", "libpng ~1.6")
 ```
 
-An official xmake package repository exists at: [xmake-repo](https://github.com/xmake-io/xmake-repo)
+Adds a requirement of tbox v1.6, zlib (any version), and libpng v1.6.
+
+The official xmake package repository exists at: [xmake-repo](https://github.com/xmake-io/xmake-repo)
 
+<p align="center">
 <img src="https://github.com/xmake-io/xmake-docs/raw/master/assets/img/index/package.gif" width="650px" />
+</p>
 
-## Create project
+## Commandline interface reference
 
-```bash
-$ xmake create hello
-$ cd hello
-```
+The below assumes you are currently in the project's root directory.
 
-## Build project
+### Build a project
 
 ```bash
 $ xmake
 ```
 
-## Run target
+### Run target
 
 ```bash
 $ xmake run console
 ```
 
-## Debug target
+### Debug target
 
 ```bash
 $ xmake run -d console
 ```
 
-## Configure platform
+### Configure platform
 
 ```bash
 $ xmake f -p [windows|linux|macosx|android|iphoneos ..] -a [x86|arm64 ..] -m [debug|release]
 $ xmake
 ```
 
-## Menu configuration
+### Menu configuration
 
 ```bash
 $ xmake f --menu
 ```
 
-<img src="https://xmake.io/assets/img/index/menuconf.png" width="650px" />
-
-## Build as fast as ninja
-
-The test project: [xmake-core](https://github.com/xmake-io/xmake/tree/master/core)
-
-### Multi-task parallel compilation
-
-| buildsystem     | Termux (8core/-j12) | buildsystem      | MacOS (8core/-j12) |
-|-----            | ----                | ---              | ---                |
-|xmake            | 24.890s             | xmake            | 12.264s            |
-|ninja            | 25.682s             | ninja            | 11.327s            |
-|cmake(gen+make)  | 5.416s+28.473s      | cmake(gen+make)  | 1.203s+14.030s     |
-|cmake(gen+ninja) | 4.458s+24.842s      | cmake(gen+ninja) | 0.988s+11.644s     |
-
-### Single task compilation
-
-| buildsystem     | Termux (-j1)     | buildsystem      | MacOS (-j1)    |
-|-----            | ----             | ---              | ---            |
-|xmake            | 1m57.707s        | xmake            | 39.937s        |
-|ninja            | 1m52.845s        | ninja            | 38.995s        |
-|cmake(gen+make)  | 5.416s+2m10.539s | cmake(gen+make)  | 1.203s+41.737s |
-|cmake(gen+ninja) | 4.458s+1m54.868s | cmake(gen+ninja) | 0.988s+38.022s |
-
-## Package management
-
-### Processing architecture
-
-<img src="https://xmake.io/assets/img/index/package_arch.png" width="650px" />
-
-### Supported package repositories
-
-* Official package repository [xmake-repo](https://github.com/xmake-io/xmake-repo) (tbox >1.6.1)
-* Official package manager [Xrepo](https://github.com/xmake-io/xrepo)
-* [User-built repositories](https://xmake.io/#/package/remote_package?id=using-self-built-private-package-repository)
-* Conan (conan::openssl/1.1.1g)
-* Conda (conda::libpng 1.3.67)
-* Vcpkg (vcpkg::ffmpeg)
-* Homebrew/Linuxbrew (brew::pcre2/libpcre2-8)
-* Pacman on archlinux/msys2 (pacman::libcurl)
-* Apt on ubuntu/debian (apt::zlib1g-dev)
-* Clib (clib::clibs/[email protected])
-* Dub (dub::log 0.4.3)
-* Portage on Gentoo/Linux (portage::libhandy)
-* Nimble for nimlang (nimble::zip >1.3)
-* Cargo for rust (cargo::base64 0.13.0)
-
-### Package management features
-
-* The official repository provides nearly 800+ packages with one-click compilation on all platforms
-* Full platform package support, support for cross-compiled dependent packages
-* Support package virtual environment using `xrepo env shell`
-* Precompiled package acceleration for Windows
-* Support self-built package repositories and private repository deployment
-* Third-party package repository support for repositories such as: vcpkg, conan, conda, etc.
-* Supports automatic pulling of remote toolchains
-* Supports dependency version locking
+<p align="center">
+<img src="https://xmake.io/assets/img/index/menuconf.png" width="650px"/>
+</p>
 
 ## Supported platforms
 
@@ -236,61 +186,61 @@ The test project: [xmake-core](https://github.com/xmake-io/xmake/tree/master/cor
 * MinGW (i386, x86_64, arm, arm64)
 * Cygwin (i386, x86_64)
 * Wasm (wasm32)
-* Haiku (i386, x86_64)
 * Cross (cross-toolchains ..)
 
 ## Supported toolchains
 
-```bash
-$ 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
-zig           Zig Programming Language 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
-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
-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
-```
+### IDE-Tied
+
+* Xcode
+* MSVC (Microsoft Visual C compiler)
+* Android NDK
+
+### Languages
+
+* Zig
+* Go(lang)
+* Swift
+* Nim
+* Rust
+* GCC (GNU Compiler Collection)
+* Clang
+* TinyCC
+* icc (Intel C Compiler)
+* icpc (Intel C++ Compiler)
+* icx (Intel LLVM C/C++ Compiler)
+* Clang-CL (Clang Compatability with MSVC)
+* DPC++ (Intel LLVM C++ Compiler using SYCL)
+* MinGW (GNU for Windows)
+* C51 (Keil C Compiler for the 8051)
+* GNU-RM (GNU Arm Embedded Toolchain)
+* ArmCC (Keil C Compiler for Keil MKD Version 5)
+* Circle (New C++20 compiler)
+* WASI (C/C++ WebAssembly Toolchain)
+* ArmClang (Version 6 of the Keil MDK)
+* SDCC (Small Device C Compiler)
+* GDC (GNU D Compiler)
+* LDC (LLVM D Compiler)
+* DMD (Dlang)
+* FPC (Free Pascal Programming Language Compiler)
+* GFortran (GNU Fortran Compiler)
+* Ifort (Intel Fortran Compiler)
+* CUDA (nvcc, nvc, nvc++, nvfortran)
+* Emscripten
+* LLVM
+* Icarus Verilog
+* Verilator (SystemVerilog simulator and lint system)
 
-## Supported Languages
+### Assemblers
 
-* C
-* C++
+* FASM
+* NASM
+* YASM
+* MASM32 (Microsoft Macro Assembler 32-bit SDK)
+
+## Supported languages
+
+* C and C++
 * Objective-C and Objective-C++
 * Swift
 * Assembly
@@ -304,69 +254,145 @@ verilator     Verilator open-source SystemVerilog simulator and lint system
 * Pascal
 * Nim
 * Verilog
+* FASM
+* NASM
+* YASM
+* MASM32
 
-## Supported Features
+## Features
 
-* The configuration grammar is simple and easy to use
-* Quick, dependency-free installation
-* One-click compilation for all platforms
-* Supports cross compilation with intelligent analysis of cross toolchain information
-* Extremely fast parallel compilation support
-* C++20 module support
-* Supports cross-platform C/C++ dependencies with built-in package manager
+Xmake exhibits:
+
+* Simple yet flexible configuration grammar.
+* Quick, dependency-free installation.
+* Easy compilation for most all supported platforms.
+* Supports cross-compilation with intelligent analysis of cross toolchain information.
+* Extremely fast parallel compilation support.
+* Supports C++ modules (new in C++20).
+* Supports cross-platform C/C++ dependencies with built-in package manager.
 * Multi-language compilation support including mixed-language projects.
-* Rich plug-in support with various project generators (ex. vs/makefile/cmakelists/compile_commands)
+* Rich plug-in support with various project generators (ex. Visual Studio/Makefiles/CMake/`compile_commands.json`)
 * REPL interactive execution support
 * Incremental compilation support with automatic analysis of header files
-* Quick toolchain management
+* Built-in toolchain management
 * A large number of expansion modules
 * Remote compilation support
 * Distributed compilation support
 * Local and remote build cache support
 
-## Supported Projects
+## Supported Project Types
 
-* Static library
-* Shared library
-* Console
-* Cuda program
-* Qt application
-* WDK driver (umdf/kmdf/wdm)
-* WinSDK application
-* MFC application
-* iOS/MacOS application (support .metal)
-* Framework and bundle program (iOS/MacOS)
-* SWIG/Pybind11 modules (lua, python, ...)
-* Luarocks modules
-* Protobuf program
-* Lex/yacc Program
-* C++20 modules
-* Linux kernel driver modules
-* Keil MDK/C51 embed program
-* Verilog simulator program
+Xmake supports the below types of projects:
 
-## Distributed Compilation
+* Static libraries
+* Shared libraries
+* Console/CLI applications
+* CUDA programs
+* Qt applications
+* WDK drivers (umdf/kmdf/wdm)
+* WinSDK applications
+* MFC applications
+* Darwin applications (with metal support)
+* Frameworks and bundles (in Darwin)
+* SWIG modules (Lua, Python, ...)
+* LuaRocks modules
+* Protobuf programs
+* Lex/Yacc programs
+* Linux kernel modules
+
+## Package management
+
+### Download and build
+
+Xmake can automatically fetch and install dependencies!
+
+<p align="center">
+<img src="https://xmake.io/assets/img/index/package_manage.png" width="650px" />
+</p>
+
+### Supported package repositories
+
+* Official package repository [xmake-repo](https://github.com/xmake-io/xmake-repo) (tbox >1.6.1)
+* Official package manager [Xrepo](https://github.com/xmake-io/xrepo)
+* [User-built repositories](https://xmake.io/#/package/remote_package?id=using-self-built-private-package-repository)
+* Conan (conan::openssl/1.1.1g)
+* Conda (conda::libpng 1.3.67)
+* Vcpkg (vcpkg:ffmpeg)
+* Homebrew/Linuxbrew (brew::pcre2/libpcre2-8)
+* Pacman on archlinux/msys2 (pacman::libcurl)
+* Apt on ubuntu/debian (apt::zlib1g-dev)
+* Clib (clib::clibs/[email protected])
+* Dub (dub::log 0.4.3)
+* Portage on Gentoo/Linux (portage::libhandy)
+* Nimble for nimlang (nimble::zip >1.3)
+* Cargo for rust (cargo::base64 0.13.0)
+
+### Package management features
 
-- [x] Cross-platform support
-- [x] Support for msvc, clang, gcc and cross-compilation toolchain
-- [x] Support for building android, ios, linux, win, macOS programs
-- [x] No dependencies other than the compilation toolchain
-- [x] Support for build server load balancing scheduling
-- [x] Support for real time compressed transfer of large files (lz4)
-- [x] Almost zero configuration cost, no shared filesystem required, more convenience and security
+* The official repository provides nearly 500+ packages with simple compilation on all supported platforms
+* Full platform package support, support for cross-compiled dependent packages
+* Support package virtual environment using `xrepo env shell`
+* Precompiled package acceleration for Windows (NT)
+* Support self-built package repositories and private repository deployment
+* Third-party package repository support for repositories such as: vcpkg, conan, conda, etc.
+* Supports automatic pulling of remote toolchains
+* Supports dependency version locking
+
+## Processing architecture
 
-About distributed compilation and build cache, you can see:
+Below is a diagram showing roughly the architecture of Xmake, and thus how it functions.
 
-- [Distributed Compilation](https://xmake.io/#/features/distcc_build)
-- [Build Cache](https://xmake.io/#/features/build_cache)
+<p align="center">
+<img src="https://xmake.io/assets/img/index/package_arch.png" width="650px" />
+</p>
+
+## Distributed Compilation
+
+- [X] Cross-platform support.
+- [X] Support for MSVC, Clang, GCC and other cross-compilation toolchains.
+- [X] Support for building for Android, Linux, Windows NT, and Darwin hosts.
+- [X] No dependencies other than the compilation toolchain.
+- [X] Support for build server load balancing scheduling.
+- [X] Support for real time compressed transfer of large files (lz4).
+- [X] Almost zero configuration cost, no shared filesystem required, for convenience and security.
+
+For more details see: [#274](https://github.com/xmake-io/xmake/issues/274)
 
 ## Remote Compilation
 
-For more details see: [Remote Compilation](https://xmake.io/#/features/remote_build)
+For more details see: [#622](https://github.com/xmake-io/xmake/issues/622)
+
+## Local/Remote Build Cache
+
+For more details see: [#622](https://github.com/xmake-io/xmake/issues/2371)
+
+## Benchmark
+
+Xmake's speed on is par with Ninja! The test project: [xmake-core](https://github.com/xmake-io/xmake/tree/master/core)
+
+### Multi-task parallel compilation
+
+
+| buildsystem      | Termux (8core/-j12) | buildsystem      | MacOS (8core/-j12) |
+| ------------------ | --------------------- | ------------------ | -------------------- |
+| xmake            | 24.890s             | xmake            | 12.264s            |
+| ninja            | 25.682s             | ninja            | 11.327s            |
+| cmake(gen+make)  | 5.416s+28.473s      | cmake(gen+make)  | 1.203s+14.030s     |
+| cmake(gen+ninja) | 4.458s+24.842s      | cmake(gen+ninja) | 0.988s+11.644s     |
+
+## Single task compilation
+
+
+| buildsystem      | Termux (-j1)     | buildsystem      | MacOS (-j1)    |
+| ------------------ | ------------------ | ------------------ | ---------------- |
+| xmake            | 1m57.707s        | xmake            | 39.937s        |
+| ninja            | 1m52.845s        | ninja            | 38.995s        |
+| cmake(gen+make)  | 5.416s+2m10.539s | cmake(gen+make)  | 1.203s+41.737s |
+| cmake(gen+ninja) | 4.458s+1m54.868s | cmake(gen+ninja) | 0.988s+38.022s |
 
 ## More Examples
 
-#### Debug and release profiles
+### Debug and release profiles
 
 ```lua
 add_rules("mode.debug", "mode.release")
@@ -379,7 +405,7 @@ target("console")
     end
 ```
 
-#### Custom scripts
+### Custom scripts
 
 ```lua
 target("test")
@@ -391,7 +417,7 @@ target("test")
     end)
 ```
 
-#### Automatic integration of dependent packages
+### Automatic integration of dependent packages
 
 Download and use packages in [xmake-repo](https://github.com/xmake-io/xmake-repo) or third-party repositories:
 
@@ -406,7 +432,7 @@ target("test")
 
 In addition, we can also use the [xrepo](https://github.com/xmake-io/xrepo) command to quickly install dependencies.
 
-#### Qt QuickApp Program
+### Qt QuickApp Program
 
 ```lua
 target("test")
@@ -415,7 +441,7 @@ target("test")
     add_files("src/qml.qrc")
 ```
 
-#### Cuda Program
+### Cuda Program
 
 ```lua
 target("test")
@@ -425,7 +451,7 @@ target("test")
     add_cugencodes("compute_35")
 ```
 
-#### WDK/UMDF Driver Program
+### WDK/UMDF Driver Program
 
 ```lua
 target("echo")
@@ -439,9 +465,9 @@ target("app")
     add_files("exe/*.cpp")
 ```
 
-More wdk driver program examples exist (umdf/kmdf/wdm), please see [WDK Program Examples](https://xmake.io/#/guide/project_examples?id=wdk-driver-program)
+For more WDK driver examples (UMDF/KMDF/WDM), please visit [WDK Program Examples](https://xmake.io/#/guide/project_examples?id=wdk-driver-program)
 
-#### iOS/MacOS Application
+### Darwin Applications
 
 ```lua
 target("test")
@@ -450,7 +476,7 @@ target("test")
     add_files("src/Info.plist")
 ```
 
-#### Framework and Bundle Program (iOS/MacOS)
+### Framework and Bundle Program (Darwin)
 
 ```lua
 target("test")
@@ -459,7 +485,7 @@ target("test")
     add_files("src/Info.plist")
 ```
 
-#### OpenMP Program
+### OpenMP Program
 
 ```lua
 add_requires("libomp", {optional = true})
@@ -470,7 +496,7 @@ target("loop")
     add_packages("libomp")
 ```
 
-#### Zig Program
+### Zig Program
 
 ```lua
 target("test")
@@ -480,9 +506,9 @@ target("test")
 
 ### Automatically fetch remote toolchain
 
-#### fetch a special version of llvm
+#### fetch a special version of LLVM
 
-We use Clang in `llvm-10` to compile the project.
+Require the Clang version packaged with LLM-10 to compile a project.
 
 ```lua
 add_requires("llvm 10.x", {alias = "llvm-10"})
@@ -490,11 +516,11 @@ target("test")
     set_kind("binary")
     add_files("src/*.c")
     set_toolchains("llvm@llvm-10")
-````
+```
 
-#### Fetch cross-compilation toolchain
+#### Fetch a cross-compilation toolchain
 
-We can also pull a specified cross-compilation toolchain to compile the project.
+We can also pull a specified cross-compilation toolchain in to compile the project.
 
 ```lua
 add_requires("muslcc")
@@ -506,7 +532,7 @@ target("test")
 
 #### Fetch toolchain and packages
 
-We can also use the specified `muslcc` cross-compilation toolchain to compile and integrate all dependent packages
+We can also use the specified `muslcc` cross-compilation toolchain to compile and integrate all dependent packages.
 
 ```lua
 add_requires("muslcc")
@@ -548,7 +574,7 @@ $ xmake l
   }
 ```
 
-More builtin plugins exist, please see: [Builtin plugins](https://xmake.io/#/plugin/builtin_plugins)
+To see a list of bultin plugs, please visit [Builtin plugins](https://xmake.io/#/plugin/builtin_plugins).
 
 Please download and install other plugins from the plugins repository [xmake-plugins](https://github.com/xmake-io/xmake-plugins).
 
@@ -567,12 +593,10 @@ Please download and install other plugins from the plugins repository [xmake-plu
 <img src="https://raw.githubusercontent.com/xmake-io/xmake-idea/master/res/problem.gif" width="650px" />
 
 * [xmake.vim](https://github.com/luzhlon/xmake.vim) (third-party, thanks [@luzhlon](https://github.com/luzhlon))
-
 * [xmake-visualstudio](https://github.com/HelloWorld886/xmake-visualstudio) (third-party, thanks [@HelloWorld886](https://github.com/HelloWorld886))
-
 * [xmake-qtcreator](https://github.com/Arthapz/xmake-project-manager) (third-party, thanks [@Arthapz](https://github.com/Arthapz))
 
-### XMake Gradle Plugin (JNI)
+### Xmake Gradle Plugin (JNI)
 
 We can use the [xmake-gradle](https://github.com/xmake-io/xmake-gradle) plugin to compile JNI libraries via gradle.
 
@@ -597,14 +621,14 @@ $ ./gradlew app:assembleDebug
 > Task :nativelib:xmakeConfigureForArm64
 > Task :nativelib:xmakeBuildForArm64
 >> xmake build
-[ 50%]: ccache compiling.debug nativelib.cc
+[ 50%]: cache compiling.debug nativelib.cc
 [ 75%]: linking.debug libnativelib.so
 [100%]: build ok!
 >> install artifacts to /Users/ruki/projects/personal/xmake-gradle/nativelib/libs/arm64-v8a
 > Task :nativelib:xmakeConfigureForArmv7
 > Task :nativelib:xmakeBuildForArmv7
 >> xmake build
-[ 50%]: ccache compiling.debug nativelib.cc
+[ 50%]: cache compiling.debug nativelib.cc
 [ 75%]: linking.debug libnativelib.so
 [100%]: build ok!
 >> install artifacts to /Users/ruki/projects/personal/xmake-gradle/nativelib/libs/armeabi-v7a
@@ -617,9 +641,9 @@ $ ./gradlew app:assembleDebug
 
 ### GitHub Action
 
-We can use [github-action-setup-xmake](https://github.com/xmake-io/github-action-setup-xmake) to setup Xmake in Github Actions.
+The [github-action-setup-xmake](https://github.com/xmake-io/github-action-setup-xmake) plugin for GitHub Actions can allow you to use Xmake with minimal efforts if you use GitHub Actions for your CI pipeline.
 
-```
+```yaml
 uses: xmake-io/github-action-setup-xmake@v1
 with:
   xmake-version: latest
@@ -627,32 +651,31 @@ with:
 
 ## Who is using Xmake?
 
-The user list is available [here](https://xmake.io/#/about/who_is_using_xmake)
+The list of people and projects who are using Xmake is available [here](https://xmake.io/#/about/who_is_using_xmake).
 
-If you are using xmake, you are welcome to submit your information to the above list through a PR, so that others can know how many users are using it.
+If you are using Xmake, you are welcome to submit your information to the above list through a PR, so that other users and the developers can gauge interest.  Ihis also let users to use xmake more confidently and give us motivation to continue to maintain it.
 
-This also let users use xmake more confidently and give us motivation to continue to maintain it.
-This will help the xmake project and it's community to grow stronger.
+This will help the Xmake project and it's community grow stronger and expand!
 
 ## Contacts
 
 * Email：[[email protected]](mailto:[email protected])
 * Homepage：[xmake.io](https://xmake.io)
 * Community
-  - [Chat on reddit](https://www.reddit.com/r/xmake/)
-  - [Chat on telegram](https://t.me/tbooxorg)
-  - [Chat on discord](https://discord.gg/xmake)
+  - [Chat on Reddit](https://www.reddit.com/r/xmake/)
+  - [Chat on Telegram](https://t.me/tbooxorg)
+  - [Chat on Discord](https://discord.gg/xmake)
   - Chat on QQ Group: 343118190, 662147501
-* Source Code：[Github](https://github.com/xmake-io/xmake), [Gitee](https://gitee.com/tboox/xmake)
-* Wechat Public: tboox-os
+* Source Code：[GitHub](https://github.com/xmake-io/xmake), [Gitee](https://gitee.com/tboox/xmake)
+* WeChat Public: tboox-os
 
 ## Thanks
 
 This project exists thanks to all the people who have [contributed](CONTRIBUTING.md):
 <a href="https://github.com/xmake-io/xmake/graphs/contributors"><img src="https://opencollective.com/xmake/contributors.svg?width=890&button=false" /></a>
 
-* [TitanSnow](https://github.com/TitanSnow): provide the xmake [logo](https://github.com/TitanSnow/ts-xmake-logo) and install scripts
-* [uael](https://github.com/uael): provide the semantic versioning library [sv](https://github.com/uael/sv)
-* [OpportunityLiu](https://github.com/OpportunityLiu): improve cuda, tests and ci
+* [TitanSnow](https://github.com/TitanSnow): Provide the xmake [logo](https://github.com/TitanSnow/ts-xmake-logo) and install scripts
+* [uael](https://github.com/uael): Provide the semantic versioning library [sv](https://github.com/uael/sv)
+* [OpportunityLiu](https://github.com/OpportunityLiu): Improve cuda, tests and ci
 * [xq144](https://github.com/xq114): Improve `xrepo env shell`, and contribute a lot of packages to the [xmake-repo](https://github.com/xmake-io/xmake-repo) repository.
 * `enderger`: Helped smooth out the edges on the English translation of the README