From a46e3e9357709b7b4deb1e68ab5b4c8aba0e3d08 Mon Sep 17 00:00:00 2001
From: Ivan Max <mixython@gmail.com>
Date: Wed, 30 Aug 2023 20:40:08 +0000
Subject: [PATCH] build-package.sh: adding compilation based on glibc (#16901)

[skip ci]
---
 .github/workflows/packages.yml                | 14 ++--
 build-package.sh                              | 50 ++++++++++-
 clean.sh                                      |  3 +-
 repo.json                                     |  1 +
 scripts/Dockerfile                            |  4 +-
 scripts/Vagrantfile                           |  1 +
 scripts/bin/revbump                           |  5 +-
 scripts/bin/update-checksum                   |  2 +-
 scripts/bin/update-packages                   |  6 +-
 scripts/build/setup/termux_setup_cmake.sh     | 15 ++--
 .../build/termux_create_debian_subpackages.sh | 17 +++-
 .../build/termux_create_pacman_subpackages.sh | 17 +++-
 scripts/build/termux_download_deb_pac.sh      | 67 +++++++++++----
 scripts/build/termux_extract_dep_info.sh      |  2 +-
 scripts/build/termux_get_repo_files.sh        | 52 +++++++-----
 .../termux_step_create_debian_package.sh      |  9 ++
 .../termux_step_create_pacman_package.sh      | 10 +++
 .../termux_step_extract_into_massagedir.sh    |  4 +-
 scripts/build/termux_step_get_dependencies.sh | 38 ++++++---
 scripts/build/termux_step_handle_buildarch.sh |  4 +
 scripts/build/termux_step_install_license.sh  | 10 ++-
 scripts/build/termux_step_massage.sh          | 84 +++++++++++++------
 scripts/build/termux_step_patch_package.sh    |  1 +
 .../termux_step_replace_guess_scripts.sh      |  7 ++
 .../build/termux_step_setup_build_folders.sh  | 11 ++-
 .../termux_step_setup_cgct_environment.sh     | 61 ++++++++++++++
 scripts/build/termux_step_setup_toolchain.sh  | 35 +++++---
 scripts/build/termux_step_setup_variables.sh  | 67 ++++++++++++---
 scripts/build/termux_step_start_build.sh      | 50 +++++------
 .../toolchain/termux_setup_toolchain_gnu.sh   | 43 ++++++++++
 scripts/buildorder.py                         | 22 ++++-
 scripts/lint-packages.sh                      |  2 +-
 scripts/properties.sh                         | 18 +++-
 scripts/setup-cgct.sh                         |  1 -
 scripts/setup-offline-bundle.sh               |  2 +-
 scripts/setup-termux-glibc.sh                 | 19 +++++
 .../utils/termux_pkg_upgrade_version.sh       |  2 +-
 scripts/utils/package/package.sh              | 65 ++++++++++++++
 38 files changed, 657 insertions(+), 164 deletions(-)
 create mode 100644 scripts/build/termux_step_setup_cgct_environment.sh
 create mode 100644 scripts/build/toolchain/termux_setup_toolchain_gnu.sh
 create mode 100755 scripts/setup-termux-glibc.sh

diff --git a/.github/workflows/packages.yml b/.github/workflows/packages.yml
index ffa505579e..658d95e544 100644
--- a/.github/workflows/packages.yml
+++ b/.github/workflows/packages.yml
@@ -82,7 +82,7 @@ jobs:
             cd ..
           fi
 
-          for repo_path in $(jq --raw-output 'keys | .[]' repo.json); do
+          for repo_path in $(jq --raw-output 'del(.pkg_format) | keys | .[]' repo.json); do
             repo=$(jq --raw-output '.["'${repo_path}'"].name' repo.json)
             # Parse changed files and identify new packages and deleted packages.
             # Create lists of those packages that will be passed to upload job for
@@ -117,7 +117,7 @@ jobs:
           done
         else
           for pkg in ${{ github.event.inputs.packages }}; do
-            repo_paths=$(jq --raw-output 'keys | .[]' repo.json)
+            repo_paths=$(jq --raw-output 'del(.pkg_format) | keys | .[]' repo.json)
             found=false
             for repo_path in $repo_paths; do
               repo=$(jq --raw-output '.["'${repo_path}'"].name' repo.json)
@@ -136,7 +136,7 @@ jobs:
           done
         fi
 
-        for repo in $(jq --raw-output '.[].name' repo.json); do
+        for repo in $(jq --raw-output 'del(.pkg_format) | .[].name' repo.json); do
           # Fix so that lists do not contain duplicates
           if [ -f ./built_${repo}_packages.txt ]; then
             sort ./built_${repo}_packages.txt | uniq > ./built_${repo}_packages.txt.tmp
@@ -166,7 +166,7 @@ jobs:
     - name: Lint packages
       run: |
         declare -a package_recipes
-        for repo_path in $(jq --raw-output 'keys | .[]' repo.json); do
+        for repo_path in $(jq --raw-output 'del(.pkg_format) | keys | .[]' repo.json); do
           repo=$(jq --raw-output '.["'${repo_path}'"].name' repo.json)
           if [ -f ./built_${repo}_packages.txt ]; then
             package_recipes="$package_recipes $(cat ./built_${repo}_packages.txt | repo_path=${repo_path} awk '{print ENVIRON["repo_path"]"/"$1"/build.sh"}')"
@@ -180,7 +180,7 @@ jobs:
     - name: Build packages
       run: |
         declare -a packages
-        for repo_path in $(jq --raw-output 'keys | .[]' repo.json); do
+        for repo_path in $(jq --raw-output 'del(.pkg_format) | keys | .[]' repo.json); do
           repo=$(jq --raw-output '.["'${repo_path}'"].name' repo.json)
 
           if [ -f ./built_${repo}_packages.txt ]; then
@@ -197,7 +197,7 @@ jobs:
       run: |
         test -d termux-packages/output && mv termux-packages/output/* ./output/
 
-        for repo in $(jq --raw-output '.[].name' repo.json); do
+        for repo in $(jq --raw-output 'del(.pkg_format) | .[].name' repo.json); do
           # Put package lists into directory with *.deb files so they will be transferred to
           # upload job.
           test -f ./built_${repo}_packages.txt && mv ./built_${repo}_packages.txt ./debs/
@@ -255,7 +255,7 @@ jobs:
           tar xf "$archive"
         done
 
-        for repo in $(jq --raw-output 'keys | .[]' repo.json); do
+        for repo in $(jq --raw-output 'del(.pkg_format) | keys | .[]' repo.json); do
           export REPOSITORY_NAME=$(jq --raw-output '.["'$repo'"].name' repo.json)
           export REPOSITORY_DISTRIBUTION=$(jq --raw-output '.["'$repo'"].distribution' repo.json)
 
diff --git a/build-package.sh b/build-package.sh
index c2fe31edc3..8d74104649 100755
--- a/build-package.sh
+++ b/build-package.sh
@@ -57,7 +57,7 @@ if [ ! -e "$TERMUX_BUILD_LOCK_FILE" ]; then
 	touch "$TERMUX_BUILD_LOCK_FILE"
 fi
 
-export TERMUX_PACKAGES_DIRECTORIES=$(jq --raw-output 'keys | .[]' ${TERMUX_SCRIPTDIR}/repo.json)
+export TERMUX_PACKAGES_DIRECTORIES=$(jq --raw-output 'del(.pkg_format) | keys | .[]' ${TERMUX_SCRIPTDIR}/repo.json)
 
 # Special variable for internal use. It forces script to ignore
 # lock file.
@@ -71,6 +71,10 @@ source "$TERMUX_SCRIPTDIR/scripts/build/termux_error_exit.sh"
 # shellcheck source=scripts/build/termux_download.sh
 source "$TERMUX_SCRIPTDIR/scripts/build/termux_download.sh"
 
+# Installing packages if necessary for the full operation of CGCT.
+# shellcheck source=scripts/build/termux_step_setup_cgct_environment.sh
+source "$TERMUX_SCRIPTDIR/scripts/build/termux_step_setup_cgct_environment.sh"
+
 # Utility function for setting up Cargo C-ABI helpers.
 # shellcheck source=scripts/build/setup/termux_setup_cargo_c.sh
 source "$TERMUX_SCRIPTDIR/scripts/build/setup/termux_setup_cargo_c.sh"
@@ -231,6 +235,10 @@ source "$TERMUX_SCRIPTDIR/scripts/build/toolchain/termux_setup_toolchain_25c.sh"
 # shellcheck source=scripts/build/toolchain/termux_setup_toolchain_23c.sh
 source "$TERMUX_SCRIPTDIR/scripts/build/toolchain/termux_setup_toolchain_23c.sh"
 
+# Setup a standalone Glibc GNU toolchain. Called from termux_step_setup_toolchain.
+# shellcheck source=scripts/build/toolchain/termux_setup_toolchain_gnu.sh
+source "$TERMUX_SCRIPTDIR/scripts/build/toolchain/termux_setup_toolchain_gnu.sh"
+
 # Runs termux_step_setup_toolchain_${TERMUX_NDK_VERSION}. Not to be overridden by packages.
 # shellcheck source=scripts/build/termux_step_setup_toolchain.sh
 source "$TERMUX_SCRIPTDIR/scripts/build/termux_step_setup_toolchain.sh"
@@ -392,10 +400,12 @@ _show_usage() {
 	echo "  -F Force build even if package and its dependencies have already been built."
 	[ "$TERMUX_ON_DEVICE_BUILD" = "false" ] && echo "  -i Download and extract dependencies instead of building them."
 	echo "  -I Download and extract dependencies instead of building them, keep existing $TERMUX_BASE_DIR files."
+	echo "  -L The package and its dependencies will be based on the same library."
 	echo "  -q Quiet build."
 	echo "  -s Skip dependency check."
 	echo "  -o Specify directory where to put built packages. Default: output/."
 	echo "  --format Specify package output format (debian, pacman)."
+	echo "  --library Specify library of package (bionic, glibc)."
 	exit 1
 }
 
@@ -417,6 +427,17 @@ while (($# >= 1)); do
 				termux_error_exit "./build-package.sh: option '--format' requires an argument"
 			fi
 			;;
+		--library)
+			if [ $# -ge 2 ]; then
+				shift
+				if [ -z "$1" ]; then
+					termux_error_exit "./build-package.sh: argument to '--library' should not be empty"
+				fi
+				export TERMUX_PACKAGE_LIBRARY="$1"
+			else
+				termux_error_exit "./build-package.sh: option '--library' requires an argument"
+			fi
+			;;
 		-a)
 			if [ $# -ge 2 ]; then
 				shift 1
@@ -453,6 +474,7 @@ while (($# >= 1)); do
 				export TERMUX_NO_CLEAN=true
 			fi
 			;;
+		-L) export TERMUX_GLOBAL_LIBRARY=true;;
 		-q) export TERMUX_QUIET_BUILD=true;;
 		-s) export TERMUX_SKIP_DEPCHECK=true;;
 		-o)
@@ -481,6 +503,10 @@ if [ "$TERMUX_REPO_PACKAGE" != "$TERMUX_APP_PACKAGE" ]; then
 	TERMUX_INSTALL_DEPS=false
 fi
 
+if [ "$TERMUX_REPO_PKG_FORMAT" != "debian" ] && [ "$TERMUX_REPO_PKG_FORMAT" != "pacman" ]; then
+	termux_error_exit "'pkg_format' is incorrectly specified in repo.json file. Only 'debian' and 'pacman' formats are supported"
+fi
+
 if [ -n "${TERMUX_PACKAGE_FORMAT-}" ]; then
 	case "${TERMUX_PACKAGE_FORMAT-}" in
 		debian|pacman) :;;
@@ -488,7 +514,14 @@ if [ -n "${TERMUX_PACKAGE_FORMAT-}" ]; then
 	esac
 fi
 
-if [ "${TERMUX_INSTALL_DEPS-false}" = "true" ]; then
+if [ -n "${TERMUX_PACKAGE_LIBRARY-}" ]; then
+	case "${TERMUX_PACKAGE_LIBRARY-}" in
+		bionic|glibc) :;;
+		*) termux_error_exit "Unsupported library \"${TERMUX_PACKAGE_LIBRARY-}\". Only 'bionic' and 'glibc' library are supported";;
+	esac
+fi
+
+if [ "${TERMUX_INSTALL_DEPS-false}" = "true" ] || [ "${TERMUX_PACKAGE_LIBRARY-bionic}" = "glibc" ]; then
 	# Setup PGP keys for verifying integrity of dependencies.
 	# Keys are obtained from our keyring package.
 	gpg --list-keys 2C7F29AE97891F6419A9E2CDB0076E490B71616B > /dev/null 2>&1 || {
@@ -499,6 +532,10 @@ if [ "${TERMUX_INSTALL_DEPS-false}" = "true" ]; then
 		gpg --import "$TERMUX_SCRIPTDIR/packages/termux-keyring/termux-autobuilds.gpg"
 		gpg --no-tty --command-file <(echo -e "trust\n5\ny")  --edit-key CC72CF8BA7DBFA0182877D045A897D96E57CF20C
 	}
+	gpg --list-keys 998DE27318E867EA976BA877389CEED64573DFCA > /dev/null 2>&1 || {
+		gpg --import "$TERMUX_SCRIPTDIR/packages/termux-keyring/termux-pacman.gpg"
+		gpg --no-tty --command-file <(echo -e "trust\n5\ny")  --edit-key 998DE27318E867EA976BA877389CEED64573DFCA
+	}
 fi
 
 for ((i=0; i<${#PACKAGE_LIST[@]}; i++)); do
@@ -518,7 +555,9 @@ for ((i=0; i<${#PACKAGE_LIST[@]}; i++)); do
 				env TERMUX_ARCH="$arch" TERMUX_BUILD_IGNORE_LOCK=true ./build-package.sh \
 					${TERMUX_FORCE_BUILD+-f} ${TERMUX_INSTALL_DEPS+-i} ${TERMUX_IS_DISABLED+-D} \
 					${TERMUX_DEBUG_BUILD+-d} ${TERMUX_OUTPUT_DIR+-o $TERMUX_OUTPUT_DIR} \
-					--format ${TERMUX_PACKAGE_FORMAT:=debian} "${PACKAGE_LIST[i]}"
+					${TERMUX_FORCE_BUILD_DEPENDENCIES+-F} ${TERMUX_GLOBAL_LIBRARY+-L} \
+					--format ${TERMUX_PACKAGE_FORMAT:=debian} \
+					--library ${TERMUX_PACKAGE_LIBRARY:=bionic} "${PACKAGE_LIST[i]}"
 			done
 			exit
 		fi
@@ -561,6 +600,9 @@ for ((i=0; i<${#PACKAGE_LIST[@]}; i++)); do
 
 		if [ "$TERMUX_CONTINUE_BUILD" == "false" ]; then
 			termux_step_get_dependencies
+			if [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+				termux_step_setup_cgct_environment
+			fi
 			termux_step_override_config_scripts
 		fi
 
@@ -604,7 +646,7 @@ for ((i=0; i<${#PACKAGE_LIST[@]}; i++)); do
 		cd "$TERMUX_PKG_MASSAGEDIR"
 		termux_step_extract_into_massagedir
 		termux_step_massage
-		cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX"
+		cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX_CLASSICAL"
 		termux_step_post_massage
 		cd "$TERMUX_PKG_MASSAGEDIR"
 		if [ "$TERMUX_PACKAGE_FORMAT" = "debian" ]; then
diff --git a/clean.sh b/clean.sh
index a1d03a2da5..7f36c08f55 100755
--- a/clean.sh
+++ b/clean.sh
@@ -48,6 +48,7 @@ fi
 		# For on-device build cleanup /data shouldn't be erased.
 		rm -Rf "$TERMUX_TOPDIR"
 	else
-		rm -Rf /data/* "$TERMUX_TOPDIR"
+		find /data -mindepth 1 ! -regex '^/data/data/com.termux/cgct\(/.*\)?' -delete 2> /dev/null || true
+		rm -Rf "$TERMUX_TOPDIR"
 	fi
 } 5< "$TERMUX_BUILD_LOCK_FILE"
diff --git a/repo.json b/repo.json
index ef1b08cb26..fd6bd5ded4 100644
--- a/repo.json
+++ b/repo.json
@@ -1,4 +1,5 @@
 {
+  "pkg_format": "debian",
   "packages": {
     "name": "termux-main",
     "distribution": "stable",
diff --git a/scripts/Dockerfile b/scripts/Dockerfile
index 54d2c3b6ba..64d5b918b2 100644
--- a/scripts/Dockerfile
+++ b/scripts/Dockerfile
@@ -3,7 +3,7 @@
 # Push to GitHub registry with:
 #	docker push ghcr.io/termux/package-builder
 # This is done after changing this file or any of the
-# scripts/setup-{ubuntu,android-sdk}.sh setup scripts.
+# scripts/setup-{ubuntu,android-sdk,cgct}.sh setup scripts.
 FROM ubuntu:22.04
 
 # Fix locale to avoid warnings:
@@ -14,7 +14,7 @@ COPY ./setup-ubuntu.sh ./setup-android-sdk.sh ./setup-cgct.sh ./properties.sh ./
 RUN mkdir /tmp/build
 COPY ./build/termux_download.sh /tmp/build/
 
-# Setup needed packages and the Android SDK and NDK:
+# Setup needed packages and the Android SDK and NDK and the CGCT:
 RUN apt-get update && \
 	apt-get -yq upgrade && \
 	apt-get install -yq sudo lsb-release software-properties-common && \
diff --git a/scripts/Vagrantfile b/scripts/Vagrantfile
index c8a3b4517b..a67a993a35 100644
--- a/scripts/Vagrantfile
+++ b/scripts/Vagrantfile
@@ -24,6 +24,7 @@ Vagrant.configure("2") do |config|
   # Run environment setup scripts
   config.vm.provision "shell", inline: "cd /home/vagrant/termux-packages && ./scripts/setup-ubuntu.sh", privileged: false
   config.vm.provision "shell", inline: "cd /home/vagrant/termux-packages && ./scripts/setup-android-sdk.sh", privileged: false
+  config.vm.provision "shell", inline: "cd /home/vagrant/termux-packages && ./scripts/setup-cgct.sh", privileged: false
 
   # Fix permissions on the /data directory in order to allow the "vagrant" user to write to it
   config.vm.provision "shell",
diff --git a/scripts/bin/revbump b/scripts/bin/revbump
index 9ad1baa907..3fe6bbeefd 100755
--- a/scripts/bin/revbump
+++ b/scripts/bin/revbump
@@ -20,7 +20,10 @@ Add or increment TERMUX_PKG_REVISION of all the packages that have <package> in
 """
 
 REPO_PATH = os.path.join("/".join(os.path.realpath(sys.argv[0]).split("/")[:-3]), "repo.json")
-FOLDERS = [os.path.join("/".join(os.path.realpath(sys.argv[0]).split("/")[:-3]),folder) for folder in list(json.load(open(REPO_PATH)).keys())]
+FOLDERS = []
+for folder in list(json.load(open(REPO_PATH)).keys()):
+    if folder != "pkg_format":
+        FOLDERS.append(folder)
 
 
 def is_dep(DEP: str, line: str) -> bool:
diff --git a/scripts/bin/update-checksum b/scripts/bin/update-checksum
index e2862a337a..aa905e750d 100755
--- a/scripts/bin/update-checksum
+++ b/scripts/bin/update-checksum
@@ -40,7 +40,7 @@ for package in "${@}"; do
 		buildsh_path="${package}/build.sh"
 		package=$(basename ${package})
 	else
-		for repo_path in $(jq --raw-output 'keys | .[]' $REPO_ROOT/repo.json); do
+		for repo_path in $(jq --raw-output 'del(.pkg_format) | keys | .[]' $REPO_ROOT/repo.json); do
 			if [ -d "${repo_path}/${package}" ] && [ -f "${repo_path}/${package}/build.sh" ]; then
 				repo=$(jq --raw-output '.["'$repo_path'"].name' $REPO_ROOT/repo.json)
 				repo=${repo#"termux-"}
diff --git a/scripts/bin/update-packages b/scripts/bin/update-packages
index 21d74fda98..ccb2f20908 100755
--- a/scripts/bin/update-packages
+++ b/scripts/bin/update-packages
@@ -22,7 +22,7 @@ export TERMUX_SCRIPTDIR
 TERMUX_SCRIPTDIR=$(realpath "$(dirname "$0")/../..") # Root of repository.
 
 export TERMUX_PACKAGES_DIRECTORIES
-TERMUX_PACKAGES_DIRECTORIES=$(jq --raw-output 'keys | .[]' "${TERMUX_SCRIPTDIR}"/repo.json)
+TERMUX_PACKAGES_DIRECTORIES=$(jq --raw-output 'del(.pkg_format) | keys | .[]' "${TERMUX_SCRIPTDIR}"/repo.json)
 
 # Define few more variables used by scripts.
 # shellcheck source=scripts/properties.sh
@@ -189,7 +189,7 @@ _update_dependencies() {
 echo "INFO: Running update for: $*"
 
 if [[ "$1" == "@all" ]]; then
-	for repo_dir in $(jq --raw-output 'keys | .[]' "${TERMUX_SCRIPTDIR}/repo.json"); do
+	for repo_dir in $(jq --raw-output 'del(.pkg_format) | keys | .[]' "${TERMUX_SCRIPTDIR}/repo.json"); do
 		for pkg_dir in "${repo_dir}"/*; do
 			! _should_update "${pkg_dir}" && continue # Skip if not needed.
 			# Update all its dependencies first.
@@ -206,7 +206,7 @@ if [[ "$1" == "@all" ]]; then
 else
 	for pkg in "$@"; do
 		if [ ! -d "${pkg}" ]; then # If only package name is given, try to find it's directory.
-			for repo_dir in $(jq --raw-output 'keys | .[]' "${TERMUX_SCRIPTDIR}/repo.json"); do
+			for repo_dir in $(jq --raw-output 'del(.pkg_format) | keys | .[]' "${TERMUX_SCRIPTDIR}/repo.json"); do
 				if [ -d "${repo_dir}/${pkg}" ]; then
 					pkg="${repo_dir}/${pkg}"
 					break
diff --git a/scripts/build/setup/termux_setup_cmake.sh b/scripts/build/setup/termux_setup_cmake.sh
index 8f16634357..d7772316d6 100644
--- a/scripts/build/setup/termux_setup_cmake.sh
+++ b/scripts/build/setup/termux_setup_cmake.sh
@@ -5,6 +5,11 @@ termux_setup_cmake() {
 	local TERMUX_CMAKE_TARNAME=cmake-${TERMUX_CMAKE_VERSION}-linux-x86_64.tar.gz
 	local TERMUX_CMAKE_TARFILE=$TERMUX_PKG_TMPDIR/$TERMUX_CMAKE_TARNAME
 	local TERMUX_CMAKE_FOLDER
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+		local TERMUX_CMAKE_NAME="cmake"
+	elif [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		local TERMUX_CMAKE_NAME="cmake-glibc"
+	fi
 
 	if [ "${TERMUX_PACKAGES_OFFLINE-false}" = "true" ]; then
 		TERMUX_CMAKE_FOLDER=$TERMUX_SCRIPTDIR/build-tools/cmake-$TERMUX_CMAKE_VERSION
@@ -32,14 +37,14 @@ termux_setup_cmake() {
 
 		export PATH=$TERMUX_CMAKE_FOLDER/bin:$PATH
 	else
-		if [[ "$TERMUX_APP_PACKAGE_MANAGER" = "apt" && "$(dpkg-query -W -f '${db:Status-Status}\n' cmake 2>/dev/null)" != "installed" ]] ||
-                   [[ "$TERMUX_APP_PACKAGE_MANAGER" = "pacman" && ! "$(pacman -Q cmake 2>/dev/null)" ]]; then
-			echo "Package 'cmake' is not installed."
+		if [[ "$TERMUX_APP_PACKAGE_MANAGER" = "apt" && "$(dpkg-query -W -f '${db:Status-Status}\n' $TERMUX_CMAKE_NAME 2>/dev/null)" != "installed" ]] ||
+                   [[ "$TERMUX_APP_PACKAGE_MANAGER" = "pacman" && ! "$(pacman -Q $TERMUX_CMAKE_NAME 2>/dev/null)" ]]; then
+			echo "Package '$TERMUX_CMAKE_NAME' is not installed."
 			echo "You can install it with"
 			echo
-			echo "  pkg install cmake"
+			echo "  pkg install $TERMUX_CMAKE_NAME"
 			echo
-			echo "  pacman -S cmake"
+			echo "  pacman -S $TERMUX_CMAKE_NAME"
 			echo
 			exit 1
 		fi
diff --git a/scripts/build/termux_create_debian_subpackages.sh b/scripts/build/termux_create_debian_subpackages.sh
index 238fdcadc3..fc85110349 100644
--- a/scripts/build/termux_create_debian_subpackages.sh
+++ b/scripts/build/termux_create_debian_subpackages.sh
@@ -13,6 +13,9 @@ termux_create_debian_subpackages() {
 		test ! -f "$subpackage" && continue
 		local SUB_PKG_NAME
 		SUB_PKG_NAME=$(basename "$subpackage" .subpackage.sh)
+		if [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ] && ! package__is_package_name_have_glibc_prefix "$SUB_PKG_NAME"; then
+			SUB_PKG_NAME="${SUB_PKG_NAME}-glibc"
+		fi
 		# Default value is same as main package, but sub package may override:
 		local TERMUX_SUBPKG_PLATFORM_INDEPENDENT=$TERMUX_PKG_PLATFORM_INDEPENDENT
 		local SUB_PKG_DIR=$TERMUX_TOPDIR/$TERMUX_PKG_NAME/subpackages/$SUB_PKG_NAME
@@ -72,7 +75,7 @@ termux_create_debian_subpackages() {
 		if [ "$SUB_PKG_ARCH" = "all" ] && [ "$(find . -type f -print | head -n1)" = "" ]; then
 			echo "No files in subpackage '$SUB_PKG_NAME' when built for $SUB_PKG_ARCH with package '$TERMUX_PKG_NAME', so"
 			echo "the subpackage was not created. If unexpected, check to make sure the files are where you expect."
-			cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX"
+			cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX_CLASSICAL"
 			continue
 		fi
 		local SUB_PKG_INSTALLSIZE
@@ -101,6 +104,16 @@ termux_create_debian_subpackages() {
 		    TERMUX_SUBPKG_DEPENDS+=", $TERMUX_PKG_DEPENDS"
 		fi
 
+		if [ "$TERMUX_GLOBAL_LIBRARY" = "true" ] && [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+			test ! -z "$TERMUX_SUBPKG_DEPENDS" && TERMUX_SUBPKG_DEPENDS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_DEPENDS")
+			test ! -z "$TERMUX_SUBPKG_BREAKS" && TERMUX_SUBPKG_BREAKS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_BREAKS")
+			test ! -z "$TERMUX_SUBPKG_CONFLICTS" && TERMUX_SUBPKG_CONFLICTS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_CONFLICTS")
+			test ! -z "$TERMUX_SUBPKG_RECOMMENDS" && TERMUX_SUBPKG_RECOMMENDS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_RECOMMENDS")
+			test ! -z "$TERMUX_SUBPKG_REPLACES" && TERMUX_SUBPKG_REPLACES=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_REPLACES")
+			test ! -z "$TERMUX_SUBPKG_PROVIDES" && TERMUX_SUBPKG_PROVIDES=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_PROVIDES")
+			test ! -z "$TERMUX_SUBPKG_SUGGESTS" && TERMUX_SUBPKG_SUGGESTS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_SUGGESTS")
+		fi
+
 		[ "$TERMUX_SUBPKG_ESSENTIAL" = "true" ] && echo "Essential: yes" >> control
 		test ! -z "$TERMUX_SUBPKG_DEPENDS" && echo "Depends: ${TERMUX_SUBPKG_DEPENDS/#, /}" >> control
 		test ! -z "$TERMUX_SUBPKG_BREAKS" && echo "Breaks: $TERMUX_SUBPKG_BREAKS" >> control
@@ -128,6 +141,6 @@ termux_create_debian_subpackages() {
 				   "$SUB_PKG_PACKAGE_DIR/data.tar.xz"
 
 		# Go back to main package:
-		cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX"
+		cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX_CLASSICAL"
 	done
 }
diff --git a/scripts/build/termux_create_pacman_subpackages.sh b/scripts/build/termux_create_pacman_subpackages.sh
index 648957043f..d0e35efbd9 100644
--- a/scripts/build/termux_create_pacman_subpackages.sh
+++ b/scripts/build/termux_create_pacman_subpackages.sh
@@ -13,6 +13,9 @@ termux_create_pacman_subpackages() {
 		test ! -f "$subpackage" && continue
 		local SUB_PKG_NAME
 		SUB_PKG_NAME=$(basename "$subpackage" .subpackage.sh)
+		if [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ] && ! package__is_package_name_have_glibc_prefix "$SUB_PKG_NAME"; then
+			SUB_PKG_NAME="${SUB_PKG_NAME}-glibc"
+		fi
 		# Default value is same as main package, but sub package may override:
 		local TERMUX_SUBPKG_PLATFORM_INDEPENDENT=$TERMUX_PKG_PLATFORM_INDEPENDENT
 		local SUB_PKG_DIR=$TERMUX_TOPDIR/$TERMUX_PKG_NAME/subpackages/$SUB_PKG_NAME
@@ -69,7 +72,7 @@ termux_create_pacman_subpackages() {
 		if [ "$SUB_PKG_ARCH" = "any" ] && [ "$(find . -type f -print | head -n1)" = "" ]; then
 			echo "No files in subpackage '$SUB_PKG_NAME' when built for $SUB_PKG_ARCH with package '$TERMUX_PKG_NAME', so"
 			echo "the subpackage was not created. If unexpected, check to make sure the files are where you expect."
-			cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX"
+			cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX_CLASSICAL"
 			continue
 		fi
 		local SUB_PKG_INSTALLSIZE
@@ -89,6 +92,16 @@ termux_create_pacman_subpackages() {
 			TERMUX_SUBPKG_DEPENDS+=", $TERMUX_PKG_DEPENDS"
 		fi
 
+		if [ "$TERMUX_GLOBAL_LIBRARY" = "true" ] && [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+			test ! -z "$TERMUX_SUBPKG_DEPENDS" && TERMUX_SUBPKG_DEPENDS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_DEPENDS")
+			test ! -z "$TERMUX_SUBPKG_BREAKS" && TERMUX_SUBPKG_BREAKS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_BREAKS")
+			test ! -z "$TERMUX_SUBPKG_CONFLICTS" && TERMUX_SUBPKG_CONFLICTS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_CONFLICTS")
+			test ! -z "$TERMUX_SUBPKG_RECOMMENDS" && TERMUX_SUBPKG_RECOMMENDS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_RECOMMENDS")
+			test ! -z "$TERMUX_SUBPKG_REPLACES" && TERMUX_SUBPKG_REPLACES=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_REPLACES")
+			test ! -z "$TERMUX_SUBPKG_PROVIDES" && TERMUX_SUBPKG_PROVIDES=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_PROVIDES")
+			test ! -z "$TERMUX_SUBPKG_SUGGESTS" && TERMUX_SUBPKG_SUGGESTS=$(package__add_prefix_glibc_to_package_names "$TERMUX_SUBPKG_SUGGESTS")
+		fi
+
 		# Package metadata.
 		{
 			echo "pkgname = $SUB_PKG_NAME"
@@ -195,6 +208,6 @@ termux_create_pacman_subpackages() {
 		shopt -u dotglob globstar
 
 		# Go back to main package:
-		cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX"
+		cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX_CLASSICAL"
 	done
 }
diff --git a/scripts/build/termux_download_deb_pac.sh b/scripts/build/termux_download_deb_pac.sh
index ba5cbf0ba5..282fab0978 100755
--- a/scripts/build/termux_download_deb_pac.sh
+++ b/scripts/build/termux_download_deb_pac.sh
@@ -6,7 +6,12 @@ termux_download_deb_pac() {
 	local VERSION=$3
 	local VERSION_PACMAN=$4
 
-	local DEB_FILE="${PACKAGE}_${VERSION}_${PACKAGE_ARCH}.deb"
+	local PKG_FILE
+	if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+		PKG_FILE="${PACKAGE}_${VERSION}_${PACKAGE_ARCH}.deb"
+	elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+		PKG_FILE="${PACKAGE}-${VERSION_PACMAN}-${PACKAGE_ARCH}.pkg.tar.xz"
+	fi
 	PKG_HASH=""
 
 	# Dependencies should be used from repo only if they are built for
@@ -15,7 +20,7 @@ termux_download_deb_pac() {
 	# extract files to different prefix than TERMUX_PREFIX and builds
 	# would fail when looking for -I$TERMUX_PREFIX/include files.
 	if [ "$TERMUX_REPO_PACKAGE" != "$TERMUX_APP_PACKAGE" ]; then
-		echo "Ignoring download of $DEB_FILE since repo package name ($TERMUX_REPO_PACKAGE) does not equal app package name ($TERMUX_APP_PACKAGE)"
+		echo "Ignoring download of $PKG_FILE since repo package name ($TERMUX_REPO_PACKAGE) does not equal app package name ($TERMUX_APP_PACKAGE)"
 		return 1
 	fi
 
@@ -29,14 +34,28 @@ termux_download_deb_pac() {
 
 	for idx in $(seq ${#TERMUX_REPO_URL[@]}); do
 		local TERMUX_REPO_NAME=$(echo ${TERMUX_REPO_URL[$idx-1]} | sed -e 's%https://%%g' -e 's%http://%%g' -e 's%/%-%g')
-		local PACKAGE_FILE_PATH="${TERMUX_REPO_NAME}-${TERMUX_REPO_DISTRIBUTION[$idx-1]}-${TERMUX_REPO_COMPONENT[$idx-1]}-Packages"
+		if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+			local PACKAGE_FILE_PATH="${TERMUX_REPO_NAME}-${TERMUX_REPO_DISTRIBUTION[$idx-1]}-${TERMUX_REPO_COMPONENT[$idx-1]}-Packages"
+		elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+			local PACKAGE_FILE_PATH="${TERMUX_REPO_NAME}-json"
+		fi
 		if [ "${PACKAGE_ARCH}" = 'all' ]; then
 			for arch in 'aarch64' 'arm' 'i686' 'x86_64'; do
 				if [ -f "${TERMUX_COMMON_CACHEDIR}-${arch}/${PACKAGE_FILE_PATH}" ]; then
-					read -d "\n" PKG_PATH PKG_HASH <<<$(./scripts/get_hash_from_file.py "${TERMUX_COMMON_CACHEDIR}-${arch}/$PACKAGE_FILE_PATH" $PACKAGE $VERSION)
-					if [ -n "$PKG_HASH" ]; then
+					if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+						read -d "\n" PKG_PATH PKG_HASH <<<$(./scripts/get_hash_from_file.py "${TERMUX_COMMON_CACHEDIR}-${arch}/$PACKAGE_FILE_PATH" $PACKAGE $VERSION)
+					elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+						PKG_HASH=$(jq -r '."'$PACKAGE'"."SHA256SUM"' "${TERMUX_COMMON_CACHEDIR}-${arch}/$PACKAGE_FILE_PATH")
+						PKG_PATH=$(jq -r '."'$PACKAGE'"."FILENAME"' "${TERMUX_COMMON_CACHEDIR}-${arch}/$PACKAGE_FILE_PATH")
+						PKG_PATH="${arch}/${PKG_PATH}"
+					fi
+					if [ -n "$PKG_HASH" ] && [ "$PKG_HASH" != "null" ]; then
 						if [ ! "$TERMUX_QUIET_BUILD" = true ]; then
-							echo "Found $PACKAGE in ${TERMUX_REPO_URL[$idx-1]}/dists/${TERMUX_REPO_DISTRIBUTION[$idx-1]}"
+							if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+								echo "Found $PACKAGE in ${TERMUX_REPO_URL[$idx-1]}/dists/${TERMUX_REPO_DISTRIBUTION[$idx-1]}"
+							elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+								echo "Found $PACKAGE in ${TERMUX_REPO_URL[$idx-1]}"
+							fi
 						fi
 						break 2
 					fi
@@ -49,30 +68,50 @@ termux_download_deb_pac() {
 			# all arch is mixed into the other arches,
 			# check for package in aarch64 Packages
 			# instead.
-			read -d "\n" PKG_PATH PKG_HASH <<<$(./scripts/get_hash_from_file.py "${TERMUX_COMMON_CACHEDIR}-aarch64/$PACKAGE_FILE_PATH" $PACKAGE $VERSION)
-			if [ -n "$PKG_HASH" ]; then
+			if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+				read -d "\n" PKG_PATH PKG_HASH <<<$(./scripts/get_hash_from_file.py "${TERMUX_COMMON_CACHEDIR}-aarch64/$PACKAGE_FILE_PATH" $PACKAGE $VERSION)
+			elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+				PKG_HASH=$(jq -r '."'$PACKAGE'"."SHA256SUM"' "${TERMUX_COMMON_CACHEDIR}-aarch64/$PACKAGE_FILE_PATH")
+				PKG_PATH=$(jq -r '."'$PACKAGE'"."FILENAME"' "${TERMUX_COMMON_CACHEDIR}-aarch64/$PACKAGE_FILE_PATH")
+				PKG_PATH="aarch64/${PKG_PATH}"
+			fi
+			if [ -n "$PKG_HASH" ] && [ "$PKG_HASH" != "null" ]; then
 				if [ ! "$TERMUX_QUIET_BUILD" = true ]; then
-					echo "Found $PACKAGE in ${TERMUX_REPO_URL[$idx-1]}/dists/${TERMUX_REPO_DISTRIBUTION[$idx-1]}"
+					if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+						echo "Found $PACKAGE in ${TERMUX_REPO_URL[$idx-1]}/dists/${TERMUX_REPO_DISTRIBUTION[$idx-1]}"
+					elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+						echo "Found $PACKAGE in ${TERMUX_REPO_URL[$idx-1]}"
+					fi
 				fi
 				break
 			fi
 		elif [ -f "${TERMUX_COMMON_CACHEDIR}-${PACKAGE_ARCH}/${PACKAGE_FILE_PATH}" ]; then
-			read -d "\n" PKG_PATH PKG_HASH <<<$(./scripts/get_hash_from_file.py "${TERMUX_COMMON_CACHEDIR}-${PACKAGE_ARCH}/$PACKAGE_FILE_PATH" $PACKAGE $VERSION)
-			if [ -n "$PKG_HASH" ]; then
+			if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+				read -d "\n" PKG_PATH PKG_HASH <<<$(./scripts/get_hash_from_file.py "${TERMUX_COMMON_CACHEDIR}-${PACKAGE_ARCH}/$PACKAGE_FILE_PATH" $PACKAGE $VERSION)
+			elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+				PKG_HASH=$(jq -r '."'$PACKAGE'"."SHA256SUM"' "${TERMUX_COMMON_CACHEDIR}-${PACKAGE_ARCH}/$PACKAGE_FILE_PATH")
+				PKG_PATH=$(jq -r '."'$PACKAGE'"."FILENAME"' "${TERMUX_COMMON_CACHEDIR}-${PACKAGE_ARCH}/$PACKAGE_FILE_PATH")
+				PKG_PATH="${PACKAGE_ARCH}/${PKG_PATH}"
+			fi
+			if [ -n "$PKG_HASH" ] && [ "$PKG_HASH" != "null" ]; then
 				if [ ! "$TERMUX_QUIET_BUILD" = true ]; then
-					echo "Found $PACKAGE in ${TERMUX_REPO_URL[$idx-1]}/dists/${TERMUX_REPO_DISTRIBUTION[$idx-1]}"
+					if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+						echo "Found $PACKAGE in ${TERMUX_REPO_URL[$idx-1]}/dists/${TERMUX_REPO_DISTRIBUTION[$idx-1]}"
+					elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+						echo "Found $PACKAGE in ${TERMUX_REPO_URL[$idx-1]}"
+					fi
 				fi
 				break
 			fi
 		fi
 	done
 
-	if [ "$PKG_HASH" = "" ]; then
+	if [ "$PKG_HASH" = "" ] || [ "$PKG_HASH" = "null" ]; then
 		return 1
 	fi
 
 	termux_download "${TERMUX_REPO_URL[${idx}-1]}/${PKG_PATH}" \
-				"${TERMUX_COMMON_CACHEDIR}-${PACKAGE_ARCH}/${DEB_FILE}" \
+				"${TERMUX_COMMON_CACHEDIR}-${PACKAGE_ARCH}/${PKG_FILE}" \
 				"$PKG_HASH"
 }
 
diff --git a/scripts/build/termux_extract_dep_info.sh b/scripts/build/termux_extract_dep_info.sh
index 5883c81eec..1bad2c1e78 100755
--- a/scripts/build/termux_extract_dep_info.sh
+++ b/scripts/build/termux_extract_dep_info.sh
@@ -3,7 +3,7 @@
 termux_extract_dep_info() {
 	PKG=$1
 	PKG_DIR=$2
-	if [ "$PKG" != "$(basename ${PKG_DIR})" ]; then
+	if [ "$PKG" != "$(basename ${PKG_DIR})" ] && [ "${PKG/-glibc/}" != "$(basename ${PKG_DIR})" ]; then
 		# We are dealing with a subpackage
 		TERMUX_ARCH=$(
 			# set TERMUX_SUBPKG_PLATFORM_INDEPENDENT to
diff --git a/scripts/build/termux_get_repo_files.sh b/scripts/build/termux_get_repo_files.sh
index 4deb5b0645..ef756904ee 100644
--- a/scripts/build/termux_get_repo_files.sh
+++ b/scripts/build/termux_get_repo_files.sh
@@ -7,32 +7,46 @@ termux_get_repo_files() {
 
 	for idx in $(seq ${#TERMUX_REPO_URL[@]}); do
 		local TERMUX_REPO_NAME=$(echo ${TERMUX_REPO_URL[$idx-1]} | sed -e 's%https://%%g' -e 's%http://%%g' -e 's%/%-%g')
-		local RELEASE_FILE=${TERMUX_COMMON_CACHEDIR}/${TERMUX_REPO_NAME}-${TERMUX_REPO_DISTRIBUTION[$idx-1]}-Release
-		local repo_base="${TERMUX_REPO_URL[$idx-1]}/dists/${TERMUX_REPO_DISTRIBUTION[$idx-1]}"
-		local dl_prefix="${TERMUX_REPO_NAME}-${TERMUX_REPO_DISTRIBUTION[$idx-1]}-${TERMUX_REPO_COMPONENT[$idx-1]}"
+		if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+			local RELEASE_FILE=${TERMUX_COMMON_CACHEDIR}/${TERMUX_REPO_NAME}-${TERMUX_REPO_DISTRIBUTION[$idx-1]}-Release
+			local repo_base="${TERMUX_REPO_URL[$idx-1]}/dists/${TERMUX_REPO_DISTRIBUTION[$idx-1]}"
+			local dl_prefix="${TERMUX_REPO_NAME}-${TERMUX_REPO_DISTRIBUTION[$idx-1]}-${TERMUX_REPO_COMPONENT[$idx-1]}"
+		elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+			local JSON_FILE="${TERMUX_COMMON_CACHEDIR}-${TERMUX_ARCH}/${TERMUX_REPO_NAME}-json"
+			local repo_base="${TERMUX_REPO_URL[$idx-1]}/${TERMUX_ARCH}"
+		fi
 
 		local download_attempts=6
 		while ((download_attempts > 0)); do
-			if termux_download "${repo_base}/Release" "$RELEASE_FILE" SKIP_CHECKSUM && \
-				termux_download "${repo_base}/Release.gpg" "${RELEASE_FILE}.gpg" SKIP_CHECKSUM && \
-				gpg --verify "${RELEASE_FILE}.gpg" "$RELEASE_FILE"; then
+			if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+				if termux_download "${repo_base}/Release" "$RELEASE_FILE" SKIP_CHECKSUM && \
+					termux_download "${repo_base}/Release.gpg" "${RELEASE_FILE}.gpg" SKIP_CHECKSUM && \
+					gpg --verify "${RELEASE_FILE}.gpg" "$RELEASE_FILE"; then
 
-				local failed=false
-				for arch in all $TERMUX_ARCH; do
-					local PACKAGES_HASH=$(./scripts/get_hash_from_file.py ${RELEASE_FILE} $arch ${TERMUX_REPO_COMPONENT[$idx-1]})
+					local failed=false
+					for arch in all $TERMUX_ARCH; do
+						local PACKAGES_HASH=$(./scripts/get_hash_from_file.py ${RELEASE_FILE} $arch ${TERMUX_REPO_COMPONENT[$idx-1]})
 
-					# If packages_hash = "" then the repo probably doesn't contain debs for $arch
-					if [ -n "$PACKAGES_HASH" ]; then
-						if ! termux_download "${repo_base}/${TERMUX_REPO_COMPONENT[$idx-1]}/binary-$arch/Packages" \
-							"${TERMUX_COMMON_CACHEDIR}-$arch/${dl_prefix}-Packages" \
-							$PACKAGES_HASH; then
-							failed=true
-							break
+						# If packages_hash = "" then the repo probably doesn't contain debs for $arch
+						if [ -n "$PACKAGES_HASH" ]; then
+							if ! termux_download "${repo_base}/${TERMUX_REPO_COMPONENT[$idx-1]}/binary-$arch/Packages" \
+								"${TERMUX_COMMON_CACHEDIR}-$arch/${dl_prefix}-Packages" \
+								$PACKAGES_HASH; then
+								failed=true
+								break
+							fi
 						fi
-					fi
-				done
+					done
+
+					if ! $failed; then
+						break
+					fi
+				fi
+			elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+				if termux_download "${repo_base}/${TERMUX_REPO_DISTRIBUTION[$idx-1]}.json" "$JSON_FILE" SKIP_CHECKSUM && \
+					termux_download "${repo_base}/${TERMUX_REPO_DISTRIBUTION[$idx-1]}.json.sig" "${JSON_FILE}.sig" SKIP_CHECKSUM && \
+					gpg --verify "${JSON_FILE}.sig" "$JSON_FILE"; then
 
-				if ! $failed; then
 					break
 				fi
 			fi
diff --git a/scripts/build/termux_step_create_debian_package.sh b/scripts/build/termux_step_create_debian_package.sh
index a85093de55..7232b4dff4 100644
--- a/scripts/build/termux_step_create_debian_package.sh
+++ b/scripts/build/termux_step_create_debian_package.sh
@@ -21,6 +21,15 @@ termux_step_create_debian_package() {
 		Version: $TERMUX_PKG_FULLVERSION
 		Homepage: $TERMUX_PKG_HOMEPAGE
 	HERE
+	if [ "$TERMUX_GLOBAL_LIBRARY" = "true" ] && [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		test ! -z "$TERMUX_PKG_DEPENDS" && TERMUX_PKG_DEPENDS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_DEPENDS")
+		test ! -z "$TERMUX_PKG_BREAKS" && TERMUX_PKG_BREAKS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_BREAKS")
+		test ! -z "$TERMUX_PKG_CONFLICTS" && TERMUX_PKG_CONFLICTS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_CONFLICTS")
+		test ! -z "$TERMUX_PKG_RECOMMENDS" && TERMUX_PKG_RECOMMENDS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_RECOMMENDS")
+		test ! -z "$TERMUX_PKG_REPLACES" && TERMUX_PKG_REPLACES=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_REPLACES")
+		test ! -z "$TERMUX_PKG_PROVIDES" && TERMUX_PKG_PROVIDES=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_PROVIDES")
+		test ! -z "$TERMUX_PKG_SUGGESTS" && TERMUX_PKG_SUGGESTS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_SUGGESTS")
+	fi
 	test ! -z "$TERMUX_PKG_BREAKS" && echo "Breaks: $TERMUX_PKG_BREAKS" >> DEBIAN/control
 	test ! -z "$TERMUX_PKG_PRE_DEPENDS" && echo "Pre-Depends: $TERMUX_PKG_PRE_DEPENDS" >> DEBIAN/control
 	test ! -z "$TERMUX_PKG_DEPENDS" && echo "Depends: $TERMUX_PKG_DEPENDS" >> DEBIAN/control
diff --git a/scripts/build/termux_step_create_pacman_package.sh b/scripts/build/termux_step_create_pacman_package.sh
index 17a1e4c6d7..86d588cea7 100644
--- a/scripts/build/termux_step_create_pacman_package.sh
+++ b/scripts/build/termux_step_create_pacman_package.sh
@@ -40,6 +40,16 @@ termux_step_create_pacman_package() {
 	local BUILD_DATE
 	BUILD_DATE=$(date +%s)
 
+	if [ "$TERMUX_GLOBAL_LIBRARY" = "true" ] && [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		test ! -z "$TERMUX_PKG_DEPENDS" && TERMUX_PKG_DEPENDS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_DEPENDS")
+		test ! -z "$TERMUX_PKG_BREAKS" && TERMUX_PKG_BREAKS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_BREAKS")
+		test ! -z "$TERMUX_PKG_CONFLICTS" && TERMUX_PKG_CONFLICTS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_CONFLICTS")
+		test ! -z "$TERMUX_PKG_RECOMMENDS" && TERMUX_PKG_RECOMMENDS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_RECOMMENDS")
+		test ! -z "$TERMUX_PKG_REPLACES" && TERMUX_PKG_REPLACES=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_REPLACES")
+		test ! -z "$TERMUX_PKG_PROVIDES" && TERMUX_PKG_PROVIDES=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_PROVIDES")
+		test ! -z "$TERMUX_PKG_SUGGESTS" && TERMUX_PKG_SUGGESTS=$(package__add_prefix_glibc_to_package_names "$TERMUX_PKG_SUGGESTS")
+	fi
+
 	# Package metadata.
 	{
 		echo "pkgname = $TERMUX_PKG_NAME"
diff --git a/scripts/build/termux_step_extract_into_massagedir.sh b/scripts/build/termux_step_extract_into_massagedir.sh
index bac7667d01..0df0b9e1e6 100644
--- a/scripts/build/termux_step_extract_into_massagedir.sh
+++ b/scripts/build/termux_step_extract_into_massagedir.sh
@@ -2,14 +2,14 @@ termux_step_extract_into_massagedir() {
 	local TARBALL_ORIG=$TERMUX_PKG_PACKAGEDIR/${TERMUX_PKG_NAME}_orig.tar.gz
 
 	# Build diff tar with what has changed during the build:
-	cd $TERMUX_PREFIX
+	cd $TERMUX_PREFIX_CLASSICAL
 	tar -N "$TERMUX_BUILD_TS_FILE" \
 		--exclude='tmp' \
 		-czf "$TARBALL_ORIG" .
 
 	# Extract tar in order to massage it
 	mkdir -p "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX"
-	cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX"
+	cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX_CLASSICAL"
 	tar xf "$TARBALL_ORIG"
 	rm "$TARBALL_ORIG"
 }
diff --git a/scripts/build/termux_step_get_dependencies.sh b/scripts/build/termux_step_get_dependencies.sh
index 5036e3dbf9..5400ca9fbb 100644
--- a/scripts/build/termux_step_get_dependencies.sh
+++ b/scripts/build/termux_step_get_dependencies.sh
@@ -50,7 +50,7 @@ termux_step_get_dependencies() {
 				fi
 			fi
 			if $build_dependency; then
-				TERMUX_BUILD_IGNORE_LOCK=true ./build-package.sh -I $(test "${TERMUX_FORCE_BUILD_DEPENDENCIES}" = "true" && echo "-F" || true) --format $TERMUX_PACKAGE_FORMAT "${PKG_DIR}"
+				termux_run_build-package
 				continue
 			fi
 			termux_add_package_to_built_packages_list "$PKG"
@@ -58,14 +58,19 @@ termux_step_get_dependencies() {
 				[ ! "$TERMUX_QUIET_BUILD" = true ] && echo "extracting $PKG to $TERMUX_COMMON_CACHEDIR-$DEP_ARCH..."
 				(
 					cd $TERMUX_COMMON_CACHEDIR-$DEP_ARCH
-					ar x ${PKG}_${DEP_VERSION}_${DEP_ARCH}.deb data.tar.xz
-					if tar -tf data.tar.xz|grep "^./$">/dev/null; then
-						# Strip prefixed ./, to avoid possible
-						# permission errors from tar
-						tar -xf data.tar.xz --strip-components=1 \
-							--no-overwrite-dir -C /
-					else
-						tar -xf data.tar.xz --no-overwrite-dir -C /
+					if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+						ar x ${PKG}_${DEP_VERSION}_${DEP_ARCH}.deb data.tar.xz
+						if tar -tf data.tar.xz|grep "^./$">/dev/null; then
+							# Strip prefixed ./, to avoid possible
+							# permission errors from tar
+							tar -xf data.tar.xz --strip-components=1 \
+								--no-overwrite-dir -C /
+						else
+							tar -xf data.tar.xz --no-overwrite-dir -C /
+						fi
+					elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+						tar -xJf "${PKG}-${DEP_VERSION_PAC}-${DEP_ARCH}.pkg.tar.xz" \
+							--force-local --no-overwrite-dir -C / data
 					fi
 				)
 			fi
@@ -92,7 +97,7 @@ termux_step_get_dependencies() {
 			else
 				[ ! "$TERMUX_QUIET_BUILD" = true ] && echo "Building dependency $PKG if necessary..."
 			fi
-			TERMUX_BUILD_IGNORE_LOCK=true ./build-package.sh -s $(test "${TERMUX_FORCE_BUILD_DEPENDENCIES}" = "true" && echo "-F" || true) --format $TERMUX_PACKAGE_FORMAT "${PKG_DIR}"
+			termux_run_build-package
 		done<<<$(./scripts/buildorder.py "$TERMUX_PKG_BUILDER_DIR" $TERMUX_PACKAGES_DIRECTORIES || echo "ERROR")
 	fi
 }
@@ -104,3 +109,16 @@ termux_force_check_package_dependency() {
 	fi
 	return 1
 }
+
+termux_run_build-package() {
+	local set_library
+	if [ "$TERMUX_GLOBAL_LIBRARY" = "true" ]; then
+		set_library="$TERMUX_PACKAGE_LIBRARY -L"
+	else
+		set_library="bionic"
+		if package__is_package_name_have_glibc_prefix "$PKG"; then
+			set_library="glibc"
+		fi
+	fi
+	TERMUX_BUILD_IGNORE_LOCK=true ./build-package.sh -s $(test "${TERMUX_FORCE_BUILD_DEPENDENCIES}" = "true" && echo "-F" || true) --format $TERMUX_PACKAGE_FORMAT --library $set_library "${PKG_DIR}"
+}
diff --git a/scripts/build/termux_step_handle_buildarch.sh b/scripts/build/termux_step_handle_buildarch.sh
index 141d3812d7..ef3b36a6d5 100644
--- a/scripts/build/termux_step_handle_buildarch.sh
+++ b/scripts/build/termux_step_handle_buildarch.sh
@@ -17,6 +17,10 @@ termux_step_handle_buildarch() {
 			fi
 			if [ -d /data/data ]; then
 				mv /data/data "$TERMUX_DATA_PREVIOUS_BACKUPDIR"
+				if [ -d "${TERMUX_DATA_PREVIOUS_BACKUPDIR}/${TERMUX_APP_PACKAGE}/cgct" ]; then
+					mkdir -p "/data/data/${TERMUX_APP_PACKAGE}"
+					mv "${TERMUX_DATA_PREVIOUS_BACKUPDIR}/${TERMUX_APP_PACKAGE}/cgct" "/data/data/${TERMUX_APP_PACKAGE}"
+				fi
 			fi
 			# Restore new one (if any)
 			if [ -d "$TERMUX_DATA_CURRENT_BACKUPDIR" ]; then
diff --git a/scripts/build/termux_step_install_license.sh b/scripts/build/termux_step_install_license.sh
index 84514e2bf8..05ce4f9624 100644
--- a/scripts/build/termux_step_install_license.sh
+++ b/scripts/build/termux_step_install_license.sh
@@ -22,6 +22,7 @@ termux_step_install_license() {
 			cp -f "${TERMUX_PKG_SRCDIR}/${LICENSE}" "$TARGET"
 		done < <(echo "$TERMUX_PKG_LICENSE_FILE" | sed "s/,/\n/g")
 	else
+		local TO_LICENSE
 		while read -r LICENSE; do
 			# These licenses contain copyright information, so
 			# we cannot use a generic license file
@@ -61,10 +62,15 @@ termux_step_install_license() {
 					fi
 				done
 			elif [ -f "$TERMUX_SCRIPTDIR/packages/termux-licenses/LICENSES/${LICENSE}.txt" ]; then
+				if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+					TO_LICENSE="../../LICENSES/${LICENSE}.txt"
+				elif [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+					TO_LICENSE="../../../../share/LICENSES/${LICENSE}.txt"
+				fi
 				if [[ $COUNTER -gt 0 ]]; then
-					ln -sf "../../LICENSES/${LICENSE}.txt" "$TERMUX_PREFIX/share/doc/$TERMUX_PKG_NAME/LICENSE.${COUNTER}"
+					ln -sf "$TO_LICENSE" "$TERMUX_PREFIX/share/doc/$TERMUX_PKG_NAME/LICENSE.${COUNTER}"
 				else
-					ln -sf "../../LICENSES/${LICENSE}.txt" "$TERMUX_PREFIX/share/doc/$TERMUX_PKG_NAME/LICENSE"
+					ln -sf "$TO_LICENSE" "$TERMUX_PREFIX/share/doc/$TERMUX_PKG_NAME/LICENSE"
 				fi
 				COUNTER=$((COUNTER + 1))
 			fi
diff --git a/scripts/build/termux_step_massage.sh b/scripts/build/termux_step_massage.sh
index b25f64e50e..121d4a439e 100644
--- a/scripts/build/termux_step_massage.sh
+++ b/scripts/build/termux_step_massage.sh
@@ -1,7 +1,12 @@
 termux_step_massage() {
 	[ "$TERMUX_PKG_METAPACKAGE" = "true" ] && return
 
-	cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX"
+	cd "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX_CLASSICAL"
+
+	local ADDING_PREFIX=""
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		ADDING_PREFIX="glibc/"
+	fi
 
 	# Remove lib/charset.alias which is installed by gettext-using packages:
 	rm -f lib/charset.alias
@@ -29,50 +34,59 @@ termux_step_massage() {
 
 	# Move over sbin to bin:
 	for file in sbin/*; do if test -f "$file"; then mv "$file" bin/; fi; done
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		for file in glibc/sbin/*; do if test -f "$file"; then mv "$file" glibc/bin/; fi; done
+	fi
 
 	# Remove world permissions and make sure that user still have read-write permissions.
 	chmod -Rf u+rw,g-rwx,o-rwx . || true
 
-	if [ "$TERMUX_PKG_NO_STRIP" != "true" ] && [ "$TERMUX_DEBUG_BUILD" = "false" ]; then
-		# Strip binaries. file(1) may fail for certain unusual files, so disable pipefail.
-		set +e +o pipefail
-		find . \( -path "./bin/*" -o -path "./lib/*" -o -path "./libexec/*" \) -type f |
-			xargs -r file | grep -E "ELF .+ (executable|shared object)" | cut -f 1 -d : |
-			xargs -r "$STRIP" --strip-unneeded --preserve-dates
-		set -e -o pipefail
-	fi
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+		if [ "$TERMUX_PKG_NO_STRIP" != "true" ] && [ "$TERMUX_DEBUG_BUILD" = "false" ]; then
+			# Strip binaries. file(1) may fail for certain unusual files, so disable pipefail.
+			set +e +o pipefail
+			find . \( -path "./bin/*" -o -path "./lib/*" -o -path "./libexec/*" \) -type f |
+				xargs -r file | grep -E "ELF .+ (executable|shared object)" | cut -f 1 -d : |
+				xargs -r "$STRIP" --strip-unneeded --preserve-dates
+			set -e -o pipefail
+		fi
 
-	if [ "$TERMUX_PKG_NO_ELF_CLEANER" != "true" ]; then
-		# Remove entries unsupported by Android's linker:
-		find . \( -path "./bin/*" -o -path "./lib/*" -o -path "./libexec/*" -o -path "./opt/*" \) -type f -print0 | xargs -r -0 \
-			"$TERMUX_ELF_CLEANER" --api-level $TERMUX_PKG_API_LEVEL
+		if [ "$TERMUX_PKG_NO_ELF_CLEANER" != "true" ]; then
+			# Remove entries unsupported by Android's linker:
+			find . \( -path "./bin/*" -o -path "./lib/*" -o -path "./libexec/*" -o -path "./opt/*" \) -type f -print0 | xargs -r -0 \
+				"$TERMUX_ELF_CLEANER" --api-level $TERMUX_PKG_API_LEVEL
+		fi
 	fi
 
 	if [ "$TERMUX_PKG_NO_SHEBANG_FIX" != "true" ]; then
 		# Fix shebang paths:
 		while IFS= read -r -d '' file; do
 			if head -c 100 "$file" | head -n 1 | grep -E "^#!.*/bin/.*" | grep -q -E -v "^#! ?/system"; then
-				sed --follow-symlinks -i -E "1 s@^#\!(.*)/bin/(.*)@#\!$TERMUX_PREFIX/bin/\2@" "$file"
+				if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+					sed --follow-symlinks -i -E "1 s@^#\!(.*)/bin/(.*)@#\!$TERMUX_PREFIX/bin/\2@" "$file"
+				elif [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+					sed --follow-symlinks -i -E "1 s@^#\!(.*)/bin/(.*)@#\!$TERMUX_PREFIX_CLASSICAL/bin/\2@" "$file"
+				fi
 			fi
 		done < <(find -L . -type f -print0)
 	fi
 
 	# Delete the info directory file.
-	rm -rf ./share/info/dir
+	rm -rf ./${ADDING_PREFIX}share/info/dir
 
 	# Mostly specific to X11-related packages.
-	rm -f ./share/icons/hicolor/icon-theme.cache
+	rm -f ./${ADDING_PREFIX}share/icons/hicolor/icon-theme.cache
 
 	test ! -z "$TERMUX_PKG_RM_AFTER_INSTALL" && rm -Rf $TERMUX_PKG_RM_AFTER_INSTALL
 
 	find . -type d -empty -delete # Remove empty directories
 
-	if [ -d share/man ]; then
+	if [ -d ./${ADDING_PREFIX}share/man ]; then
 		# Remove non-english man pages:
-		find share/man -mindepth 1 -maxdepth 1 -type d ! -name man\* | xargs -r rm -rf
+		find ./${ADDING_PREFIX}share/man -mindepth 1 -maxdepth 1 -type d ! -name man\* | xargs -r rm -rf
 
 		# Compress man pages with gzip:
-		find share/man -type f ! -iname \*.gz -print0 | xargs -r -0 gzip
+		find ./${ADDING_PREFIX}share/man -type f ! -iname \*.gz -print0 | xargs -r -0 gzip
 
 		# Update man page symlinks, e.g. unzstd.1 -> zstd.1:
 		while IFS= read -r -d '' file; do
@@ -80,13 +94,13 @@ termux_step_massage() {
 			_link_value=$(readlink $file)
 			rm $file
 			ln -s $_link_value.gz $file.gz
-		done < <(find share/man -type l ! -iname \*.gz -print0)
+		done < <(find ./${ADDING_PREFIX}share/man -type l ! -iname \*.gz -print0)
 	fi
 
 	# Check so files were actually installed. Exclude
 	# share/doc/$TERMUX_PKG_NAME/ as a license file is always
 	# installed there.
-	if [ "$(find . -path "./share/doc/$TERMUX_PKG_NAME" -prune -o -type f -print | head -n1)" = "" ]; then
+	if [ "$(find . -path "./${ADDING_PREFIX}share/doc/$TERMUX_PKG_NAME" -prune -o -type f -print | head -n1)" = "" ]; then
 		if [ -f "$TERMUX_PKG_SRCDIR"/configure.ac -o -f "$TERMUX_PKG_SRCDIR"/configure.in ]; then
 			termux_error_exit "No files in package. Maybe you need to run autoreconf -fi before configuring."
 		else
@@ -97,11 +111,29 @@ termux_step_massage() {
 	local HARDLINKS
 	HARDLINKS="$(find . -type f -links +1)"
 	if [ -n "$HARDLINKS" ]; then
-		termux_error_exit "Package contains hard links: $HARDLINKS"
+		if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+			termux_error_exit "Package contains hard links: $HARDLINKS"
+		elif [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+			local declare hard_list
+			for i in $HARDLINKS; do
+				hard_list[$(ls -i "$i" | awk '{printf $1}')]+="$i "
+			done
+			local root_file
+			for i in ${!hard_list[@]}; do
+				root_file=""
+				for j in ${hard_list[$i]}; do
+					if [ -z "$root_file" ]; then
+						root_file="$j"
+						continue
+					fi
+					ln -sf "${TERMUX_PREFIX_CLASSICAL}/${root_file:2}" "${j}"
+				done
+			done
+		fi
 	fi
 
 	# Check for directory "$PREFIX/man" which indicates packaging error.
-	if [ -d "./man" ]; then
+	if [ -d "./${ADDING_PREFIX}man" ]; then
 		termux_error_exit "Package contains directory \"\$PREFIX/man\" ($TERMUX_PREFIX/man). Use \"\$PREFIX/share/man\" ($TERMUX_PREFIX/share/man) instead."
 	fi
 
@@ -112,7 +144,7 @@ termux_step_massage() {
 	fi
 
 	# Check for Debianish Python directory which indicates packaging error.
-	local _python_deb_install_layout_dir="lib/python3/dist-packages"
+	local _python_deb_install_layout_dir="${ADDING_PREFIX}lib/python3/dist-packages"
 	if [ -d "./${_python_deb_install_layout_dir}" ]; then
 		termux_error_exit "Package contains directory \"\$PREFIX/${_python_deb_install_layout_dir}\" ($TERMUX_PREFIX/${_python_deb_install_layout_dir})"
 	fi
@@ -120,7 +152,7 @@ termux_step_massage() {
 	# Check so that package is not affected by
 	# https://github.com/android/ndk/issues/1614, or
 	# https://github.com/termux/termux-packages/issues/9944
-	if [ -d "lib" ]; then
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ] && [ -d "lib" ]; then
 		SYMBOLS="$($READELF -s $($TERMUX_HOST_PLATFORM-clang -print-libgcc-file-name) | grep "FUNC    GLOBAL HIDDEN" | awk '{print $8}')"
 		SYMBOLS+=" $(echo libandroid_{sem_{open,close,unlink},shm{ctl,get,at,dt}})"
 		SYMBOLS+=" $(echo backtrace{,_symbols{,_fd}})"
@@ -144,7 +176,7 @@ termux_step_massage() {
 
 	# Remove unnecessary files in haskell packages:
 	if ! [[ $TERMUX_PKG_NAME =~ ghc|ghc-libs ]]; then
-		test -f ./lib/ghc-*/settings && rm -rf ./lib/ghc-*/settings
+		test -f ./${ADDING_PREFIX}lib/ghc-*/settings && rm -rf ./${ADDING_PREFIX}lib/ghc-*/settings
 	fi
 
 	# .. remove empty directories (NOTE: keep this last):
diff --git a/scripts/build/termux_step_patch_package.sh b/scripts/build/termux_step_patch_package.sh
index 90e7ceb711..df1082d445 100644
--- a/scripts/build/termux_step_patch_package.sh
+++ b/scripts/build/termux_step_patch_package.sh
@@ -25,6 +25,7 @@ termux_step_patch_package() {
 			-e "s%\@TERMUX_CACHE_DIR\@%${TERMUX_CACHE_DIR}%g" \
 			-e "s%\@TERMUX_HOME\@%${TERMUX_ANDROID_HOME}%g" \
 			-e "s%\@TERMUX_PREFIX\@%${TERMUX_PREFIX}%g" \
+			-e "s%\@TERMUX_PREFIX_CLASSICAL\@%${TERMUX_PREFIX_CLASSICAL}%g" \
 			"$patch" | patch --silent -p1
 	done
 	shopt -u nullglob
diff --git a/scripts/build/termux_step_replace_guess_scripts.sh b/scripts/build/termux_step_replace_guess_scripts.sh
index cacb459eae..f7a2bf9df2 100644
--- a/scripts/build/termux_step_replace_guess_scripts.sh
+++ b/scripts/build/termux_step_replace_guess_scripts.sh
@@ -4,4 +4,11 @@ termux_step_replace_guess_scripts() {
 	cd "$TERMUX_PKG_SRCDIR"
 	find . -name config.sub -exec chmod u+w '{}' \; -exec cp "$TERMUX_SCRIPTDIR/scripts/config.sub" '{}' \;
 	find . -name config.guess -exec chmod u+w '{}' \; -exec cp "$TERMUX_SCRIPTDIR/scripts/config.guess" '{}' \;
+
+	if [ "$TERMUX_ON_DEVICE_BUILD" = "true" ] && [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		local list_files=$(grep -s -r -l '^#!.*/bin/' $TERMUX_PKG_SRCDIR)
+		if [ -n "$list_files" ]; then
+			sed -i "s|#\!.*/bin/|#\!$TERMUX_PREFIX_CLASSICAL/bin/|" $list_files
+		fi
+	fi
 }
diff --git a/scripts/build/termux_step_setup_build_folders.sh b/scripts/build/termux_step_setup_build_folders.sh
index da3a1e7c98..8c11ca9eeb 100644
--- a/scripts/build/termux_step_setup_build_folders.sh
+++ b/scripts/build/termux_step_setup_build_folders.sh
@@ -11,7 +11,7 @@ termux_step_setup_build_folders() {
 		   [ "$TERMUX_ON_DEVICE_BUILD" = false ]; then
 		# Remove all previously extracted/built files from
 		# $TERMUX_PREFIX:
-		rm -rf $TERMUX_PREFIX
+		rm -fr $TERMUX_PREFIX_CLASSICAL
 		rm -f $TERMUX_BUILT_PACKAGES_DIRECTORY/*
 	fi
 
@@ -34,6 +34,11 @@ termux_step_setup_build_folders() {
 		 "$TERMUX_PKG_PACKAGEDIR" \
 		 "$TERMUX_PKG_TMPDIR" \
 		 "$TERMUX_PKG_CACHEDIR" \
-		 "$TERMUX_PKG_MASSAGEDIR" \
-		 $TERMUX_PREFIX/{bin,etc,lib,libexec,share,share/LICENSES,tmp,include}
+		 "$TERMUX_PKG_MASSAGEDIR"
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+		mkdir -p $TERMUX_PREFIX/{bin,etc,lib,libexec,share,share/LICENSES,tmp,include}
+	elif [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		mkdir -p $TERMUX_PREFIX/{bin,etc,lib,share,share/LICENSES,include}
+		mkdir -p $TERMUX_PREFIX_CLASSICAL/{bin,etc,tmp}
+	fi
 }
diff --git a/scripts/build/termux_step_setup_cgct_environment.sh b/scripts/build/termux_step_setup_cgct_environment.sh
new file mode 100644
index 0000000000..a939985bbc
--- /dev/null
+++ b/scripts/build/termux_step_setup_cgct_environment.sh
@@ -0,0 +1,61 @@
+# Installing packages if necessary for the full operation of CGCT (main use: not in Termux devices)
+
+termux_step_setup_cgct_environment() {
+	[ "$TERMUX_ON_DEVICE_BUILD" = "true" ] && return
+
+	local REPO_NAME=""
+	for idx in ${!TERMUX_REPO_DISTRIBUTION[@]}; do
+		if [ "${TERMUX_REPO_DISTRIBUTION[$idx]}" = "gpkg-dev" ]; then
+			REPO_NAME=$(echo "${TERMUX_REPO_URL[$idx]}" | sed -e 's%https://%%g' -e 's%http://%%g' -e 's%/%-%g')
+			if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+				REPO_NAME+="-${TERMUX_REPO_DISTRIBUTION[$idx]}-Release"
+			elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+				REPO_NAME+="-json"
+			fi
+			break
+		fi
+	done
+	if [ -z "$REPO_NAME" ]; then
+		termux_error_exit "Could not find 'gpkg-dev' repo"
+	fi
+
+	for PKG in glibc linux-api-headers-glibc; do
+		local PKG_DIR=$(ls ${TERMUX_SCRIPTDIR}/*/${PKG}/build.sh 2> /dev/null || \
+			ls ${TERMUX_SCRIPTDIR}/*/${PKG/-glibc/}/build.sh 2> /dev/null)
+		if [ -z "$PKG_DIR" ]; then
+			termux_error_exit "Could not find build.sh file for package '${PKG}'"
+		fi
+		read DEP_ARCH DEP_VERSION DEP_VERSION_PAC <<< $(termux_extract_dep_info $PKG "${PKG_DIR/'/build.sh'/}")
+
+		if ! package__is_package_version_built "$PKG" "$DEP_VERSION"; then
+			[ ! "$TERMUX_QUIET_BUILD" = "true" ] && echo "Installing '${PKG}' for the CGCT tool environment."
+
+			if [ ! -f "${TERMUX_COMMON_CACHEDIR}-${DEP_ARCH}/${REPO_NAME}" ]; then
+				TERMUX_INSTALL_DEPS=true termux_get_repo_files
+			fi
+
+			if ! termux_download_deb_pac $PKG $DEP_ARCH $DEP_VERSION $DEP_VERSION_PAC; then
+				termux_error_exit "Failed to download package '${PKG}'"
+			fi
+
+			[ ! "$TERMUX_QUIET_BUILD" = true ] && echo "extracting $PKG to $TERMUX_COMMON_CACHEDIR-$DEP_ARCH..."
+			(
+				cd $TERMUX_COMMON_CACHEDIR-$DEP_ARCH
+				if [ "$TERMUX_REPO_PKG_FORMAT" = "debian" ]; then
+					ar x ${PKG}_${DEP_VERSION}_${DEP_ARCH}.deb data.tar.xz
+					if tar -tf data.tar.xz|grep "^./$">/dev/null; then
+						tar -xf data.tar.xz --strip-components=1 \
+							--no-overwrite-dir -C /
+					else
+						tar -xf data.tar.xz --no-overwrite-dir -C /
+					fi
+				elif [ "$TERMUX_REPO_PKG_FORMAT" = "pacman" ]; then
+					tar -xJf "${PKG}-${DEP_VERSION_PAC}-${DEP_ARCH}.pkg.tar.xz" \
+						--force-local --no-overwrite-dir -C / data
+				fi
+			)
+			mkdir -p $TERMUX_BUILT_PACKAGES_DIRECTORY
+			echo "$DEP_VERSION" > "$TERMUX_BUILT_PACKAGES_DIRECTORY/$PKG"
+		fi
+	done
+}
diff --git a/scripts/build/termux_step_setup_toolchain.sh b/scripts/build/termux_step_setup_toolchain.sh
index 0ffed5a85f..f36c709a77 100644
--- a/scripts/build/termux_step_setup_toolchain.sh
+++ b/scripts/build/termux_step_setup_toolchain.sh
@@ -1,17 +1,26 @@
 termux_step_setup_toolchain() {
-	TERMUX_STANDALONE_TOOLCHAIN="$TERMUX_COMMON_CACHEDIR/android-r${TERMUX_NDK_VERSION}-api-${TERMUX_PKG_API_LEVEL}"
-	[ "$TERMUX_PKG_METAPACKAGE" = "true" ] && return
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+		TERMUX_STANDALONE_TOOLCHAIN="$TERMUX_COMMON_CACHEDIR/android-r${TERMUX_NDK_VERSION}-api-${TERMUX_PKG_API_LEVEL}"
+		[ "$TERMUX_PKG_METAPACKAGE" = "true" ] && return
 
-	# Bump TERMUX_STANDALONE_TOOLCHAIN if a change is made in
-	# toolchain setup to ensure that everyone gets an updated
-	# toolchain
-	if [ "${TERMUX_NDK_VERSION}" = 25c ]; then
-		TERMUX_STANDALONE_TOOLCHAIN+="-v2"
-		termux_setup_toolchain_25c
-	elif [ "${TERMUX_NDK_VERSION}" = 23c ]; then
-		TERMUX_STANDALONE_TOOLCHAIN+="-v5"
-		termux_setup_toolchain_23c
-	else
-		termux_error_exit "We do not have a setup_toolchain function for NDK version $TERMUX_NDK_VERSION"
+		# Bump TERMUX_STANDALONE_TOOLCHAIN if a change is made in
+		# toolchain setup to ensure that everyone gets an updated
+		# toolchain
+		if [ "${TERMUX_NDK_VERSION}" = 25c ]; then
+			TERMUX_STANDALONE_TOOLCHAIN+="-v2"
+			termux_setup_toolchain_25c
+		elif [ "${TERMUX_NDK_VERSION}" = 23c ]; then
+			TERMUX_STANDALONE_TOOLCHAIN+="-v5"
+			termux_setup_toolchain_23c
+		else
+			termux_error_exit "We do not have a setup_toolchain function for NDK version $TERMUX_NDK_VERSION"
+		fi
+	elif [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		if [ "$TERMUX_ON_DEVICE_BUILD" = "true" ]; then
+			TERMUX_STANDALONE_TOOLCHAIN="$TERMUX_PREFIX"
+		else
+			TERMUX_STANDALONE_TOOLCHAIN="${CGCT_DIR}/${TERMUX_ARCH}"
+		fi
+		termux_setup_toolchain_gnu
 	fi
 }
diff --git a/scripts/build/termux_step_setup_variables.sh b/scripts/build/termux_step_setup_variables.sh
index e925be6c30..e48ca2465c 100644
--- a/scripts/build/termux_step_setup_variables.sh
+++ b/scripts/build/termux_step_setup_variables.sh
@@ -11,6 +11,7 @@ termux_step_setup_variables() {
 	: "${TERMUX_CONTINUE_BUILD:="false"}"
 	: "${TERMUX_QUIET_BUILD:="false"}"
 	: "${TERMUX_SKIP_DEPCHECK:="false"}"
+	: "${TERMUX_GLOBAL_LIBRARY:="false"}"
 	: "${TERMUX_TOPDIR:="$HOME/.termux-build"}"
 	: "${TERMUX_PACMAN_PACKAGE_COMPRESSION:="xz"}"
 
@@ -28,15 +29,29 @@ termux_step_setup_variables() {
 		*) termux_error_exit "Unsupported package format \"${TERMUX_PACKAGE_FORMAT-}\". Only 'debian' and 'pacman' formats are supported";;
 	esac
 
+	# Default package library base
+	if [ -z "${TERMUX_PACKAGE_LIBRARY-}" ]; then
+		export TERMUX_PACKAGE_LIBRARY="bionic"
+	fi
+
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		export TERMUX_PREFIX="$TERMUX_PREFIX/glibc"
+		if ! package__is_package_name_have_glibc_prefix "$TERMUX_PKG_NAME"; then
+			TERMUX_PKG_NAME="${TERMUX_PKG_NAME}-glibc"
+		fi
+	fi
+
 	if [ "$TERMUX_ON_DEVICE_BUILD" = "true" ]; then
 		# For on-device builds cross-compiling is not supported so we can
 		# store information about built packages under $TERMUX_TOPDIR.
 		TERMUX_BUILT_PACKAGES_DIRECTORY="$TERMUX_TOPDIR/.built-packages"
 		TERMUX_NO_CLEAN="true"
 
-		# On-device builds without termux-exec are unsupported.
-		if ! grep -q "${TERMUX_PREFIX}/lib/libtermux-exec.so" <<< "${LD_PRELOAD-x}"; then
-			termux_error_exit "On-device builds without termux-exec are not supported."
+		if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+			# On-device builds without termux-exec are unsupported.
+			if ! grep -q "${TERMUX_PREFIX}/lib/libtermux-exec.so" <<< "${LD_PRELOAD-x}"; then
+				termux_error_exit "On-device builds without termux-exec are not supported."
+			fi
 		fi
 	else
 		TERMUX_BUILT_PACKAGES_DIRECTORY="/data/data/.built-packages"
@@ -51,15 +66,47 @@ termux_step_setup_variables() {
 		TERMUX_ARCH_BITS=32
 	fi
 
-	TERMUX_HOST_PLATFORM="${TERMUX_ARCH}-linux-android"
-	if [ "$TERMUX_ARCH" = "arm" ]; then TERMUX_HOST_PLATFORM="${TERMUX_HOST_PLATFORM}eabi"; fi
-
-	if [ "$TERMUX_ON_DEVICE_BUILD" = "false" ] && [ ! -d "$NDK" ]; then
-		termux_error_exit 'NDK not pointing at a directory!'
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+		TERMUX_HOST_PLATFORM="${TERMUX_ARCH}-linux-android"
+	else
+		TERMUX_HOST_PLATFORM="${TERMUX_ARCH}-linux-gnu"
+	fi
+	if [ "$TERMUX_ARCH" = "arm" ]; then
+		TERMUX_HOST_PLATFORM="${TERMUX_HOST_PLATFORM}eabi"
+		if [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+			TERMUX_HOST_PLATFORM="${TERMUX_HOST_PLATFORM}hf"
+		fi
 	fi
 
-	if [ "$TERMUX_ON_DEVICE_BUILD" = "false" ] && ! grep -s -q "Pkg.Revision = $TERMUX_NDK_VERSION_NUM" "$NDK/source.properties"; then
-		termux_error_exit "Wrong NDK version - we need $TERMUX_NDK_VERSION"
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+		if [ "$TERMUX_ON_DEVICE_BUILD" = "false" ] && [ ! -d "$NDK" ]; then
+			termux_error_exit 'NDK not pointing at a directory!'
+		fi
+
+		if [ "$TERMUX_ON_DEVICE_BUILD" = "false" ] && ! grep -s -q "Pkg.Revision = $TERMUX_NDK_VERSION_NUM" "$NDK/source.properties"; then
+			termux_error_exit "Wrong NDK version - we need $TERMUX_NDK_VERSION"
+		fi
+	elif [ "$TERMUX_PACKAGE_LIBRARY" = "glibc" ]; then
+		if [ "$TERMUX_ON_DEVICE_BUILD" = "true" ]; then
+			if [ -n "${LD_PRELOAD-}" ]; then
+				unset LD_PRELOAD
+			fi
+			if ! $(echo "$PATH" | grep -q "$TERMUX_PREFIX"); then
+				if [ -d "${TERMUX_PREFIX}/bin" ]; then
+					export PATH="${TERMUX_PREFIX}/bin:${PATH}"
+				else
+					termux_error_exit "Glibc components are not installed, run './scripts/setup-termux-glibc.sh'"
+				fi
+			fi
+		else
+			if ! $(echo "$PATH" | grep -q "${CGCT_DIR}/${TERMUX_ARCH}/bin"); then
+				if [ -d "${CGCT_DIR}/${TERMUX_ARCH}/bin" ]; then
+					export PATH="${CGCT_DIR}/${TERMUX_ARCH}/bin:${PATH}"
+				else
+					termux_error_exit "The cgct tools were not found, run './scripts/setup-cgct.sh'"
+				fi
+			fi
+		fi
 	fi
 
 	# The build tuple that may be given to --build configure flag:
diff --git a/scripts/build/termux_step_start_build.sh b/scripts/build/termux_step_start_build.sh
index 870d9e3541..353b1db1dc 100644
--- a/scripts/build/termux_step_start_build.sh
+++ b/scripts/build/termux_step_start_build.sh
@@ -88,29 +88,31 @@ termux_step_start_build() {
 		termux_error_exit "Package '$TERMUX_PKG_NAME' is not available for on-device builds."
 	fi
 
-	if [ "$TERMUX_ON_DEVICE_BUILD" = "true" ]; then
-		case "$TERMUX_APP_PACKAGE_MANAGER" in
-			"apt") apt install -y termux-elf-cleaner;;
-			"pacman") pacman -S termux-elf-cleaner --needed --noconfirm;;
-		esac
-		TERMUX_ELF_CLEANER="$(command -v termux-elf-cleaner)"
-	else
-		local TERMUX_ELF_CLEANER_VERSION
-		TERMUX_ELF_CLEANER_VERSION=$(bash -c ". $TERMUX_SCRIPTDIR/packages/termux-elf-cleaner/build.sh; echo \$TERMUX_PKG_VERSION")
-		termux_download \
-			"https://github.com/termux/termux-elf-cleaner/releases/download/v${TERMUX_ELF_CLEANER_VERSION}/termux-elf-cleaner" \
-			"$TERMUX_ELF_CLEANER" \
-			7c29143b9cffb3a9a580f39a7966b2bb36c5fc099da6f4c98dcdedacb14f08a2
-		chmod u+x "$TERMUX_ELF_CLEANER"
-	fi
-
-	# Some packages search for libutil, libpthread and librt even
-	# though this functionality is provided by libc.  Provide
-	# library stubs so that such configure checks succeed.
-	mkdir -p "$TERMUX_PREFIX/lib"
-	for lib in libutil.so libpthread.so librt.so; do
-		if [ ! -f $TERMUX_PREFIX/lib/$lib ]; then
-			echo 'INPUT(-lc)' > $TERMUX_PREFIX/lib/$lib
+	if [ "$TERMUX_PACKAGE_LIBRARY" = "bionic" ]; then
+		if [ "$TERMUX_ON_DEVICE_BUILD" = "true" ]; then
+			case "$TERMUX_APP_PACKAGE_MANAGER" in
+				"apt") apt install -y termux-elf-cleaner;;
+				"pacman") pacman -S termux-elf-cleaner --needed --noconfirm;;
+			esac
+			TERMUX_ELF_CLEANER="$(command -v termux-elf-cleaner)"
+		else
+			local TERMUX_ELF_CLEANER_VERSION
+			TERMUX_ELF_CLEANER_VERSION=$(bash -c ". $TERMUX_SCRIPTDIR/packages/termux-elf-cleaner/build.sh; echo \$TERMUX_PKG_VERSION")
+			termux_download \
+				"https://github.com/termux/termux-elf-cleaner/releases/download/v${TERMUX_ELF_CLEANER_VERSION}/termux-elf-cleaner" \
+				"$TERMUX_ELF_CLEANER" \
+				7c29143b9cffb3a9a580f39a7966b2bb36c5fc099da6f4c98dcdedacb14f08a2
+			chmod u+x "$TERMUX_ELF_CLEANER"
 		fi
-	done
+
+		# Some packages search for libutil, libpthread and librt even
+		# though this functionality is provided by libc.  Provide
+		# library stubs so that such configure checks succeed.
+		mkdir -p "$TERMUX_PREFIX/lib"
+		for lib in libutil.so libpthread.so librt.so; do
+			if [ ! -f $TERMUX_PREFIX/lib/$lib ]; then
+				echo 'INPUT(-lc)' > $TERMUX_PREFIX/lib/$lib
+			fi
+		done
+	fi
 }
diff --git a/scripts/build/toolchain/termux_setup_toolchain_gnu.sh b/scripts/build/toolchain/termux_setup_toolchain_gnu.sh
new file mode 100644
index 0000000000..8da29694ed
--- /dev/null
+++ b/scripts/build/toolchain/termux_setup_toolchain_gnu.sh
@@ -0,0 +1,43 @@
+termux_setup_toolchain_gnu() {
+	export CFLAGS="-O2 -pipe -fno-plt -fexceptions -Wp,-D_FORTIFY_SOURCE=2 -Wformat -Werror=format-security -fstack-clash-protection"
+	export CPPFLAGS=""
+	export LDFLAGS=""
+
+	export CC=$TERMUX_HOST_PLATFORM-gcc
+	export CXX=$TERMUX_HOST_PLATFORM-g++
+	export CPP="$TERMUX_HOST_PLATFORM-c++ -E"
+	export AR=$TERMUX_HOST_PLATFORM-gcc-ar
+	export RANLIB=$TERMUX_HOST_PLATFORM-gcc-ranlib
+	export NM=$TERMUX_HOST_PLATFORM-gcc-nm
+	export LD=ld
+	export AS=as
+	export OBJCOPY=objcopy
+	export OBJDUMP=objdump
+	export READELF=readelf
+	export STRIP=strip
+	if [ "$TERMUX_ON_DEVICE_BUILD" = "true" ]; then
+		export CXXFILT=c++filt
+	else
+		export CXXFILT=$TERMUX_HOST_PLATFORM-c++filt
+	fi
+
+	if [ "$TERMUX_ARCH" = "aarch64" ]; then
+		CFLAGS+=" -march=armv8-a"
+	elif [ "$TERMUX_ARCH" = "arm" ]; then
+		CFLAGS+=" -march=armv7-a -mfloat-abi=hard -mfpu=neon"
+	elif [ "$TERMUX_ARCH" = "x86_64" ]; then
+		CFLAGS+=" -march=x86-64"
+	elif [ "$TERMUX_ARCH" = "i686" ]; then
+		CFLAGS+=" -march=i686"
+	fi
+
+	case "$TERMUX_ARCH" in
+		"aarch64"|"arm") CFLAGS+=" -fstack-protector-strong";;
+		"x86_64"|"i686") CFLAGS+=" -mtune=generic -fcf-protection";;
+	esac
+
+	export PKG_CONFIG=pkg-config
+	export PKGCONFIG=$PKG_CONFIG
+
+	export CXXFLAGS="$CFLAGS -Wp,-D_GLIBCXX_ASSERTIONS"
+}
diff --git a/scripts/buildorder.py b/scripts/buildorder.py
index a48bfb7949..42adb12b98 100755
--- a/scripts/buildorder.py
+++ b/scripts/buildorder.py
@@ -84,6 +84,8 @@ class TermuxPackage(object):
     def __init__(self, dir_path, fast_build_mode):
         self.dir = dir_path
         self.name = os.path.basename(self.dir)
+        if "gpkg" in self.dir.split("/")[-2].split("-") and "glibc" not in self.name.split("-"):
+            self.name += "-glibc"
 
         # search package build.sh
         build_sh_path = os.path.join(self.dir, 'build.sh')
@@ -94,7 +96,7 @@ class TermuxPackage(object):
         self.antideps = parse_build_file_antidependencies(build_sh_path)
         self.excluded_arches = parse_build_file_excluded_arches(build_sh_path)
 
-        if os.getenv('TERMUX_ON_DEVICE_BUILD') == "true":
+        if os.getenv('TERMUX_ON_DEVICE_BUILD') == "true" and os.getenv('TERMUX_PACKAGE_LIBRARY') == "bionic":
             always_deps = ['libc++']
             for dependency_name in always_deps:
                 if dependency_name not in self.deps and self.name not in always_deps:
@@ -134,7 +136,11 @@ class TermuxPackage(object):
         "All the dependencies of the package, both direct and indirect."
         result = []
         for dependency_name in sorted(self.deps):
-            dependency_package = pkgs_map[dependency_name]
+            if os.getenv('TERMUX_GLOBAL_LIBRARY') == "true" and os.getenv('TERMUX_PACKAGE_LIBRARY') == "glibc" and "glibc" not in dependency_name.split("-"):
+                dependency_name+="-glibc"
+                dependency_package = pkgs_map[dependency_name if dependency_name in pkgs_map else dependency_name.replace("-glibc", "")]
+            else:
+                dependency_package = pkgs_map[dependency_name]
             result += dependency_package.recursive_dependencies(pkgs_map)
             result += [dependency_package]
         return unique_everseen(result)
@@ -182,7 +188,10 @@ def read_packages_from_directories(directories, fast_build_mode, full_buildmode)
         # Ignore directories and get all folders from repo.json file
         with open ('repo.json') as f:
             data = json.load(f)
-        directories = [d for d in data.keys()]
+        directories = []
+        for d in data.keys():
+            if d != "pkg_format":
+                directories.append(d)
 
     for package_dir in directories:
         for pkgdir_name in sorted(os.listdir(package_dir)):
@@ -278,6 +287,8 @@ def generate_target_buildorder(target_path, pkgs_map, fast_build_mode):
         target_path = target_path[:-1]
 
     package_name = os.path.basename(target_path)
+    if "gpkg" in target_path.split("/")[-2].split("-") and "glibc" not in package_name.split("-"):
+        package_name += "-glibc"
     package = pkgs_map[package_name]
     # Do not depend on any sub package
     if fast_build_mode:
@@ -328,7 +339,10 @@ def main():
         build_order = generate_target_buildorder(package, pkgs_map, fast_build_mode)
 
     for pkg in build_order:
-        print("%-30s %s" % (pkg.name, pkg.dir))
+        pkg_name = pkg.name
+        if os.getenv('TERMUX_GLOBAL_LIBRARY') == "true" and os.getenv('TERMUX_PACKAGE_LIBRARY') == "glibc" and "glibc" not in pkg_name.split("-"):
+            pkg_name += "-glibc"
+        print("%-30s %s" % (pkg_name, pkg.dir))
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/lint-packages.sh b/scripts/lint-packages.sh
index c31001c3f5..65e7ccfcd1 100755
--- a/scripts/lint-packages.sh
+++ b/scripts/lint-packages.sh
@@ -481,7 +481,7 @@ linter_main() {
 }
 
 if [ $# -eq 0 ]; then
-	for repo_dir in $(jq --raw-output 'keys | .[]' $REPO_DIR/repo.json); do
+	for repo_dir in $(jq --raw-output 'del(.pkg_format) | keys | .[]' $REPO_DIR/repo.json); do
 		linter_main $repo_dir/*/build.sh
 	done || exit 1
 else
diff --git a/scripts/properties.sh b/scripts/properties.sh
index 82e85758b7..deb580d47d 100644
--- a/scripts/properties.sh
+++ b/scripts/properties.sh
@@ -35,25 +35,35 @@ TERMUX_BASE_DIR="/data/data/${TERMUX_APP_PACKAGE}/files"
 TERMUX_CACHE_DIR="/data/data/${TERMUX_APP_PACKAGE}/cache"
 TERMUX_ANDROID_HOME="${TERMUX_BASE_DIR}/home"
 TERMUX_APPS_DIR="${TERMUX_BASE_DIR}/apps"
-TERMUX_PREFIX="${TERMUX_BASE_DIR}/usr"
+TERMUX_PREFIX_CLASSICAL="${TERMUX_BASE_DIR}/usr"
+TERMUX_PREFIX="${TERMUX_PREFIX_CLASSICAL}"
+
+# Path to CGCT tools
+export CGCT_DIR="/data/data/${TERMUX_APP_PACKAGE}/cgct"
 
 # Package name for the packages hosted on the repo.
 # This must only equal TERMUX_APP_PACKAGE if using custom repo that
 # has packages that were built with same package name.
 TERMUX_REPO_PACKAGE="com.termux"
 
+# Getting the format of packages in repos
+TERMUX_REPO_PKG_FORMAT=$(jq -r '.pkg_format' ${TERMUX_SCRIPTDIR}/repo.json)
+if [ "$TERMUX_REPO_PKG_FORMAT" = "null" ]; then
+	TERMUX_REPO_PKG_FORMAT="debian"
+fi
+
 # Termux repo urls.
 TERMUX_REPO_URL=()
 TERMUX_REPO_DISTRIBUTION=()
 TERMUX_REPO_COMPONENT=()
 
-for url in $(jq -r '.[] | .url' ${TERMUX_SCRIPTDIR}/repo.json); do
+for url in $(jq -r 'del(.pkg_format) | .[] | .url' ${TERMUX_SCRIPTDIR}/repo.json); do
 	TERMUX_REPO_URL+=("$url")
 done
-for distribution in $(jq -r '.[] | .distribution' ${TERMUX_SCRIPTDIR}/repo.json); do
+for distribution in $(jq -r 'del(.pkg_format) | .[] | .distribution' ${TERMUX_SCRIPTDIR}/repo.json); do
 	TERMUX_REPO_DISTRIBUTION+=("$distribution")
 done
-for component in $(jq -r '.[] | .component' ${TERMUX_SCRIPTDIR}/repo.json); do
+for component in $(jq -r 'del(.pkg_format) | .[] | .component' ${TERMUX_SCRIPTDIR}/repo.json); do
 	TERMUX_REPO_COMPONENT+=("$component")
 done
 
diff --git a/scripts/setup-cgct.sh b/scripts/setup-cgct.sh
index 4f4cc956d5..db24aa7745 100755
--- a/scripts/setup-cgct.sh
+++ b/scripts/setup-cgct.sh
@@ -5,7 +5,6 @@
 
 set -e -u
 
-: "${CGCT_DIR:="/data/data/${TERMUX_APP_PACKAGE}/cgct"}"
 ARCH="x86_64"
 REPO_URL="https://service.termux-pacman.dev/gpkg-dev/${ARCH}"
 VERSION_OF_CBT="2.41-0"
diff --git a/scripts/setup-offline-bundle.sh b/scripts/setup-offline-bundle.sh
index 4f495382ab..9ead5314a5 100755
--- a/scripts/setup-offline-bundle.sh
+++ b/scripts/setup-offline-bundle.sh
@@ -75,7 +75,7 @@ mkdir -p "$TERMUX_PKG_TMPDIR"
 rm -rf "${TERMUX_PKG_TMPDIR}"
 
 # Package sources.
-for repo_path in $(jq --raw-output 'keys | .[]' $TERMUX_SCRIPTDIR/repo.json); do
+for repo_path in $(jq --raw-output 'del(.pkg_format) | keys | .[]' $TERMUX_SCRIPTDIR/repo.json); do
 	for p in "$TERMUX_SCRIPTDIR"/$repo_path/*; do
 		(
 			. "$TERMUX_SCRIPTDIR"/scripts/build/get_source/termux_step_get_source.sh
diff --git a/scripts/setup-termux-glibc.sh b/scripts/setup-termux-glibc.sh
new file mode 100755
index 0000000000..ef96c79b04
--- /dev/null
+++ b/scripts/setup-termux-glibc.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+. $(dirname "$(realpath "$0")")/properties.sh
+source "$TERMUX_PREFIX/bin/termux-setup-package-manager" || true
+
+if [ "$TERMUX_APP_PACKAGE_MANAGER" = "apt" ]; then
+	echo "Error: apt does not have glibc packages"
+	exit 1
+elif [ "$TERMUX_APP_PACKAGE_MANAGER" = "pacman" ]; then
+	if $(pacman-conf -r gpkg-dev &> /dev/null); then
+		pacman -Syu gpkg-dev --needed --noconfirm
+	else
+		echo "Error: no glibc packages repo found (only gpkg-dev at the moment)"
+		exit 1
+	fi
+else
+	echo "Error: no package manager defined"
+	exit 1
+fi
diff --git a/scripts/updates/utils/termux_pkg_upgrade_version.sh b/scripts/updates/utils/termux_pkg_upgrade_version.sh
index 00ede998fa..8d0d6764e7 100755
--- a/scripts/updates/utils/termux_pkg_upgrade_version.sh
+++ b/scripts/updates/utils/termux_pkg_upgrade_version.sh
@@ -64,7 +64,7 @@ termux_pkg_upgrade_version() {
 
 		echo "INFO: Trying to build package."
 
-		for repo_path in $(jq --raw-output 'keys | .[]' ${TERMUX_SCRIPTDIR}/repo.json); do
+		for repo_path in $(jq --raw-output 'del(.pkg_format) | keys | .[]' ${TERMUX_SCRIPTDIR}/repo.json); do
 			_buildsh_path="${TERMUX_SCRIPTDIR}/${repo_path}/${TERMUX_PKG_NAME}/build.sh"
 			repo=$(jq --raw-output ".\"${repo_path}\".name" ${TERMUX_SCRIPTDIR}/repo.json)
 			repo=${repo#"termux-"}
diff --git a/scripts/utils/package/package.sh b/scripts/utils/package/package.sh
index a23a5b1aee..be36b9126d 100644
--- a/scripts/utils/package/package.sh
+++ b/scripts/utils/package/package.sh
@@ -47,3 +47,68 @@ package__is_package_version_built() {
 	[ -e "$TERMUX_BUILT_PACKAGES_DIRECTORY/$1" ] && [ "$(cat "$TERMUX_BUILT_PACKAGES_DIRECTORY/$1")" = "$2" ]
 	return $?
 }
+
+
+
+##
+# Check if the package name has a prefix called `glibc`.
+# .
+# .
+# **Parameters:**
+# `package_name` - The package name for the package.
+# .
+# **Returns:**
+# Returns `0` if have, otherwise `1`.
+# .
+# .
+# package__is_package_name_have_glibc_prefix `package_name`
+##
+package__is_package_name_have_glibc_prefix() {
+	for __pkgname_part in ${1//-/ }; do
+		if [ "${__pkgname_part}" = "glibc" ]; then
+			return 0
+		fi
+	done
+	return 1
+}
+
+
+
+##
+# Adds the prefix `-glibc` to the list of package names if necessary.
+# .
+# .
+# **Parameters:**
+# `package_list` - List of package names (eg `TERMUX_PKG_DEPENDS`).
+# .
+# **Returns:**
+# Returns a modified list of package names.
+# .
+# .
+# package__add_prefix_glibc_to_package_names `package_list`
+##
+package__add_prefix_glibc_to_package_names() {
+	local packages=""
+	for __pkg in ${1//,/}; do
+		if ! $(echo "${__pkg}" | grep -q -e '(' -e ')' -e '|'); then
+			if [ "${packages: -1}" != "|" ]; then
+				packages+=","
+			fi
+			packages+=" "
+			if ! package__is_package_name_have_glibc_prefix "${__pkg}"; then
+				# Maybe glibc-based static packages won't exist :/
+				#if $(echo "${__pkg}" | grep -q -e "-static"); then
+				#	packages+="${__pkg/-static/}-glibc-static"
+				#else
+				#	packages+="${__pkg}-glibc"
+				#fi
+				packages+="${__pkg/-static/}-glibc"
+			else
+				packages+="${__pkg}"
+			fi
+		else
+			packages+=" ${__pkg}"
+		fi
+	done
+	echo "${packages:2}"
+}