diff --git a/toolchain/scripts/common_vars.sh b/toolchain/scripts/common_vars.sh
index fd003555c3b..637e37f5bf6 100755
--- a/toolchain/scripts/common_vars.sh
+++ b/toolchain/scripts/common_vars.sh
@@ -13,9 +13,20 @@ SETUPFILE=${SETUPFILE:-"${INSTALLDIR}/setup"}
 ARCH_FILE_TEMPLATE=${ARCH_FILE_TEMPLATE:-"${SCRIPTDIR}/arch_base.tmpl"}
 VERSION_FILE=${VERSION_FILE:-"${SCRIPTDIR}/VERSION"}
 
-# system arch gotten from OpenBLAS prebuild
-OPENBLAS_ARCH=${OPENBLAS_ARCH:-''}
-OPENBLAS_LIBCORE=${OPENBLAS_LIBCORE:-''}
+# host architecture
+SYSTEM_ARCH=${SYSTEM_ARCH:-"$(uname -m)"}
+case "${SYSTEM_ARCH}" in
+  x86_64 | amd64)
+    SYSTEM_ARCH="x86_64"
+    ;;
+  aarch64 | arm64)
+    SYSTEM_ARCH="arm64"
+    ;;
+  *)
+    # Keep other architectures as reported by uname.
+    ;;
+esac
+export SYSTEM_ARCH
 
 # search paths
 SYS_INCLUDE_PATH=${SYS_INCLUDE_PATH:-'/usr/local/include:/usr/include'}
diff --git a/toolchain/scripts/get_openblas_arch.sh b/toolchain/scripts/get_openblas_arch.sh
deleted file mode 100755
index 79f40805e97..00000000000
--- a/toolchain/scripts/get_openblas_arch.sh
+++ /dev/null
@@ -1,76 +0,0 @@
-#!/bin/bash -e
-
-# TODO: Review and if possible fix shellcheck errors.
-# shellcheck disable=all
-
-[ "${BASH_SOURCE[0]}" ] && SCRIPT_NAME="${BASH_SOURCE[0]}" || SCRIPT_NAME=$0
-SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_NAME")" && pwd -P)"
-
-# Load centralized version management
-source "${SCRIPT_DIR}"/package_versions.sh
-
-# Load OpenBLAS package variables with version suffix support
-# Check for version configuration from environment or individual package setting
-version_suffix=""
-if [[ -n "${ABACUS_TOOLCHAIN_PACKAGE_VERSIONS}" ]]; then
-    # Check for individual package version override
-    if echo "${ABACUS_TOOLCHAIN_PACKAGE_VERSIONS}" | grep -q "openblas:alt"; then
-        version_suffix="alt"
-    elif echo "${ABACUS_TOOLCHAIN_PACKAGE_VERSIONS}" | grep -q "openblas:main"; then
-        version_suffix="main"
-    fi
-fi
-# Fall back to global version suffix if no individual setting
-if [[ -z "$version_suffix" && -n "${ABACUS_TOOLCHAIN_VERSION_SUFFIX}" ]]; then
-    version_suffix="${ABACUS_TOOLCHAIN_VERSION_SUFFIX}"
-fi
-# Load package variables with appropriate version
-load_package_vars "openblas" "$version_suffix"
-openblas_pkg="OpenBLAS-${openblas_ver}.tar.gz"
-
-find_openblas_dir() {
-    local __dir=''
-    for __dir in *OpenBLAS*; do
-        if [ -d "$__dir" ]; then
-            echo "$__dir"
-            return
-        fi
-    done
-    echo ''
-}
-
-source "${SCRIPT_DIR}"/common_vars.sh
-source "${SCRIPT_DIR}"/tool_kit.sh
-source "${SCRIPT_DIR}"/signal_trap.sh
-source "${INSTALLDIR}"/toolchain.conf
-source "${INSTALLDIR}"/toolchain.env
-
-! [ -d "${BUILDDIR}" ] && mkdir -p "${BUILDDIR}"
-cd "${BUILDDIR}"
-
-echo "==================== Getting proc arch info using OpenBLAS tools ===================="
-url="https://codeload.github.com/OpenMathLib/OpenBLAS/tar.gz/v${openblas_ver}"
-retrieve_package "${openblas_sha256}" "${openblas_pkg}" "${url}"
-# if toolchain run in pack-run mode, do exit
-if [ "${PACK_RUN}" = "__TRUE__" ]; then
-    echo "--pack-run mode specified, skip arch detection"
-    exit 0
-fi
-tar -xzf ${openblas_pkg}
-openblas_dir="$(find_openblas_dir)"
-openblas_conf="${openblas_dir}/Makefile.conf"
-# try find Makefile.config, if not then generate one with make lapack_prebuild
-if ! [ -f "$openblas_conf" ]; then
-    cd "$openblas_dir"
-    make lapack_prebuild
-    cd ..
-fi
-OPENBLAS_LIBCORE="$(grep 'LIBCORE=' $openblas_conf | cut -f2 -d=)"
-OPENBLAS_ARCH="$(grep 'ARCH=' $openblas_conf | cut -f2 -d=)"
-echo "OpenBLAS detected LIBCORE = $OPENBLAS_LIBCORE"
-echo "OpenBLAS detected ARCH    = $OPENBLAS_ARCH"
-# output setup file
-cat << EOF > "${BUILDDIR}/openblas_arch"
-export OPENBLAS_LIBCORE="${OPENBLAS_LIBCORE}"
-export OPENBLAS_ARCH="${OPENBLAS_ARCH}"
-EOF
diff --git a/toolchain/scripts/package_versions.sh b/toolchain/scripts/package_versions.sh
index 6cef74e63fd..322c93c0829 100644
--- a/toolchain/scripts/package_versions.sh
+++ b/toolchain/scripts/package_versions.sh
@@ -139,24 +139,10 @@ load_package_vars() {
             fi
             ;;
         "cmake")
-            # Determine architecture for SHA256 selection
-            local arch_suffix=""
-            if [ "${OPENBLAS_ARCH}" = "arm64" ]; then
-                if [ "$(uname -s)" = "Darwin" ]; then
-                    arch_suffix="_macos"
-                else
-                    arch_suffix="_aarch64"
-                fi
-            else
-                arch_suffix="_x86_64"
-            fi
-            
             if [ "${version_suffix}" = "alt" ]; then
                 cmake_ver="${cmake_alt_ver}"
-                eval "cmake_sha256=\${cmake_alt_sha256${arch_suffix}}"
             else
                 cmake_ver="${cmake_main_ver}"
-                eval "cmake_sha256=\${cmake_main_sha256${arch_suffix}}"
             fi
             ;;
         "openmpi")
diff --git a/toolchain/scripts/stage0/install_cmake.sh b/toolchain/scripts/stage0/install_cmake.sh
index 1084e757f3e..55d82b82b2f 100755
--- a/toolchain/scripts/stage0/install_cmake.sh
+++ b/toolchain/scripts/stage0/install_cmake.sh
@@ -29,41 +29,12 @@ if [[ -z "$version_suffix" && -n "${ABACUS_TOOLCHAIN_VERSION_SUFFIX}" ]]; then
     version_suffix="${ABACUS_TOOLCHAIN_VERSION_SUFFIX}"
 fi
 
-# Ensure OPENBLAS_ARCH is set before loading package variables
-# This is needed for architecture-specific SHA256 selection
-# In --pack-run mode, openblas_arch file may contain empty values, so we need fallback
-if [ -f "${BUILDDIR}/openblas_arch" ]; then
-    source "${BUILDDIR}/openblas_arch"
-fi
-
-if [ -z "${OPENBLAS_ARCH}" ]; then
-    case "$(uname -m)" in
-        x86_64|amd64) OPENBLAS_ARCH="x86_64" ;;
-        aarch64|arm64) OPENBLAS_ARCH="arm64" ;;
-        *) OPENBLAS_ARCH="x86_64" ;;  # default fallback
-    esac
-    echo "OPENBLAS_ARCH not set, using fallback: ${OPENBLAS_ARCH}"
-fi
-
-# Export OPENBLAS_ARCH to ensure it's available throughout the script
-export OPENBLAS_ARCH
-
 # Load package variables with appropriate version
 load_package_vars "cmake" "$version_suffix"
 
 source "${INSTALLDIR}"/toolchain.conf
 source "${INSTALLDIR}"/toolchain.env
 
-# Re-apply architecture detection if OPENBLAS_ARCH is still empty after sourcing
-if [ -z "${OPENBLAS_ARCH}" ]; then
-    case "$(uname -m)" in
-        x86_64|amd64) OPENBLAS_ARCH="x86_64" ;;
-        aarch64|arm64) OPENBLAS_ARCH="arm64" ;;
-        *) OPENBLAS_ARCH="x86_64" ;;  # default fallback
-    esac
-    export OPENBLAS_ARCH
-fi
-
 [ -f "${BUILDDIR}/setup_cmake" ] && rm "${BUILDDIR}/setup_cmake"
 
 ! [ -d "${BUILDDIR}" ] && mkdir -p "${BUILDDIR}"
@@ -71,22 +42,33 @@ cd "${BUILDDIR}"
 case "${with_cmake}" in
     __INSTALL__)
         echo "==================== Installing CMake ===================="
-        if [ "${OPENBLAS_ARCH}" = "arm64" ]; then
-            if [ "$(uname -s)" = "Darwin" ]; then
+        case "$(uname -s):${SYSTEM_ARCH}" in
+            Darwin:x86_64 | Darwin:arm64)
                 cmake_arch="macos-universal"
-            elif [ "$(uname -s)" = "Linux" ]; then
+                cmake_checksum_arch="macos"
+                ;;
+            Linux:x86_64)
+                cmake_arch="linux-x86_64"
+                cmake_checksum_arch="x86_64"
+                ;;
+            Linux:arm64)
                 cmake_arch="linux-aarch64"
-            else
+                cmake_checksum_arch="aarch64"
+                ;;
+            *)
                 report_error ${LINENO} \
-                    "cmake installation for ARCH=${OPENBLAS_ARCH} under $(uname -s) is not supported. You can try to use the system installation using the flag --with-cmake=system instead."
-            fi
-        elif [ "${OPENBLAS_ARCH}" = "x86_64" ]; then
-            cmake_arch="linux-x86_64"
+                    "cmake installation for ARCH=${SYSTEM_ARCH} under $(uname -s) is not supported. You can try to use the system installation using the flag \"--with-cmake=system\" instead."
+                exit 1
+                ;;
+        esac
+
+        if [ "${version_suffix}" = "alt" ]; then
+            cmake_checksum_var="cmake_alt_sha256_${cmake_checksum_arch}"
         else
-            report_error ${LINENO} \
-                "cmake installation for ARCH=${OPENBLAS_ARCH} is not supported. You can try to use the system installation using the flag --with-cmake=system instead."
-            exit 1
+            cmake_checksum_var="cmake_main_sha256_${cmake_checksum_arch}"
         fi
+        cmake_sha256="${!cmake_checksum_var}"
+
         pkg_install_dir="${INSTALLDIR}/cmake-${cmake_ver}"
         #pkg_install_dir="${HOME}/apps/cmake/${cmake_ver}"
         install_lock_file="${pkg_install_dir}/install_successful"
diff --git a/toolchain/scripts/stage0/setup_buildtools.sh b/toolchain/scripts/stage0/setup_buildtools.sh
index 924282ed41e..095f5d677a3 100755
--- a/toolchain/scripts/stage0/setup_buildtools.sh
+++ b/toolchain/scripts/stage0/setup_buildtools.sh
@@ -61,10 +61,6 @@ else
 fi
 export LDFLAGS="${TSANFLAGS}"
 
-# get system arch information using OpenBLAS prebuild
-${SCRIPTDIR}/get_openblas_arch.sh
-load "${BUILDDIR}/openblas_arch"
-
 write_toolchain_env "${INSTALLDIR}"
 
 #EOF
diff --git a/toolchain/scripts/stage1/install_openmpi.sh b/toolchain/scripts/stage1/install_openmpi.sh
index e798cc7325e..f9700776bd4 100755
--- a/toolchain/scripts/stage1/install_openmpi.sh
+++ b/toolchain/scripts/stage1/install_openmpi.sh
@@ -61,7 +61,7 @@ case "${with_openmpi}" in
             [ -d openmpi-${openmpi_ver} ] && rm -rf openmpi-${openmpi_ver}
             tar -xjf ${openmpi_pkg}
             cd openmpi-${openmpi_ver}
-            if [ "${OPENBLAS_ARCH}" = "x86_64" ]; then
+            if [ "${SYSTEM_ARCH}" = "x86_64" ]; then
                 # can have issue with older glibc libraries, in which case
                 # we need to add the -fgnu89-inline to CFLAGS. We can check
                 # the version of glibc using ldd --version, as ldd is part of
diff --git a/toolchain/scripts/stage2/install_mkl.sh b/toolchain/scripts/stage2/install_mkl.sh
index d0ff9f99239..62d9f0bd6ef 100755
--- a/toolchain/scripts/stage2/install_mkl.sh
+++ b/toolchain/scripts/stage2/install_mkl.sh
@@ -57,7 +57,7 @@ case "${with_mkl}" in
         ;;
 esac
 if [ "${with_mkl}" != "__DONTUSE__" ]; then
-    case ${OPENBLAS_ARCH} in
+    case "${SYSTEM_ARCH}" in
         x86_64)
             mkl_arch_dir="intel64"
             MKL_CFLAGS="-m64"
@@ -67,7 +67,7 @@ if [ "${with_mkl}" != "__DONTUSE__" ]; then
             MKL_CFLAGS="-m32"
             ;;
         *)
-            report_error $LINENO "MKL only supports intel64 (x86_64) and ia32 (i386) at the moment, and your arch obtained from OpenBLAS prebuild is $OPENBLAS_ARCH"
+            report_error $LINENO "MKL only supports intel64 (x86_64) and ia32 (i386) at the moment, but the detected architecture is ${SYSTEM_ARCH}"
             exit 1
             ;;
     esac
diff --git a/toolchain/scripts/stage2/install_openblas.sh b/toolchain/scripts/stage2/install_openblas.sh
index 6c6a8a40866..1cc874fb761 100755
--- a/toolchain/scripts/stage2/install_openblas.sh
+++ b/toolchain/scripts/stage2/install_openblas.sh
@@ -60,62 +60,38 @@ case "${with_openblas}" in
             [ -d OpenBLAS-${openblas_ver} ] && rm -rf OpenBLAS-${openblas_ver}
             tar -zxf ${openblas_pkg}
             cd OpenBLAS-${openblas_ver}
-
-            # First attempt to make openblas using auto detected
-            # TARGET, if this fails, then make with forced
-            # TARGET=NEHALEM
+            # Build OpenBLAS with DYNAMIC_ARCH unless native architecture is requested.
+            # If the latter fails, then build with DYNAMIC_ARCH.
             #
             # wrt NUM_THREADS=64: this is what the most common Linux distros seem to choose atm
             #                     for a good compromise between memory usage and scalability
             #
             # Unfortunately, NO_SHARED=1 breaks ScaLAPACK build.
-            case "${TARGET_CPU}" in
-                "generic")
-                    TARGET="NEHALEM"
-                    ;;
-                "native")
-                    TARGET=${OPENBLAS_LIBCORE}
-                    ;;
-                "broadwell" | "skylake")
-                    TARGET="HASWELL"
-                    ;;
-                "skylake-avx512")
-                    TARGET="SKYLAKEX"
-                    ;;
-                *)
-                    TARGET=${TARGET_CPU}
-                    ;;
-            esac
-            TARGET=$(echo ${TARGET} | tr '[:lower:]' '[:upper:]')
-            echo "Installing OpenBLAS library for target ${TARGET}"
-            (
-                make -j $(get_nprocs) \
-                    MAKE_NB_JOBS=0 \
-                    TARGET=${TARGET} \
-                    NUM_THREADS=64 \
-                    USE_THREAD=1 \
-                    USE_OPENMP=1 \
-                    NO_AFFINITY=1 \
-                    CC="${CC}" \
-                    FC="${FC}" \
-                    PREFIX="${pkg_install_dir}" \
-                    > make.log 2>&1 || tail -n ${LOG_LINES} make.log
-            ) || (
-                make -j $(get_nprocs) \
-                    MAKE_NB_JOBS=0 \
-                    TARGET=NEHALEM \
-                    NUM_THREADS=64 \
-                    USE_THREAD=1 \
-                    USE_OPENMP=1 \
-                    NO_AFFINITY=1 \
-                    CC="${CC}" \
-                    FC="${FC}" \
-                    PREFIX="${pkg_install_dir}" \
-                    > make.nehalem.log 2>&1 || tail -n ${LOG_LINES} make.nehalem.log
-            )
-            make -j $(get_nprocs) \
+            BUILD_DYNAMIC=0
+            if [ "native" != "${TARGET_CPU}" ]; then
+              BUILD_DYNAMIC=1
+            fi
+            if [ "${BUILD_DYNAMIC}" = "0" ]; then
+              echo "Installing OpenBLAS library for native target"
+              if ! make -j "$(get_nprocs)" \
+                MAKE_NB_JOBS=0 \
+                NUM_THREADS=64 \
+                USE_THREAD=1 \
+                USE_OPENMP=1 \
+                NO_AFFINITY=1 \
+                CC="${CC}" \
+                FC="${FC}" \
+                PREFIX="${pkg_install_dir}" \
+                > make.log 2>&1; then
+                tail -n "${LOG_LINES}" make.log
+                BUILD_DYNAMIC=1
+              fi
+            fi
+            if [ "${BUILD_DYNAMIC}" != "0" ]; then
+              echo "Installing OpenBLAS library for dynamic target"
+              if ! make -j "$(get_nprocs)" \
                 MAKE_NB_JOBS=0 \
-                TARGET=${TARGET} \
+                DYNAMIC_ARCH=1 \
                 NUM_THREADS=64 \
                 USE_THREAD=1 \
                 USE_OPENMP=1 \
@@ -123,7 +99,11 @@ case "${with_openblas}" in
                 CC="${CC}" \
                 FC="${FC}" \
                 PREFIX="${pkg_install_dir}" \
-                install > install.log 2>&1 || tail -n ${LOG_LINES} install.log
+                install > install.log 2>&1; then
+                tail -n "${LOG_LINES}" install.log
+                exit 1
+              fi
+            fi
             cd ..
             write_checksums "${install_lock_file}" "${SCRIPT_DIR}/stage2/$(basename ${SCRIPT_NAME})"
         fi
diff --git a/toolchain/scripts/stage3/install_elpa.sh b/toolchain/scripts/stage3/install_elpa.sh
index c0df99c2780..58b4b8bc2a1 100755
--- a/toolchain/scripts/stage3/install_elpa.sh
+++ b/toolchain/scripts/stage3/install_elpa.sh
@@ -93,7 +93,7 @@ case "$with_elpa" in
             SSE4_flag=""
             config_flags="--disable-avx-kernels --disable-avx2-kernels --disable-avx512-kernels --disable-sse-kernels --disable-sse-assembly-kernels"
             if [ "${TARGET_CPU}" = "native" ]; then
-                if [ -f /proc/cpuinfo ] && [ "${OPENBLAS_ARCH}" = "x86_64" ]; then
+                if [ -f /proc/cpuinfo ] && [ "${SYSTEM_ARCH}" = "x86_64" ]; then
                     has_AVX=$(grep '\bavx\b' /proc/cpuinfo 1> /dev/null && echo 'yes' || echo 'no')
                     [ "${has_AVX}" = "yes" ] && AVX_flag="-mavx" || AVX_flag=""
                     has_AVX2=$(grep '\bavx2\b' /proc/cpuinfo 1> /dev/null && echo 'yes' || echo 'no')