diff --git a/.github/workflows/CICD.yml b/.github/workflows/CICD.yml
index 66ee23168b8..ad12ede6833 100644
--- a/.github/workflows/CICD.yml
+++ b/.github/workflows/CICD.yml
@@ -15,7 +15,11 @@ env:
   # * style job configuration
   STYLE_FAIL_ON_FAULT: true ## (bool) fail the build if a style job contains a fault (error or warning); may be overridden on a per-job basis
 
-on: [push, pull_request]
+on:
+  pull_request:
+  push:
+    branches:
+      - main
 
 permissions:
   contents: read # to fetch code (actions/checkout)
@@ -133,7 +137,7 @@ jobs:
       shell: bash
       run: |
         RUSTDOCFLAGS="-Dwarnings" cargo doc  ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-deps --workspace --document-private-items
-    - uses: DavidAnson/markdownlint-cli2-action@v13
+    - uses: DavidAnson/markdownlint-cli2-action@v15
       with:
         fix: "true"
         globs: |
@@ -204,7 +208,7 @@ jobs:
         echo "## dependency list"
         ## * using the 'stable' toolchain is necessary to avoid "unexpected '--filter-platform'" errors
         RUSTUP_TOOLCHAIN=stable cargo fetch --locked --quiet
-        RUSTUP_TOOLCHAIN=stable cargo tree --all --locked --no-dev-dependencies --no-indent ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} | grep -vE "$PWD" | sort --unique
+        RUSTUP_TOOLCHAIN=stable cargo tree --no-dedupe --locked -e=no-dev --prefix=none ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} | grep -vE "$PWD" | sort --unique
     - name: Test
       run: cargo nextest run --hide-progress-bar --profile ci ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -p uucore -p coreutils
       env:
@@ -391,14 +395,14 @@ jobs:
               --arg multisize "$SIZE_MULTI" \
               '{($date): { sha: $sha, size: $size, multisize: $multisize, }}' > size-result.json
     - name: Download the previous individual size result
-      uses: dawidd6/action-download-artifact@v2
+      uses: dawidd6/action-download-artifact@v3
       with:
         workflow: CICD.yml
         name: individual-size-result
         repo: uutils/coreutils
         path: dl
     - name: Download the previous size result
-      uses: dawidd6/action-download-artifact@v2
+      uses: dawidd6/action-download-artifact@v3
       with:
         workflow: CICD.yml
         name: size-result
@@ -435,12 +439,12 @@ jobs:
         previous_multisize=$(cat dl/size-result.json | jq -r '.[] | .multisize')
         check 'multicall binary' "$multisize" "$previous_multisize" 'size-result.json'
     - name: Upload the individual size result
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: individual-size-result
         path: individual-size-result.json
     - name: Upload the size result
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: size-result
         path: size-result.json
@@ -464,11 +468,13 @@ jobs:
           # - { os , target , cargo-options , features , use-cross , toolchain, skip-tests }
           - { os: ubuntu-latest  , target: arm-unknown-linux-gnueabihf, features: feat_os_unix_gnueabihf, use-cross: use-cross, }
           - { os: ubuntu-latest  , target: aarch64-unknown-linux-gnu   , features: feat_os_unix_gnueabihf , use-cross: use-cross }
+          - { os: ubuntu-latest  , target: aarch64-unknown-linux-musl  , features: feat_os_unix_musl      , use-cross: use-cross }
           # - { os: ubuntu-latest  , target: x86_64-unknown-linux-gnu    , features: feat_selinux           , use-cross: use-cross }
           - { os: ubuntu-latest  , target: i686-unknown-linux-gnu      , features: feat_os_unix           , use-cross: use-cross }
           - { os: ubuntu-latest  , target: i686-unknown-linux-musl     , features: feat_os_unix_musl      , use-cross: use-cross }
           - { os: ubuntu-latest  , target: x86_64-unknown-linux-gnu    , features: feat_os_unix           , use-cross: use-cross }
           - { os: ubuntu-latest  , target: x86_64-unknown-linux-musl   , features: feat_os_unix_musl      , use-cross: use-cross }
+          - { os: ubuntu-latest  , target: x86_64-unknown-redox        , features: feat_os_unix_redox     , use-cross: redoxer  , skip-tests: true }
           - { os: macos-latest   , target: aarch64-apple-darwin        , features: feat_os_macos          , use-cross: use-cross, skip-tests: true} # Hopefully github provides free M1 runners soon...
           - { os: macos-latest   , target: x86_64-apple-darwin         , features: feat_os_macos }
           - { os: windows-latest , target: i686-pc-windows-msvc        , features: feat_os_windows }
@@ -521,7 +527,13 @@ jobs:
           i686-*) TARGET_ARCH=i686 ;;
           x86_64-*) TARGET_ARCH=x86_64 ;;
         esac;
-        unset TARGET_OS ; case '${{ matrix.job.target }}' in *-linux-*) TARGET_OS=linux ;; *-apple-*) TARGET_OS=macos ;; *-windows-*) TARGET_OS=windows ;; esac;
+        unset TARGET_OS
+        case '${{ matrix.job.target }}' in
+          *-linux-*) TARGET_OS=linux ;;
+          *-apple-*) TARGET_OS=macos ;;
+          *-windows-*) TARGET_OS=windows ;;
+          *-redox*) TARGET_OS=redox ;;
+        esac
         outputs TARGET_ARCH TARGET_OS
         # package name
         PKG_suffix=".tar.gz" ; case '${{ matrix.job.target }}' in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
@@ -556,8 +568,19 @@ jobs:
         if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features=${{ matrix.job.features }}' ; fi
         outputs CARGO_FEATURES_OPTION
         # * CARGO_CMD
-        CARGO_CMD='cross' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) CARGO_CMD='cargo' ;; esac;
+        CARGO_CMD='cross'
+        CARGO_CMD_OPTIONS='+${{ env.RUST_MIN_SRV }}'
+        case '${{ matrix.job.use-cross }}' in
+          ''|0|f|false|n|no)
+            CARGO_CMD='cargo'
+            ;;
+          redoxer)
+            CARGO_CMD='redoxer'
+            CARGO_CMD_OPTIONS=''
+            ;;
+        esac
         outputs CARGO_CMD
+        outputs CARGO_CMD_OPTIONS
         # ** pass needed environment into `cross` container (iff `cross` not already configured via "Cross.toml")
         if [ "${CARGO_CMD}" = 'cross' ] && [ ! -e "Cross.toml" ] ; then
           printf "[build.env]\npassthrough = [\"CI\", \"RUST_BACKTRACE\", \"CARGO_TERM_COLOR\"]\n" > Cross.toml
@@ -568,7 +591,7 @@ jobs:
         # * executable for `strip`?
         STRIP="strip"
         case ${{ matrix.job.target }} in
-          aarch64-*-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;;
+          aarch64-*-linux-*) STRIP="aarch64-linux-gnu-strip" ;;
           arm-*-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;;
           *-pc-windows-msvc) STRIP="" ;;
         esac;
@@ -589,8 +612,23 @@ jobs:
       run: |
         ## Install/setup prerequisites
         case '${{ matrix.job.target }}' in
-          arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
-          aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install gcc-aarch64-linux-gnu ;;
+          arm-unknown-linux-gnueabihf) 
+            sudo apt-get -y update
+            sudo apt-get -y install gcc-arm-linux-gnueabihf
+          ;;
+          aarch64-unknown-linux-*) 
+            sudo apt-get -y update
+            sudo apt-get -y install gcc-aarch64-linux-gnu
+          ;;
+          *-redox*) 
+            sudo apt-get -y update
+            sudo apt-get -y install fuse3 libfuse-dev
+          ;;
+          # Update binutils if MinGW due to https://github.com/rust-lang/rust/issues/112368
+          x86_64-pc-windows-gnu)
+            C:/msys64/usr/bin/pacman.exe -Syu --needed mingw-w64-x86_64-gcc --noconfirm
+            echo "C:\msys64\mingw64\bin" >> $GITHUB_PATH
+          ;;
         esac
         case '${{ matrix.job.os }}' in
           macos-latest) brew install coreutils ;; # needed for testing
@@ -610,6 +648,10 @@ jobs:
             echo "foo" > /home/runner/.plan
             ;;
         esac
+    - uses: taiki-e/install-action@v2
+      if: steps.vars.outputs.CARGO_CMD == 'redoxer'
+      with:
+        tool: redoxer@0.2.37
     - name: Initialize toolchain-dependent workflow variables
       id: dep_vars
       shell: bash
@@ -643,19 +685,19 @@ jobs:
         # dependencies
         echo "## dependency list"
         cargo fetch --locked --quiet
-        cargo tree --locked --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --all --no-dev-dependencies --no-indent | grep -vE "$PWD" | sort --unique
+        cargo tree --locked --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-dedupe -e=no-dev --prefix=none | grep -vE "$PWD" | sort --unique
     - name: Build
       shell: bash
       run: |
         ## Build
-        ${{ steps.vars.outputs.CARGO_CMD }} +${{ env.RUST_MIN_SRV }} build --release \
+        ${{ steps.vars.outputs.CARGO_CMD }} ${{ steps.vars.outputs.CARGO_CMD_OPTIONS }} build --release \
         --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
     - name: Test
       if: matrix.job.skip-tests != true
       shell: bash
       run: |
         ## Test
-        ${{ steps.vars.outputs.CARGO_CMD }} +${{ env.RUST_MIN_SRV }} test --target=${{ matrix.job.target }} \
+        ${{ steps.vars.outputs.CARGO_CMD }} ${{ steps.vars.outputs.CARGO_CMD_OPTIONS }} test --target=${{ matrix.job.target }} \
         ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
       env:
         RUST_BACKTRACE: "1"
@@ -664,12 +706,12 @@ jobs:
       shell: bash
       run: |
         ## Test individual utilities
-        ${{ steps.vars.outputs.CARGO_CMD }} +${{ env.RUST_MIN_SRV }} test --target=${{ matrix.job.target }} \
+        ${{ steps.vars.outputs.CARGO_CMD }} ${{ steps.vars.outputs.CARGO_CMD_OPTIONS }} test --target=${{ matrix.job.target }} \
         ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
       env:
         RUST_BACKTRACE: "1"
     - name: Archive executable artifacts
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}
         path: target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}
@@ -780,17 +822,17 @@ jobs:
           HASH=$(sha1sum '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}' | cut --delim=" " -f 1)
           echo "HASH=${HASH}" >> $GITHUB_OUTPUT
     - name: Reserve SHA1/ID of 'test-summary'
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: "${{ steps.summary.outputs.HASH }}"
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Reserve test results summary
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
-        name: test-summary
+        name: busybox-test-summary
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Upload json results
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: busybox-result.json
         path: ${{ steps.vars.outputs.TEST_SUMMARY_FILE }}
@@ -868,17 +910,17 @@ jobs:
         HASH=$(sha1sum '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}' | cut --delim=" " -f 1)
           echo "HASH=${HASH}" >> $GITHUB_OUTPUT
     - name: Reserve SHA1/ID of 'test-summary'
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: "${{ steps.summary.outputs.HASH }}"
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Reserve test results summary
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
-        name: test-summary
+        name: toybox-test-summary
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Upload json results
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: toybox-result.json
         path: ${{ steps.vars.outputs.TEST_SUMMARY_FILE }}
@@ -956,6 +998,10 @@ jobs:
             echo "foo" > /home/runner/.plan
             ;;
         esac
+        case '${{ matrix.job.os }}' in
+          # Update binutils if MinGW due to https://github.com/rust-lang/rust/issues/112368
+          windows-latest) C:/msys64/usr/bin/pacman.exe -Syu --needed mingw-w64-x86_64-gcc --noconfirm ; echo "C:\msys64\mingw64\bin" >> $GITHUB_PATH ;;
+        esac
     - name: Initialize toolchain-dependent workflow variables
       id: dep_vars
       shell: bash
@@ -966,16 +1012,8 @@ jobs:
         UTILITY_LIST="$(./util/show-utils.sh ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }})"
         CARGO_UTILITY_LIST_OPTIONS="$(for u in ${UTILITY_LIST}; do echo -n "-puu_${u} "; done;)"
         outputs CARGO_UTILITY_LIST_OPTIONS
-    - name: Test uucore
-      run: cargo nextest run --profile ci --hide-progress-bar -p uucore
-      env:
-        RUSTC_WRAPPER: ""
-        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
-        RUSTDOCFLAGS: "-Cpanic=abort"
-        RUST_BACKTRACE: "1"
-        # RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
     - name: Test
-      run: cargo nextest run --profile ci --hide-progress-bar ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+      run: cargo nextest run --profile ci --hide-progress-bar ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -p uucore -p coreutils
       env:
         RUSTC_WRAPPER: ""
         RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
diff --git a/.github/workflows/FixPR.yml b/.github/workflows/FixPR.yml
index 7f5e5234d8b..e837b354687 100644
--- a/.github/workflows/FixPR.yml
+++ b/.github/workflows/FixPR.yml
@@ -63,7 +63,7 @@ jobs:
         echo "## dependency list"
         cargo fetch --locked --quiet
         ## * using the 'stable' toolchain is necessary to avoid "unexpected '--filter-platform'" errors
-        RUSTUP_TOOLCHAIN=stable cargo tree --locked --all --no-dev-dependencies --no-indent --features ${{ matrix.job.features }} | grep -vE "$PWD" | sort --unique
+        RUSTUP_TOOLCHAIN=stable cargo tree --locked --no-dedupe -e=no-dev --prefix=none --features ${{ matrix.job.features }} | grep -vE "$PWD" | sort --unique
     - name: Commit any changes (to '${{ env.BRANCH_TARGET }}')
       uses: EndBug/add-and-commit@v9
       with:
diff --git a/.github/workflows/GnuTests.yml b/.github/workflows/GnuTests.yml
index 61f30eba4c1..89fa5a7da50 100644
--- a/.github/workflows/GnuTests.yml
+++ b/.github/workflows/GnuTests.yml
@@ -9,7 +9,11 @@ name: GnuTests
 
 # * note: to run a single test => `REPO/util/run-gnu-test.sh PATH/TO/TEST/SCRIPT`
 
-on: [push, pull_request]
+on:
+  pull_request:
+  push:
+    branches:
+      - main
 
 permissions:
   contents: read
@@ -26,7 +30,7 @@ jobs:
       contents: read  # for actions/checkout to fetch code
       pull-requests: read  # for dawidd6/action-download-artifact to query commit hash
     name: Run GNU tests
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - name: Initialize workflow variables
       id: vars
@@ -73,7 +77,7 @@ jobs:
         ref: ${{ steps.vars.outputs.repo_GNU_ref }}
         submodules: recursive
     - name: Retrieve reference artifacts
-      uses: dawidd6/action-download-artifact@v2
+      uses: dawidd6/action-download-artifact@v3
       # ref: <https://github.com/dawidd6/action-download-artifact>
       continue-on-error: true ## don't break the build for missing reference artifacts (may be expired or just not generated yet)
       with:
@@ -112,7 +116,7 @@ jobs:
       run: |
         ## Build binaries
         cd '${{ steps.vars.outputs.path_UUTILS }}'
-        bash util/build-gnu.sh
+        bash util/build-gnu.sh --release-build
     - name: Run GNU tests
       shell: bash
       run: |
@@ -175,22 +179,22 @@ jobs:
           # Compress logs before upload (fails otherwise)
           gzip ${{ steps.vars.outputs.TEST_LOGS_GLOB }}
     - name: Reserve SHA1/ID of 'test-summary'
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: "${{ steps.summary.outputs.HASH }}"
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Reserve test results summary
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: test-summary
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Reserve test logs
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: test-logs
         path: "${{ steps.vars.outputs.TEST_LOGS_GLOB }}"
     - name: Upload full json results
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: gnu-full-result.json
         path: ${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}
@@ -200,6 +204,7 @@ jobs:
         ## Compare test failures VS reference
         have_new_failures=""
         REF_LOG_FILE='${{ steps.vars.outputs.path_reference }}/test-logs/test-suite.log'
+        ROOT_REF_LOG_FILE='${{ steps.vars.outputs.path_reference }}/test-logs/test-suite-root.log'
         REF_SUMMARY_FILE='${{ steps.vars.outputs.path_reference }}/test-summary/gnu-result.json'
         REPO_DEFAULT_BRANCH='${{ steps.vars.outputs.repo_default_branch }}'
         path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
@@ -219,72 +224,96 @@ jobs:
         rm -f ${COMMENT_LOG}
         touch ${COMMENT_LOG}
 
-        if test -f "${REF_LOG_FILE}"; then
-          echo "Reference SHA1/ID: $(sha1sum -- "${REF_SUMMARY_FILE}")"
-          REF_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" "${REF_LOG_FILE}" | sort)
-          NEW_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" '${{ steps.vars.outputs.path_GNU_tests }}/test-suite.log' | sort)
-          REF_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" "${REF_LOG_FILE}" | sort)
-          NEW_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" '${{ steps.vars.outputs.path_GNU_tests }}/test-suite.log' | sort)
-          for LINE in ${REF_FAILING}
-          do
-            if ! grep -Fxq ${LINE}<<<"${NEW_FAILING}"; then
-              if ! grep ${LINE} ${IGNORE_INTERMITTENT}
+        compare_tests() {
+          local new_log_file=$1
+          local ref_log_file=$2
+          local test_type=$3  # "standard" or "root"
+
+          if test -f "${ref_log_file}"; then
+            echo "Reference ${test_type} test log SHA1/ID: $(sha1sum -- "${ref_log_file}") - ${test_type}"
+            REF_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" "${ref_log_file}"| sort)
+            CURRENT_RUN_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" "${new_log_file}" | sort)
+            REF_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" "${ref_log_file}"| sort)
+            CURRENT_RUN_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" "${new_log_file}" | sort)
+            echo "Detailled information:"
+            echo "REF_ERROR = ${REF_ERROR}"
+            echo "CURRENT_RUN_ERROR = ${CURRENT_RUN_ERROR}"
+            echo "REF_FAILING = ${REF_FAILING}"
+            echo "CURRENT_RUN_FAILING = ${CURRENT_RUN_FAILING}"
+
+            # Compare failing and error tests
+            for LINE in ${CURRENT_RUN_FAILING}
+            do
+              if ! grep -Fxq ${LINE}<<<"${REF_FAILING}"
               then
-                MSG="Congrats! The gnu test ${LINE} is no longer failing!"
-                echo "::warning ::$MSG"
-                echo $MSG >> ${COMMENT_LOG}
-              else
-                MSG="Skipping an intermittent issue ${LINE}"
-                echo "::warning ::$MSG"
-                echo $MSG >> ${COMMENT_LOG}
-                echo ""
+                if ! grep ${LINE} ${IGNORE_INTERMITTENT}
+                then
+                  MSG="GNU test failed: ${LINE}. ${LINE} is passing on '${REPO_DEFAULT_BRANCH}'. Maybe you have to rebase?"
+                  echo "::error ::$MSG"
+                  echo $MSG >> ${COMMENT_LOG}
+                  have_new_failures="true"
+                else
+                  MSG="Skip an intermittent issue ${LINE} (fails in this run but passes in the 'main' branch)"
+                  echo "::warning ::$MSG"
+                  echo $MSG >> ${COMMENT_LOG}
+                  echo ""
+                fi
               fi
-            fi
-          done
-          for LINE in ${NEW_FAILING}
-          do
-            if ! grep -Fxq ${LINE}<<<"${REF_FAILING}"
-            then
-              if ! grep ${LINE} ${IGNORE_INTERMITTENT}
+            done
+
+            for LINE in ${REF_FAILING}
+            do
+              if ! grep -Fxq ${LINE}<<<"${CURRENT_RUN_FAILING}"
+              then
+                if ! grep ${LINE} ${IGNORE_INTERMITTENT}
+                then
+                  MSG="Congrats! The gnu test ${LINE} is no longer failing!"
+                  echo "::warning ::$MSG"
+                  echo $MSG >> ${COMMENT_LOG}
+                else
+                  MSG="Skipping an intermittent issue ${LINE} (passes in this run but fails in the 'main' branch)"
+                  echo "::warning ::$MSG"
+                  echo $MSG >> ${COMMENT_LOG}
+                  echo ""
+                fi
+              fi
+            done
+
+            for LINE in ${CURRENT_RUN_ERROR}
+            do
+              if ! grep -Fxq ${LINE}<<<"${REF_ERROR}"
               then
-                MSG="GNU test failed: ${LINE}. ${LINE} is passing on '${{ steps.vars.outputs.repo_default_branch }}'. Maybe you have to rebase?"
+                MSG="GNU test error: ${LINE}. ${LINE} is passing on '${REPO_DEFAULT_BRANCH}'. Maybe you have to rebase?"
                 echo "::error ::$MSG"
                 echo $MSG >> ${COMMENT_LOG}
                 have_new_failures="true"
-              else
-                MSG="Skip an intermittent issue ${LINE}"
+              fi
+            done
+
+            for LINE in ${REF_ERROR}
+            do
+              if ! grep -Fxq ${LINE}<<<"${CURRENT_RUN_ERROR}"
+              then
+                MSG="Congrats! The gnu test ${LINE} is no longer ERROR!"
                 echo "::warning ::$MSG"
                 echo $MSG >> ${COMMENT_LOG}
-                echo ""
               fi
-            fi
-          done
-          for LINE in ${REF_ERROR}
-          do
-            if ! grep -Fxq ${LINE}<<<"${NEW_ERROR}"; then
-              MSG="Congrats! The gnu test ${LINE} is no longer ERROR!"
-              echo "::warning ::$MSG"
-              echo $MSG >> ${COMMENT_LOG}
-            fi
-          done
-          for LINE in ${NEW_ERROR}
-          do
-            if ! grep -Fxq ${LINE}<<<"${REF_ERROR}"
-            then
-              MSG="GNU test error: ${LINE}. ${LINE} is passing on '${{ steps.vars.outputs.repo_default_branch }}'. Maybe you have to rebase?"
-              echo "::error ::$MSG"
-              echo $MSG >> ${COMMENT_LOG}
-              have_new_failures="true"
-            fi
-          done
+            done
+          else
+            echo "::warning ::Skipping ${test_type} test failure comparison; no prior reference test logs are available."
+          fi
+        }
+
+        # Compare standard tests
+        compare_tests '${{ steps.vars.outputs.path_GNU_tests }}/test-suite.log' "${REF_LOG_FILE}" "standard"
+
+        # Compare root tests
+        compare_tests '${{ steps.vars.outputs.path_GNU_tests }}/test-suite-root.log' "${ROOT_REF_LOG_FILE}" "root"
 
-        else
-          echo "::warning ::Skipping test failure comparison; no prior reference test logs are available."
-        fi
         if test -n "${have_new_failures}" ; then exit -1 ; fi
     - name: Upload comparison log (for GnuComment workflow)
       if: success() || failure() # run regardless of prior step success/failure
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: comment
         path: ${{ steps.vars.outputs.path_reference }}/comment/
@@ -304,7 +333,7 @@ jobs:
 
   gnu_coverage:
     name: Run GNU tests with coverage
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - name: Checkout code uutil
       uses: actions/checkout@v4
@@ -350,7 +379,7 @@ jobs:
       run: |
         ## Build binaries
         cd uutils
-        UU_MAKE_PROFILE=debug bash util/build-gnu.sh
+        bash util/build-gnu.sh
     - name: Run GNU tests
       run: bash uutils/util/run-gnu-test.sh
     - name: Generate coverage data (via `grcov`)
diff --git a/.github/workflows/android.yml b/.github/workflows/android.yml
index 5834aceffe8..86b5a89e83a 100644
--- a/.github/workflows/android.yml
+++ b/.github/workflows/android.yml
@@ -2,7 +2,12 @@ name: Android
 
 # spell-checker:ignore TERMUX reactivecircus Swatinem  noaudio pkill swiftshader dtolnay juliangruber
 
-on: [push, pull_request]
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
 
 permissions:
   contents: read # to fetch code (actions/checkout)
@@ -28,7 +33,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Restore AVD cache
-      uses: actions/cache/restore@v3
+      uses: actions/cache/restore@v4
       id: avd-cache
       with:
         path: |
@@ -47,12 +52,12 @@ jobs:
         ram-size: 2048M
         disk-size: 7GB
         force-avd-creation: true
-        emulator-options: -no-snapshot-load -noaudio -no-boot-anim -camera-back none
+        emulator-options: -no-window -no-snapshot-load -noaudio -no-boot-anim -camera-back none
         script: |
           util/android-commands.sh init "${{ matrix.arch }}" "${{ matrix.api-level }}" "${{ env.TERMUX }}"
     - name: Save AVD cache
       if: steps.avd-cache.outputs.cache-hit != 'true'
-      uses: actions/cache/save@v3
+      uses: actions/cache/save@v4
       with:
         path: |
           ~/.android/avd/*
@@ -68,7 +73,7 @@ jobs:
         trim: true
     - name: Restore rust cache
       id: rust-cache
-      uses: actions/cache/restore@v3
+      uses: actions/cache/restore@v4
       with:
         path: ~/__rust_cache__
         # The version vX at the end of the key is just a development version to avoid conflicts in
@@ -83,7 +88,7 @@ jobs:
         ram-size: 2048M
         disk-size: 7GB
         force-avd-creation: false
-        emulator-options: -no-snapshot-save -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none -snapshot ${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}
+        emulator-options: -no-window -no-snapshot-save -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none -snapshot ${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}
         # This is not a usual script. Every line is executed in a separate shell with `sh -c`. If
         # one of the lines returns with error the whole script is failed (like running a script with
         # set -e) and in consequences the other lines (shells) are not executed.
@@ -94,7 +99,7 @@ jobs:
           if [[ "${{ steps.rust-cache.outputs.cache-hit }}" != 'true' ]]; then util/android-commands.sh sync_image; fi; exit 0
     - name: Save rust cache
       if: steps.rust-cache.outputs.cache-hit != 'true'
-      uses: actions/cache/save@v3
+      uses: actions/cache/save@v4
       with:
         path: ~/__rust_cache__
         key: ${{ matrix.arch }}_${{ matrix.target}}_${{ steps.read_rustc_hash.outputs.content }}_${{ hashFiles('**/Cargo.toml', '**/Cargo.lock') }}_v3
diff --git a/.github/workflows/code-quality.yml b/.github/workflows/code-quality.yml
index 98691f34bc8..289830f8171 100644
--- a/.github/workflows/code-quality.yml
+++ b/.github/workflows/code-quality.yml
@@ -2,7 +2,11 @@ name: Code Quality
 
 # spell-checker:ignore TERMUX reactivecircus Swatinem  noaudio pkill swiftshader dtolnay juliangruber
 
-on: [push, pull_request]
+on:
+  pull_request:
+  push:
+    branches:
+      - main
 
 env:
   # * style job configuration
diff --git a/.github/workflows/freebsd.yml b/.github/workflows/freebsd.yml
index 5af3da320a7..25655f0917f 100644
--- a/.github/workflows/freebsd.yml
+++ b/.github/workflows/freebsd.yml
@@ -6,7 +6,11 @@ env:
   # * style job configuration
   STYLE_FAIL_ON_FAULT: true ## (bool) fail the build if a style job contains a fault (error or warning); may be overridden on a per-job basis
 
-on: [push, pull_request]
+on:
+  pull_request:
+  push:
+    branches:
+      - main
 
 permissions:
   contents: read # to fetch code (actions/checkout)
@@ -25,7 +29,7 @@ jobs:
       fail-fast: false
       matrix:
         job:
-          - { os: macos-12 , features: unix } ## GHA MacOS-11.0 VM won't have VirtualBox; refs: <https://github.com/actions/virtual-environments/issues/4060> , <https://github.com/actions/virtual-environments/pull/4010>
+          - { os: ubuntu-22.04 , features: unix }
     env:
       SCCACHE_GHA_ENABLED: "true"
       RUSTC_WRAPPER: "sccache"
@@ -35,11 +39,13 @@ jobs:
     - name: Run sccache-cache
       uses: mozilla-actions/sccache-action@v0.0.3
     - name: Prepare, build and test
-      uses: vmactions/freebsd-vm@v0.3.1
+      uses: vmactions/freebsd-vm@v1.0.5
       with:
         usesh: true
-        # We need jq to run show-utils.sh and bash to use inline shell string replacement
-        prepare: pkg install -y curl sudo jq bash
+        sync: rsync
+        copyback: false
+        # We need jq and GNU coreutils to run show-utils.sh and bash to use inline shell string replacement
+        prepare: pkg install -y curl sudo jq coreutils bash
         run: |
           ## Prepare, build, and test
           # implementation modelled after ref: <https://github.com/rust-lang/rustup/pull/2783>
@@ -48,11 +54,11 @@ jobs:
           #
           TEST_USER=tester
           REPO_NAME=${GITHUB_WORKSPACE##*/}
-          WORKSPACE_PARENT="/Users/runner/work/${REPO_NAME}"
+          WORKSPACE_PARENT="/home/runner/work/${REPO_NAME}"
           WORKSPACE="${WORKSPACE_PARENT}/${REPO_NAME}"
           #
           pw adduser -n ${TEST_USER} -d /root/ -g wheel -c "Coreutils user to build" -w random
-          chown -R ${TEST_USER}:wheel /root/ "/Users/runner/work/${REPO_NAME}"/
+          chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
           whoami
           #
           # Further work needs to be done in a sudo as we are changing users
@@ -114,7 +120,7 @@ jobs:
       fail-fast: false
       matrix:
         job:
-          - { os: macos-12 , features: unix } ## GHA MacOS-11.0 VM won't have VirtualBox; refs: <https://github.com/actions/virtual-environments/issues/4060> , <https://github.com/actions/virtual-environments/pull/4010>
+          - { os: ubuntu-22.04 , features: unix }
     env:
       mem: 4096
       SCCACHE_GHA_ENABLED: "true"
@@ -125,10 +131,11 @@ jobs:
     - name: Run sccache-cache
       uses: mozilla-actions/sccache-action@v0.0.3
     - name: Prepare, build and test
-      uses: vmactions/freebsd-vm@v0.3.1
+      uses: vmactions/freebsd-vm@v1.0.5
       with:
         usesh: true
-        # sync: sshfs
+        sync: rsync
+        copyback: false
         prepare: pkg install -y curl gmake sudo
         run: |
           ## Prepare, build, and test
@@ -141,12 +148,12 @@ jobs:
           #
           TEST_USER=tester
           REPO_NAME=${GITHUB_WORKSPACE##*/}
-          WORKSPACE_PARENT="/Users/runner/work/${REPO_NAME}"
+          WORKSPACE_PARENT="/home/runner/work/${REPO_NAME}"
           WORKSPACE="${WORKSPACE_PARENT}/${REPO_NAME}"
           #
           pw adduser -n ${TEST_USER} -d /root/ -g wheel -c "Coreutils user to build" -w random
           # chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
-          chown -R ${TEST_USER}:wheel /root/ "/Users/runner/work/${REPO_NAME}"/
+          chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
           whoami
           #
           # Further work needs to be done in a sudo as we are changing users
diff --git a/.github/workflows/fuzzing.yml b/.github/workflows/fuzzing.yml
index e7a9cb1e329..c60c01ff4be 100644
--- a/.github/workflows/fuzzing.yml
+++ b/.github/workflows/fuzzing.yml
@@ -2,7 +2,11 @@ name: Fuzzing
 
 # spell-checker:ignore fuzzer
 
-on: [push, pull_request]
+on:
+  pull_request:
+  push:
+    branches:
+      - main
 
 permissions:
   contents: read # to fetch code (actions/checkout)
@@ -32,21 +36,26 @@ jobs:
     needs: fuzz-build
     name: Run the fuzzers
     runs-on: ubuntu-latest
+    timeout-minutes: 5
     env:
       RUN_FOR: 60
     strategy:
       matrix:
         test-target:
-          [
-            fuzz_date,
-            fuzz_test,
-            fuzz_expr,
-            fuzz_parse_glob,
-            fuzz_parse_size,
-            fuzz_parse_time,
-            # adding more fuzz tests here.
-            # e.g. fuzz_test_a,
-          ]
+          - { name: fuzz_test, should_pass: true }
+          # https://github.com/uutils/coreutils/issues/5311
+          - { name: fuzz_date, should_pass: false }
+          - { name: fuzz_expr, should_pass: true }
+          - { name: fuzz_printf, should_pass: false }
+          - { name: fuzz_echo, should_pass: true }
+          - { name: fuzz_seq, should_pass: false }
+          - { name: fuzz_sort, should_pass: false }
+          - { name: fuzz_wc, should_pass: false }
+          - { name: fuzz_cut, should_pass: false }
+          - { name: fuzz_split, should_pass: false }
+          - { name: fuzz_parse_glob, should_pass: true }
+          - { name: fuzz_parse_size, should_pass: true }
+          - { name: fuzz_parse_time, should_pass: true }
     steps:
     - uses: actions/checkout@v4
     - uses: dtolnay/rust-toolchain@nightly
@@ -57,18 +66,19 @@ jobs:
         shared-key: "cargo-fuzz-cache-key"
         cache-directories: "fuzz/target"
     - name: Restore Cached Corpus
-      uses: actions/cache/restore@v3
+      uses: actions/cache/restore@v4
       with:
-        key: corpus-cache-${{ matrix.test-target }}
+        key: corpus-cache-${{ matrix.test-target.name }}
         path: |
-          fuzz/corpus/${{ matrix.test-target }}
-    - name: Run ${{ matrix.test-target }} for XX seconds
+          fuzz/corpus/${{ matrix.test-target.name }}
+    - name: Run ${{ matrix.test-target.name }} for XX seconds
       shell: bash
+      continue-on-error: ${{ !matrix.test-target.name.should_pass }}
       run: |
-        cargo +nightly fuzz run ${{ matrix.test-target }} -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+        cargo +nightly fuzz run ${{ matrix.test-target.name }} -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
     - name: Save Corpus Cache
-      uses: actions/cache/save@v3
+      uses: actions/cache/save@v4
       with:
-        key: corpus-cache-${{ matrix.test-target }}
+        key: corpus-cache-${{ matrix.test-target.name }}
         path: |
-          fuzz/corpus/${{ matrix.test-target }}
+          fuzz/corpus/${{ matrix.test-target.name }}
diff --git a/.github/workflows/ignore-intermittent.txt b/.github/workflows/ignore-intermittent.txt
index 759bd96eb8a..e163202a2ca 100644
--- a/.github/workflows/ignore-intermittent.txt
+++ b/.github/workflows/ignore-intermittent.txt
@@ -1,3 +1,3 @@
-tests/tail-2/inotify-dir-recreate
+tests/tail/inotify-dir-recreate
 tests/misc/timeout
 tests/rm/rm1
diff --git a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
index c004ea2f822..4a59ed094bd 100644
--- a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
+++ b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
@@ -37,6 +37,7 @@ aarch
 flac
 impls
 lzma
+loongarch
 
 # * names
 BusyBox
diff --git a/.vscode/cspell.dictionaries/jargon.wordlist.txt b/.vscode/cspell.dictionaries/jargon.wordlist.txt
index dca883dc804..20e26990f3b 100644
--- a/.vscode/cspell.dictionaries/jargon.wordlist.txt
+++ b/.vscode/cspell.dictionaries/jargon.wordlist.txt
@@ -42,6 +42,7 @@ fileio
 filesystem
 filesystems
 flamegraph
+fsxattr
 fullblock
 getfacl
 gibi
@@ -133,6 +134,7 @@ urand
 whitespace
 wordlist
 wordlists
+xattrs
 
 # * abbreviations
 consts
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 255ed2c53e3..b10d3d11472 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -14,7 +14,8 @@ check out these documents:
 
 Now follows a very important warning:
 
-> [!WARNING] uutils is original code and cannot contain any code from GNU or
+> [!WARNING]
+> uutils is original code and cannot contain any code from GNU or
 > other implementations. This means that **we cannot accept any changes based on
 > the GNU source code**. To make sure that cannot happen, **you cannot link to
 > the GNU source code** either.
diff --git a/Cargo.lock b/Cargo.lock
index d83adfee600..e8c0ce0ca28 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -188,9 +188,9 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.8.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "542f33a8835a0884b006a0c3df3dadd99c0c3f296ed26c2fdc8028e01ad6230c"
+checksum = "c48f0051a4b4c5e0b6d365cd04af53aeaa209e3cc15ec2cdb69e73cc87fbd0dc"
 dependencies = [
  "memchr",
  "regex-automata",
@@ -238,14 +238,14 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.31"
+version = "0.4.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38"
+checksum = "41daef31d7a747c5c847246f36de49ced6f7403b4cdabc807a97b5cc184cda7a"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "num-traits",
- "windows-targets 0.48.0",
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
@@ -320,15 +320,15 @@ checksum = "120133d4db2ec47efe2e26502ee984747630c67f51974fca0b6c1340cf2368d3"
 
 [[package]]
 name = "console"
-version = "0.15.7"
+version = "0.15.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
 dependencies = [
  "encode_unicode",
  "lazy_static",
  "libc",
  "unicode-width",
- "windows-sys 0.45.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -374,7 +374,7 @@ checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
 
 [[package]]
 name = "coreutils"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "chrono",
  "clap",
@@ -507,6 +507,7 @@ dependencies = [
  "uucore",
  "uuhelp_parser",
  "walkdir",
+ "xattr",
  "zip",
 ]
 
@@ -590,9 +591,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.8"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
+checksum = "82a9b73a36529d9c47029b9fb3a6f0ea3cc916a261195352ba19e770fc1748b2"
 dependencies = [
  "cfg-if",
  "crossbeam-utils",
@@ -600,9 +601,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.2"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
+checksum = "fca89a0e215bab21874660c67903c5f143333cab1da83d041c7ded6053774751"
 dependencies = [
  "cfg-if",
  "crossbeam-epoch",
@@ -611,22 +612,20 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.14"
+version = "0.9.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
+checksum = "0e3681d554572a651dda4186cd47240627c3d0114d45a95f6ad27f2f22e7548d"
 dependencies = [
  "autocfg",
  "cfg-if",
  "crossbeam-utils",
- "memoffset",
- "scopeguard",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.15"
+version = "0.8.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
+checksum = "c3a430a770ebd84726f584a90ee7f020d28db52c6d02138900f22341f866d39c"
 dependencies = [
  "cfg-if",
 ]
@@ -690,15 +689,15 @@ checksum = "ef8ae57c4978a2acd8b869ce6b9ca1dfe817bff704c220209fdef2c0b75a01b9"
 
 [[package]]
 name = "data-encoding"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308"
+checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
 
 [[package]]
 name = "data-encoding-macro"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c904b33cc60130e1aeea4956ab803d08a3f4a0ca82d64ed757afac3891f2bb99"
+checksum = "20c01c06f5f429efdf2bae21eb67c28b3df3cf85b7dd2d8ef09c0838dac5d33e"
 dependencies = [
  "data-encoding",
  "data-encoding-macro-internal",
@@ -706,9 +705,9 @@ dependencies = [
 
 [[package]]
 name = "data-encoding-macro-internal"
-version = "0.1.11"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fdf3fce3ce863539ec1d7fd1b6dcc3c645663376b43ed376bbf887733e4f772"
+checksum = "0047d07f2c89b17dd631c80450d69841a6b5d7fb17278cbc43d7e4cfcf2576f3"
 dependencies = [
  "data-encoding",
  "syn 1.0.109",
@@ -781,12 +780,12 @@ dependencies = [
 
 [[package]]
 name = "errno"
-version = "0.3.5"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
 dependencies = [
  "libc",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -815,14 +814,14 @@ checksum = "31a7a908b8f32538a2143e59a6e4e2508988832d5d4d6f7c156b3cbc762643a5"
 
 [[package]]
 name = "filetime"
-version = "0.2.22"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4029edd3e734da6fe05b6cd7bd2960760a616bd2ddd0d59a0124746d6272af0"
+checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.3.5",
- "windows-sys 0.48.0",
+ "redox_syscall",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1122,9 +1121,9 @@ dependencies = [
 
 [[package]]
 name = "itertools"
-version = "0.11.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
+checksum = "25db6b064527c5d482d0423354fcd07a89a2dfe07b67892e62411946db7f07b0"
 dependencies = [
  "either",
 ]
@@ -1187,9 +1186,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.150"
+version = "0.2.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c"
+checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7"
 
 [[package]]
 name = "libloading"
@@ -1215,9 +1214,9 @@ checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.10"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f"
+checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456"
 
 [[package]]
 name = "lock_api"
@@ -1240,9 +1239,9 @@ dependencies = [
 
 [[package]]
 name = "lscolors"
-version = "0.15.0"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf7015a04103ad78abb77e4b79ed151e767922d1cfde5f62640471c629a2320d"
+checksum = "ab0b209ec3976527806024406fe765474b9a1750a0ed4b8f0372364741f50e7b"
 dependencies = [
  "nu-ansi-term",
 ]
@@ -1265,9 +1264,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.6.2"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5486aed0026218e61b8a01d5fbd5a0a134649abb71a0e53b7bc088529dced86e"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
 
 [[package]]
 name = "memmap2"
@@ -1278,15 +1277,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "memoffset"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -1304,14 +1294,14 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "0.8.6"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b9d9a46eff5b4ff64b45a9e316a6d1e0bc719ef429cbec4dc630684212bfdf9"
+checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09"
 dependencies = [
  "libc",
  "log",
  "wasi",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -1409,9 +1399,9 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
 
 [[package]]
 name = "once_cell"
-version = "1.18.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "onig"
@@ -1466,13 +1456,13 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.8"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447"
+checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.3.5",
+ "redox_syscall",
  "smallvec",
  "windows-targets 0.48.0",
 ]
@@ -1600,7 +1590,7 @@ dependencies = [
  "hex",
  "lazy_static",
  "procfs-core",
- "rustix 0.38.21",
+ "rustix 0.38.30",
 ]
 
 [[package]]
@@ -1700,18 +1690,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
-dependencies = [
- "bitflags 1.3.2",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded0bce2d41cc3c57aefa284708ced249a64acb01745dbbe72bd78610bfd644c"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
 dependencies = [
  "bitflags 1.3.2",
 ]
@@ -1724,9 +1705,9 @@ checksum = "f1bfbf25d7eb88ddcbb1ec3d755d0634da8f7657b2cb8b74089121409ab8228f"
 
 [[package]]
 name = "regex"
-version = "1.10.2"
+version = "1.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -1736,9 +1717,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
+checksum = "3b7fa1134405e2ec9353fd416b17f8dacd46c473d7d3fd1cf202706a14eb792a"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -1842,15 +1823,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.21"
+version = "0.38.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b426b0506e5d50a7d8dafcf2e81471400deb602392c7dd110815afb4eaf02a3"
+checksum = "322394588aaf33c24007e8bb3238ee3e4c5c09c084ab32bc73890b99ff326bca"
 dependencies = [
  "bitflags 2.4.0",
  "errno",
  "libc",
- "linux-raw-sys 0.4.10",
- "windows-sys 0.48.0",
+ "linux-raw-sys 0.4.12",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1870,9 +1851,9 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "self_cell"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e388332cd64eb80cd595a00941baf513caffae8dce9cfd0467fc9c66397dade6"
+checksum = "58bf37232d3bb9a2c4e641ca2a11d83b5062066f88df7fed36c28772046d65ba"
 
 [[package]]
 name = "selinux"
@@ -2006,9 +1987,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.11.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
+checksum = "3b187f0231d56fe41bfb12034819dd2bf336422a5866de41bc3fec4b2e3883e8"
 
 [[package]]
 name = "smawk"
@@ -2056,15 +2037,15 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.8.1"
+version = "3.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef1adac450ad7f4b3c28589471ade84f25f731a7a0fe30d71dfa9f60fd808e5"
+checksum = "01ce4141aa927a6d1bd34a041795abd0db1cccba5d5f24b009f694bdf3a1f3fa"
 dependencies = [
  "cfg-if",
  "fastrand",
- "redox_syscall 0.4.0",
- "rustix 0.38.21",
- "windows-sys 0.48.0",
+ "redox_syscall",
+ "rustix 0.38.30",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2083,7 +2064,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
 dependencies = [
- "rustix 0.38.21",
+ "rustix 0.38.30",
  "windows-sys 0.48.0",
 ]
 
@@ -2207,7 +2188,7 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
 
 [[package]]
 name = "uu_arch"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "platform-info",
@@ -2216,7 +2197,7 @@ dependencies = [
 
 [[package]]
 name = "uu_base32"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2224,7 +2205,7 @@ dependencies = [
 
 [[package]]
 name = "uu_base64"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "uu_base32",
  "uucore",
@@ -2232,7 +2213,7 @@ dependencies = [
 
 [[package]]
 name = "uu_basename"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2240,7 +2221,7 @@ dependencies = [
 
 [[package]]
 name = "uu_basenc"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uu_base32",
@@ -2249,7 +2230,7 @@ dependencies = [
 
 [[package]]
 name = "uu_cat"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "nix",
@@ -2259,7 +2240,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chcon"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "fts-sys",
@@ -2271,7 +2252,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chgrp"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2279,7 +2260,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chmod"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2288,7 +2269,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chown"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2296,7 +2277,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chroot"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2304,7 +2285,7 @@ dependencies = [
 
 [[package]]
 name = "uu_cksum"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "hex",
@@ -2313,7 +2294,7 @@ dependencies = [
 
 [[package]]
 name = "uu_comm"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2321,7 +2302,7 @@ dependencies = [
 
 [[package]]
 name = "uu_cp"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "exacl",
@@ -2337,7 +2318,7 @@ dependencies = [
 
 [[package]]
 name = "uu_csplit"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "regex",
@@ -2347,7 +2328,7 @@ dependencies = [
 
 [[package]]
 name = "uu_cut"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "bstr",
  "clap",
@@ -2357,7 +2338,7 @@ dependencies = [
 
 [[package]]
 name = "uu_date"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "chrono",
  "clap",
@@ -2369,7 +2350,7 @@ dependencies = [
 
 [[package]]
 name = "uu_dd"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "gcd",
@@ -2381,7 +2362,7 @@ dependencies = [
 
 [[package]]
 name = "uu_df"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "tempfile",
@@ -2391,7 +2372,7 @@ dependencies = [
 
 [[package]]
 name = "uu_dir"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uu_ls",
@@ -2400,7 +2381,7 @@ dependencies = [
 
 [[package]]
 name = "uu_dircolors"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2408,7 +2389,7 @@ dependencies = [
 
 [[package]]
 name = "uu_dirname"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2416,7 +2397,7 @@ dependencies = [
 
 [[package]]
 name = "uu_du"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "chrono",
  "clap",
@@ -2427,7 +2408,7 @@ dependencies = [
 
 [[package]]
 name = "uu_echo"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2435,7 +2416,7 @@ dependencies = [
 
 [[package]]
 name = "uu_env"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "nix",
@@ -2445,7 +2426,7 @@ dependencies = [
 
 [[package]]
 name = "uu_expand"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "unicode-width",
@@ -2454,7 +2435,7 @@ dependencies = [
 
 [[package]]
 name = "uu_expr"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "num-bigint",
@@ -2465,7 +2446,7 @@ dependencies = [
 
 [[package]]
 name = "uu_factor"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "coz",
@@ -2478,7 +2459,7 @@ dependencies = [
 
 [[package]]
 name = "uu_false"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2486,7 +2467,7 @@ dependencies = [
 
 [[package]]
 name = "uu_fmt"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "unicode-width",
@@ -2495,7 +2476,7 @@ dependencies = [
 
 [[package]]
 name = "uu_fold"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2503,7 +2484,7 @@ dependencies = [
 
 [[package]]
 name = "uu_groups"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2511,7 +2492,7 @@ dependencies = [
 
 [[package]]
 name = "uu_hashsum"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "hex",
@@ -2522,7 +2503,7 @@ dependencies = [
 
 [[package]]
 name = "uu_head"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "memchr",
@@ -2531,7 +2512,7 @@ dependencies = [
 
 [[package]]
 name = "uu_hostid"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2540,7 +2521,7 @@ dependencies = [
 
 [[package]]
 name = "uu_hostname"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "hostname",
@@ -2550,7 +2531,7 @@ dependencies = [
 
 [[package]]
 name = "uu_id"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "selinux",
@@ -2559,7 +2540,7 @@ dependencies = [
 
 [[package]]
 name = "uu_install"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "file_diff",
@@ -2570,7 +2551,7 @@ dependencies = [
 
 [[package]]
 name = "uu_join"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "memchr",
@@ -2579,7 +2560,7 @@ dependencies = [
 
 [[package]]
 name = "uu_kill"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "nix",
@@ -2588,7 +2569,7 @@ dependencies = [
 
 [[package]]
 name = "uu_link"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2596,7 +2577,7 @@ dependencies = [
 
 [[package]]
 name = "uu_ln"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2604,7 +2585,7 @@ dependencies = [
 
 [[package]]
 name = "uu_logname"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2613,11 +2594,12 @@ dependencies = [
 
 [[package]]
 name = "uu_ls"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "chrono",
  "clap",
  "glob",
+ "hostname",
  "lscolors",
  "number_prefix",
  "once_cell",
@@ -2630,7 +2612,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mkdir"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2638,7 +2620,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mkfifo"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2647,7 +2629,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mknod"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2656,7 +2638,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mktemp"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "rand",
@@ -2666,7 +2648,7 @@ dependencies = [
 
 [[package]]
 name = "uu_more"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "crossterm",
@@ -2678,7 +2660,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mv"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "fs_extra",
@@ -2688,7 +2670,7 @@ dependencies = [
 
 [[package]]
 name = "uu_nice"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2698,7 +2680,7 @@ dependencies = [
 
 [[package]]
 name = "uu_nl"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "regex",
@@ -2707,7 +2689,7 @@ dependencies = [
 
 [[package]]
 name = "uu_nohup"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2716,7 +2698,7 @@ dependencies = [
 
 [[package]]
 name = "uu_nproc"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2725,7 +2707,7 @@ dependencies = [
 
 [[package]]
 name = "uu_numfmt"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2733,7 +2715,7 @@ dependencies = [
 
 [[package]]
 name = "uu_od"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "byteorder",
  "clap",
@@ -2743,7 +2725,7 @@ dependencies = [
 
 [[package]]
 name = "uu_paste"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2751,7 +2733,7 @@ dependencies = [
 
 [[package]]
 name = "uu_pathchk"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2760,7 +2742,7 @@ dependencies = [
 
 [[package]]
 name = "uu_pinky"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2768,7 +2750,7 @@ dependencies = [
 
 [[package]]
 name = "uu_pr"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "chrono",
  "clap",
@@ -2780,7 +2762,7 @@ dependencies = [
 
 [[package]]
 name = "uu_printenv"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2788,7 +2770,7 @@ dependencies = [
 
 [[package]]
 name = "uu_printf"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2796,7 +2778,7 @@ dependencies = [
 
 [[package]]
 name = "uu_ptx"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "regex",
@@ -2805,7 +2787,7 @@ dependencies = [
 
 [[package]]
 name = "uu_pwd"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2813,7 +2795,7 @@ dependencies = [
 
 [[package]]
 name = "uu_readlink"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2821,7 +2803,7 @@ dependencies = [
 
 [[package]]
 name = "uu_realpath"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2829,7 +2811,7 @@ dependencies = [
 
 [[package]]
 name = "uu_rm"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2840,7 +2822,7 @@ dependencies = [
 
 [[package]]
 name = "uu_rmdir"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2849,7 +2831,7 @@ dependencies = [
 
 [[package]]
 name = "uu_runcon"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2860,7 +2842,7 @@ dependencies = [
 
 [[package]]
 name = "uu_seq"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "bigdecimal",
  "clap",
@@ -2871,7 +2853,7 @@ dependencies = [
 
 [[package]]
 name = "uu_shred"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2881,7 +2863,7 @@ dependencies = [
 
 [[package]]
 name = "uu_shuf"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "memchr",
@@ -2892,7 +2874,7 @@ dependencies = [
 
 [[package]]
 name = "uu_sleep"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "fundu",
@@ -2901,7 +2883,7 @@ dependencies = [
 
 [[package]]
 name = "uu_sort"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "binary-heap-plus",
  "clap",
@@ -2920,7 +2902,7 @@ dependencies = [
 
 [[package]]
 name = "uu_split"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "memchr",
@@ -2929,7 +2911,7 @@ dependencies = [
 
 [[package]]
 name = "uu_stat"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2937,7 +2919,7 @@ dependencies = [
 
 [[package]]
 name = "uu_stdbuf"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "tempfile",
@@ -2947,17 +2929,16 @@ dependencies = [
 
 [[package]]
 name = "uu_stdbuf_libstdbuf"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "cpp",
  "cpp_build",
  "libc",
- "uucore",
 ]
 
 [[package]]
 name = "uu_stty"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "nix",
@@ -2966,7 +2947,7 @@ dependencies = [
 
 [[package]]
 name = "uu_sum"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -2974,7 +2955,7 @@ dependencies = [
 
 [[package]]
 name = "uu_sync"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -2985,7 +2966,7 @@ dependencies = [
 
 [[package]]
 name = "uu_tac"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "memchr",
@@ -2996,7 +2977,7 @@ dependencies = [
 
 [[package]]
 name = "uu_tail"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "fundu",
@@ -3012,7 +2993,7 @@ dependencies = [
 
 [[package]]
 name = "uu_tee"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -3021,17 +3002,17 @@ dependencies = [
 
 [[package]]
 name = "uu_test"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
- "redox_syscall 0.4.0",
+ "redox_syscall",
  "uucore",
 ]
 
 [[package]]
 name = "uu_timeout"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -3041,7 +3022,7 @@ dependencies = [
 
 [[package]]
 name = "uu_touch"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "chrono",
  "clap",
@@ -3053,7 +3034,7 @@ dependencies = [
 
 [[package]]
 name = "uu_tr"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "nom",
@@ -3062,7 +3043,7 @@ dependencies = [
 
 [[package]]
 name = "uu_true"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -3070,7 +3051,7 @@ dependencies = [
 
 [[package]]
 name = "uu_truncate"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -3078,7 +3059,7 @@ dependencies = [
 
 [[package]]
 name = "uu_tsort"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -3086,7 +3067,7 @@ dependencies = [
 
 [[package]]
 name = "uu_tty"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "nix",
@@ -3095,7 +3076,7 @@ dependencies = [
 
 [[package]]
 name = "uu_uname"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "platform-info",
@@ -3104,7 +3085,7 @@ dependencies = [
 
 [[package]]
 name = "uu_unexpand"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "unicode-width",
@@ -3113,7 +3094,7 @@ dependencies = [
 
 [[package]]
 name = "uu_uniq"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -3121,7 +3102,7 @@ dependencies = [
 
 [[package]]
 name = "uu_unlink"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -3129,7 +3110,7 @@ dependencies = [
 
 [[package]]
 name = "uu_uptime"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "chrono",
  "clap",
@@ -3138,7 +3119,7 @@ dependencies = [
 
 [[package]]
 name = "uu_users"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -3146,7 +3127,7 @@ dependencies = [
 
 [[package]]
 name = "uu_vdir"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uu_ls",
@@ -3155,7 +3136,7 @@ dependencies = [
 
 [[package]]
 name = "uu_wc"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "bytecount",
  "clap",
@@ -3168,7 +3149,7 @@ dependencies = [
 
 [[package]]
 name = "uu_who"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "uucore",
@@ -3176,7 +3157,7 @@ dependencies = [
 
 [[package]]
 name = "uu_whoami"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "libc",
@@ -3186,7 +3167,7 @@ dependencies = [
 
 [[package]]
 name = "uu_yes"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "clap",
  "itertools",
@@ -3196,7 +3177,7 @@ dependencies = [
 
 [[package]]
 name = "uucore"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "blake2b_simd",
  "blake3",
@@ -3227,12 +3208,13 @@ dependencies = [
  "wild",
  "winapi-util",
  "windows-sys 0.48.0",
+ "xattr",
  "z85",
 ]
 
 [[package]]
 name = "uucore_procs"
-version = "0.0.23"
+version = "0.0.24"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3241,7 +3223,7 @@ dependencies = [
 
 [[package]]
 name = "uuhelp_parser"
-version = "0.0.23"
+version = "0.0.24"
 
 [[package]]
 name = "uuid"
@@ -3403,6 +3385,15 @@ dependencies = [
  "windows-targets 0.48.0",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.0",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.42.2"
@@ -3433,6 +3424,21 @@ dependencies = [
  "windows_x86_64_msvc 0.48.0",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.0",
+ "windows_aarch64_msvc 0.52.0",
+ "windows_i686_gnu 0.52.0",
+ "windows_i686_msvc 0.52.0",
+ "windows_x86_64_gnu 0.52.0",
+ "windows_x86_64_gnullvm 0.52.0",
+ "windows_x86_64_msvc 0.52.0",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.42.2"
@@ -3445,6 +3451,12 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
@@ -3457,6 +3469,12 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
@@ -3469,6 +3487,12 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
@@ -3481,6 +3505,12 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
@@ -3493,6 +3523,12 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
@@ -3505,6 +3541,12 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.42.2"
@@ -3517,13 +3559,21 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
+
 [[package]]
 name = "xattr"
-version = "1.0.1"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4686009f71ff3e5c4dbcf1a282d0a44db3f021ba69350cd42086b3e5f1c6985"
+checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f"
 dependencies = [
  "libc",
+ "linux-raw-sys 0.4.12",
+ "rustix 0.38.30",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index f313e2b03e4..757cacf3492 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,7 @@
 
 [package]
 name = "coreutils"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "coreutils ~ GNU coreutils (updated); implemented as universal (cross-platform) utils, written in Rust"
@@ -240,6 +240,7 @@ feat_os_unix_redox = [
   "feat_common_core",
   #
   "chmod",
+  "stat",
   "uname",
 ]
 # "feat_os_windows_legacy" == slightly restricted set of utilities which can be built/run on early windows platforms (eg, "WinXP")
@@ -259,10 +260,10 @@ test = ["uu_test"]
 [workspace.dependencies]
 bigdecimal = "0.4"
 binary-heap-plus = "0.5.0"
-bstr = "1.8"
+bstr = "1.9"
 bytecount = "0.6.7"
 byteorder = "1.5.0"
-chrono = { version = "^0.4.31", default-features = false, features = [
+chrono = { version = "^0.4.32", default-features = false, features = [
   "std",
   "alloc",
   "clock",
@@ -284,11 +285,12 @@ fundu = "2.0.0"
 gcd = "2.3"
 glob = "0.3.1"
 half = "2.3"
+hostname = "0.3"
 indicatif = "0.17"
-itertools = "0.11.0"
-libc = "0.2.150"
-lscolors = { version = "0.15.0", default-features = false, features = [
-  "nu-ansi-term",
+itertools = "0.12.0"
+libc = "0.2.152"
+lscolors = { version = "0.16.0", default-features = false, features = [
+  "gnu_legacy",
 ] }
 memchr = "2"
 memmap2 = "0.9"
@@ -298,7 +300,7 @@ notify = { version = "=6.0.1", features = ["macos_kqueue"] }
 num-bigint = "0.4.4"
 num-traits = "0.2.17"
 number_prefix = "0.4"
-once_cell = "1.18.0"
+once_cell = "1.19.0"
 onig = { version = "~6.4", default-features = false }
 parse_datetime = "0.5.0"
 phf = "0.11.2"
@@ -309,15 +311,15 @@ rand = { version = "0.8", features = ["small_rng"] }
 rand_core = "0.6"
 rayon = "1.8"
 redox_syscall = "0.4"
-regex = "1.10.2"
+regex = "1.10.3"
 rstest = "0.18.2"
 rust-ini = "0.19.0"
 same-file = "1.0.6"
-self_cell = "1.0.2"
+self_cell = "1.0.3"
 selinux = "0.4"
 signal-hook = "0.3.17"
-smallvec = { version = "1.11", features = ["union"] }
-tempfile = "3.8.1"
+smallvec = { version = "1.13", features = ["union"] }
+tempfile = "3.9.0"
 uutils_term_grid = "0.3"
 terminal_size = "0.3.0"
 textwrap = { version = "0.16.0", features = ["terminal_size"] }
@@ -329,8 +331,8 @@ utf-8 = "0.7.6"
 walkdir = "2.4"
 winapi-util = "0.1.6"
 windows-sys = { version = "0.48.0", default-features = false }
-xattr = "1.0.1"
-zip = { version = "0.6.6", default_features = false, features = ["deflate"] }
+xattr = "1.3.1"
+zip = { version = "0.6.6", default-features = false, features = ["deflate"] }
 
 hex = "0.4.3"
 md-5 = "0.10.6"
@@ -361,109 +363,109 @@ zip = { workspace = true, optional = true }
 uuhelp_parser = { optional = true, version = ">=0.0.19", path = "src/uuhelp_parser" }
 
 # * uutils
-uu_test = { optional = true, version = "0.0.23", package = "uu_test", path = "src/uu/test" }
+uu_test = { optional = true, version = "0.0.24", package = "uu_test", path = "src/uu/test" }
 #
-arch = { optional = true, version = "0.0.23", package = "uu_arch", path = "src/uu/arch" }
-base32 = { optional = true, version = "0.0.23", package = "uu_base32", path = "src/uu/base32" }
-base64 = { optional = true, version = "0.0.23", package = "uu_base64", path = "src/uu/base64" }
-basename = { optional = true, version = "0.0.23", package = "uu_basename", path = "src/uu/basename" }
-basenc = { optional = true, version = "0.0.23", package = "uu_basenc", path = "src/uu/basenc" }
-cat = { optional = true, version = "0.0.23", package = "uu_cat", path = "src/uu/cat" }
-chcon = { optional = true, version = "0.0.23", package = "uu_chcon", path = "src/uu/chcon" }
-chgrp = { optional = true, version = "0.0.23", package = "uu_chgrp", path = "src/uu/chgrp" }
-chmod = { optional = true, version = "0.0.23", package = "uu_chmod", path = "src/uu/chmod" }
-chown = { optional = true, version = "0.0.23", package = "uu_chown", path = "src/uu/chown" }
-chroot = { optional = true, version = "0.0.23", package = "uu_chroot", path = "src/uu/chroot" }
-cksum = { optional = true, version = "0.0.23", package = "uu_cksum", path = "src/uu/cksum" }
-comm = { optional = true, version = "0.0.23", package = "uu_comm", path = "src/uu/comm" }
-cp = { optional = true, version = "0.0.23", package = "uu_cp", path = "src/uu/cp" }
-csplit = { optional = true, version = "0.0.23", package = "uu_csplit", path = "src/uu/csplit" }
-cut = { optional = true, version = "0.0.23", package = "uu_cut", path = "src/uu/cut" }
-date = { optional = true, version = "0.0.23", package = "uu_date", path = "src/uu/date" }
-dd = { optional = true, version = "0.0.23", package = "uu_dd", path = "src/uu/dd" }
-df = { optional = true, version = "0.0.23", package = "uu_df", path = "src/uu/df" }
-dir = { optional = true, version = "0.0.23", package = "uu_dir", path = "src/uu/dir" }
-dircolors = { optional = true, version = "0.0.23", package = "uu_dircolors", path = "src/uu/dircolors" }
-dirname = { optional = true, version = "0.0.23", package = "uu_dirname", path = "src/uu/dirname" }
-du = { optional = true, version = "0.0.23", package = "uu_du", path = "src/uu/du" }
-echo = { optional = true, version = "0.0.23", package = "uu_echo", path = "src/uu/echo" }
-env = { optional = true, version = "0.0.23", package = "uu_env", path = "src/uu/env" }
-expand = { optional = true, version = "0.0.23", package = "uu_expand", path = "src/uu/expand" }
-expr = { optional = true, version = "0.0.23", package = "uu_expr", path = "src/uu/expr" }
-factor = { optional = true, version = "0.0.23", package = "uu_factor", path = "src/uu/factor" }
-false = { optional = true, version = "0.0.23", package = "uu_false", path = "src/uu/false" }
-fmt = { optional = true, version = "0.0.23", package = "uu_fmt", path = "src/uu/fmt" }
-fold = { optional = true, version = "0.0.23", package = "uu_fold", path = "src/uu/fold" }
-groups = { optional = true, version = "0.0.23", package = "uu_groups", path = "src/uu/groups" }
-hashsum = { optional = true, version = "0.0.23", package = "uu_hashsum", path = "src/uu/hashsum" }
-head = { optional = true, version = "0.0.23", package = "uu_head", path = "src/uu/head" }
-hostid = { optional = true, version = "0.0.23", package = "uu_hostid", path = "src/uu/hostid" }
-hostname = { optional = true, version = "0.0.23", package = "uu_hostname", path = "src/uu/hostname" }
-id = { optional = true, version = "0.0.23", package = "uu_id", path = "src/uu/id" }
-install = { optional = true, version = "0.0.23", package = "uu_install", path = "src/uu/install" }
-join = { optional = true, version = "0.0.23", package = "uu_join", path = "src/uu/join" }
-kill = { optional = true, version = "0.0.23", package = "uu_kill", path = "src/uu/kill" }
-link = { optional = true, version = "0.0.23", package = "uu_link", path = "src/uu/link" }
-ln = { optional = true, version = "0.0.23", package = "uu_ln", path = "src/uu/ln" }
-ls = { optional = true, version = "0.0.23", package = "uu_ls", path = "src/uu/ls" }
-logname = { optional = true, version = "0.0.23", package = "uu_logname", path = "src/uu/logname" }
-mkdir = { optional = true, version = "0.0.23", package = "uu_mkdir", path = "src/uu/mkdir" }
-mkfifo = { optional = true, version = "0.0.23", package = "uu_mkfifo", path = "src/uu/mkfifo" }
-mknod = { optional = true, version = "0.0.23", package = "uu_mknod", path = "src/uu/mknod" }
-mktemp = { optional = true, version = "0.0.23", package = "uu_mktemp", path = "src/uu/mktemp" }
-more = { optional = true, version = "0.0.23", package = "uu_more", path = "src/uu/more" }
-mv = { optional = true, version = "0.0.23", package = "uu_mv", path = "src/uu/mv" }
-nice = { optional = true, version = "0.0.23", package = "uu_nice", path = "src/uu/nice" }
-nl = { optional = true, version = "0.0.23", package = "uu_nl", path = "src/uu/nl" }
-nohup = { optional = true, version = "0.0.23", package = "uu_nohup", path = "src/uu/nohup" }
-nproc = { optional = true, version = "0.0.23", package = "uu_nproc", path = "src/uu/nproc" }
-numfmt = { optional = true, version = "0.0.23", package = "uu_numfmt", path = "src/uu/numfmt" }
-od = { optional = true, version = "0.0.23", package = "uu_od", path = "src/uu/od" }
-paste = { optional = true, version = "0.0.23", package = "uu_paste", path = "src/uu/paste" }
-pathchk = { optional = true, version = "0.0.23", package = "uu_pathchk", path = "src/uu/pathchk" }
-pinky = { optional = true, version = "0.0.23", package = "uu_pinky", path = "src/uu/pinky" }
-pr = { optional = true, version = "0.0.23", package = "uu_pr", path = "src/uu/pr" }
-printenv = { optional = true, version = "0.0.23", package = "uu_printenv", path = "src/uu/printenv" }
-printf = { optional = true, version = "0.0.23", package = "uu_printf", path = "src/uu/printf" }
-ptx = { optional = true, version = "0.0.23", package = "uu_ptx", path = "src/uu/ptx" }
-pwd = { optional = true, version = "0.0.23", package = "uu_pwd", path = "src/uu/pwd" }
-readlink = { optional = true, version = "0.0.23", package = "uu_readlink", path = "src/uu/readlink" }
-realpath = { optional = true, version = "0.0.23", package = "uu_realpath", path = "src/uu/realpath" }
-rm = { optional = true, version = "0.0.23", package = "uu_rm", path = "src/uu/rm" }
-rmdir = { optional = true, version = "0.0.23", package = "uu_rmdir", path = "src/uu/rmdir" }
-runcon = { optional = true, version = "0.0.23", package = "uu_runcon", path = "src/uu/runcon" }
-seq = { optional = true, version = "0.0.23", package = "uu_seq", path = "src/uu/seq" }
-shred = { optional = true, version = "0.0.23", package = "uu_shred", path = "src/uu/shred" }
-shuf = { optional = true, version = "0.0.23", package = "uu_shuf", path = "src/uu/shuf" }
-sleep = { optional = true, version = "0.0.23", package = "uu_sleep", path = "src/uu/sleep" }
-sort = { optional = true, version = "0.0.23", package = "uu_sort", path = "src/uu/sort" }
-split = { optional = true, version = "0.0.23", package = "uu_split", path = "src/uu/split" }
-stat = { optional = true, version = "0.0.23", package = "uu_stat", path = "src/uu/stat" }
-stdbuf = { optional = true, version = "0.0.23", package = "uu_stdbuf", path = "src/uu/stdbuf" }
-stty = { optional = true, version = "0.0.23", package = "uu_stty", path = "src/uu/stty" }
-sum = { optional = true, version = "0.0.23", package = "uu_sum", path = "src/uu/sum" }
-sync = { optional = true, version = "0.0.23", package = "uu_sync", path = "src/uu/sync" }
-tac = { optional = true, version = "0.0.23", package = "uu_tac", path = "src/uu/tac" }
-tail = { optional = true, version = "0.0.23", package = "uu_tail", path = "src/uu/tail" }
-tee = { optional = true, version = "0.0.23", package = "uu_tee", path = "src/uu/tee" }
-timeout = { optional = true, version = "0.0.23", package = "uu_timeout", path = "src/uu/timeout" }
-touch = { optional = true, version = "0.0.23", package = "uu_touch", path = "src/uu/touch" }
-tr = { optional = true, version = "0.0.23", package = "uu_tr", path = "src/uu/tr" }
-true = { optional = true, version = "0.0.23", package = "uu_true", path = "src/uu/true" }
-truncate = { optional = true, version = "0.0.23", package = "uu_truncate", path = "src/uu/truncate" }
-tsort = { optional = true, version = "0.0.23", package = "uu_tsort", path = "src/uu/tsort" }
-tty = { optional = true, version = "0.0.23", package = "uu_tty", path = "src/uu/tty" }
-uname = { optional = true, version = "0.0.23", package = "uu_uname", path = "src/uu/uname" }
-unexpand = { optional = true, version = "0.0.23", package = "uu_unexpand", path = "src/uu/unexpand" }
-uniq = { optional = true, version = "0.0.23", package = "uu_uniq", path = "src/uu/uniq" }
-unlink = { optional = true, version = "0.0.23", package = "uu_unlink", path = "src/uu/unlink" }
-uptime = { optional = true, version = "0.0.23", package = "uu_uptime", path = "src/uu/uptime" }
-users = { optional = true, version = "0.0.23", package = "uu_users", path = "src/uu/users" }
-vdir = { optional = true, version = "0.0.23", package = "uu_vdir", path = "src/uu/vdir" }
-wc = { optional = true, version = "0.0.23", package = "uu_wc", path = "src/uu/wc" }
-who = { optional = true, version = "0.0.23", package = "uu_who", path = "src/uu/who" }
-whoami = { optional = true, version = "0.0.23", package = "uu_whoami", path = "src/uu/whoami" }
-yes = { optional = true, version = "0.0.23", package = "uu_yes", path = "src/uu/yes" }
+arch = { optional = true, version = "0.0.24", package = "uu_arch", path = "src/uu/arch" }
+base32 = { optional = true, version = "0.0.24", package = "uu_base32", path = "src/uu/base32" }
+base64 = { optional = true, version = "0.0.24", package = "uu_base64", path = "src/uu/base64" }
+basename = { optional = true, version = "0.0.24", package = "uu_basename", path = "src/uu/basename" }
+basenc = { optional = true, version = "0.0.24", package = "uu_basenc", path = "src/uu/basenc" }
+cat = { optional = true, version = "0.0.24", package = "uu_cat", path = "src/uu/cat" }
+chcon = { optional = true, version = "0.0.24", package = "uu_chcon", path = "src/uu/chcon" }
+chgrp = { optional = true, version = "0.0.24", package = "uu_chgrp", path = "src/uu/chgrp" }
+chmod = { optional = true, version = "0.0.24", package = "uu_chmod", path = "src/uu/chmod" }
+chown = { optional = true, version = "0.0.24", package = "uu_chown", path = "src/uu/chown" }
+chroot = { optional = true, version = "0.0.24", package = "uu_chroot", path = "src/uu/chroot" }
+cksum = { optional = true, version = "0.0.24", package = "uu_cksum", path = "src/uu/cksum" }
+comm = { optional = true, version = "0.0.24", package = "uu_comm", path = "src/uu/comm" }
+cp = { optional = true, version = "0.0.24", package = "uu_cp", path = "src/uu/cp" }
+csplit = { optional = true, version = "0.0.24", package = "uu_csplit", path = "src/uu/csplit" }
+cut = { optional = true, version = "0.0.24", package = "uu_cut", path = "src/uu/cut" }
+date = { optional = true, version = "0.0.24", package = "uu_date", path = "src/uu/date" }
+dd = { optional = true, version = "0.0.24", package = "uu_dd", path = "src/uu/dd" }
+df = { optional = true, version = "0.0.24", package = "uu_df", path = "src/uu/df" }
+dir = { optional = true, version = "0.0.24", package = "uu_dir", path = "src/uu/dir" }
+dircolors = { optional = true, version = "0.0.24", package = "uu_dircolors", path = "src/uu/dircolors" }
+dirname = { optional = true, version = "0.0.24", package = "uu_dirname", path = "src/uu/dirname" }
+du = { optional = true, version = "0.0.24", package = "uu_du", path = "src/uu/du" }
+echo = { optional = true, version = "0.0.24", package = "uu_echo", path = "src/uu/echo" }
+env = { optional = true, version = "0.0.24", package = "uu_env", path = "src/uu/env" }
+expand = { optional = true, version = "0.0.24", package = "uu_expand", path = "src/uu/expand" }
+expr = { optional = true, version = "0.0.24", package = "uu_expr", path = "src/uu/expr" }
+factor = { optional = true, version = "0.0.24", package = "uu_factor", path = "src/uu/factor" }
+false = { optional = true, version = "0.0.24", package = "uu_false", path = "src/uu/false" }
+fmt = { optional = true, version = "0.0.24", package = "uu_fmt", path = "src/uu/fmt" }
+fold = { optional = true, version = "0.0.24", package = "uu_fold", path = "src/uu/fold" }
+groups = { optional = true, version = "0.0.24", package = "uu_groups", path = "src/uu/groups" }
+hashsum = { optional = true, version = "0.0.24", package = "uu_hashsum", path = "src/uu/hashsum" }
+head = { optional = true, version = "0.0.24", package = "uu_head", path = "src/uu/head" }
+hostid = { optional = true, version = "0.0.24", package = "uu_hostid", path = "src/uu/hostid" }
+hostname = { optional = true, version = "0.0.24", package = "uu_hostname", path = "src/uu/hostname" }
+id = { optional = true, version = "0.0.24", package = "uu_id", path = "src/uu/id" }
+install = { optional = true, version = "0.0.24", package = "uu_install", path = "src/uu/install" }
+join = { optional = true, version = "0.0.24", package = "uu_join", path = "src/uu/join" }
+kill = { optional = true, version = "0.0.24", package = "uu_kill", path = "src/uu/kill" }
+link = { optional = true, version = "0.0.24", package = "uu_link", path = "src/uu/link" }
+ln = { optional = true, version = "0.0.24", package = "uu_ln", path = "src/uu/ln" }
+ls = { optional = true, version = "0.0.24", package = "uu_ls", path = "src/uu/ls" }
+logname = { optional = true, version = "0.0.24", package = "uu_logname", path = "src/uu/logname" }
+mkdir = { optional = true, version = "0.0.24", package = "uu_mkdir", path = "src/uu/mkdir" }
+mkfifo = { optional = true, version = "0.0.24", package = "uu_mkfifo", path = "src/uu/mkfifo" }
+mknod = { optional = true, version = "0.0.24", package = "uu_mknod", path = "src/uu/mknod" }
+mktemp = { optional = true, version = "0.0.24", package = "uu_mktemp", path = "src/uu/mktemp" }
+more = { optional = true, version = "0.0.24", package = "uu_more", path = "src/uu/more" }
+mv = { optional = true, version = "0.0.24", package = "uu_mv", path = "src/uu/mv" }
+nice = { optional = true, version = "0.0.24", package = "uu_nice", path = "src/uu/nice" }
+nl = { optional = true, version = "0.0.24", package = "uu_nl", path = "src/uu/nl" }
+nohup = { optional = true, version = "0.0.24", package = "uu_nohup", path = "src/uu/nohup" }
+nproc = { optional = true, version = "0.0.24", package = "uu_nproc", path = "src/uu/nproc" }
+numfmt = { optional = true, version = "0.0.24", package = "uu_numfmt", path = "src/uu/numfmt" }
+od = { optional = true, version = "0.0.24", package = "uu_od", path = "src/uu/od" }
+paste = { optional = true, version = "0.0.24", package = "uu_paste", path = "src/uu/paste" }
+pathchk = { optional = true, version = "0.0.24", package = "uu_pathchk", path = "src/uu/pathchk" }
+pinky = { optional = true, version = "0.0.24", package = "uu_pinky", path = "src/uu/pinky" }
+pr = { optional = true, version = "0.0.24", package = "uu_pr", path = "src/uu/pr" }
+printenv = { optional = true, version = "0.0.24", package = "uu_printenv", path = "src/uu/printenv" }
+printf = { optional = true, version = "0.0.24", package = "uu_printf", path = "src/uu/printf" }
+ptx = { optional = true, version = "0.0.24", package = "uu_ptx", path = "src/uu/ptx" }
+pwd = { optional = true, version = "0.0.24", package = "uu_pwd", path = "src/uu/pwd" }
+readlink = { optional = true, version = "0.0.24", package = "uu_readlink", path = "src/uu/readlink" }
+realpath = { optional = true, version = "0.0.24", package = "uu_realpath", path = "src/uu/realpath" }
+rm = { optional = true, version = "0.0.24", package = "uu_rm", path = "src/uu/rm" }
+rmdir = { optional = true, version = "0.0.24", package = "uu_rmdir", path = "src/uu/rmdir" }
+runcon = { optional = true, version = "0.0.24", package = "uu_runcon", path = "src/uu/runcon" }
+seq = { optional = true, version = "0.0.24", package = "uu_seq", path = "src/uu/seq" }
+shred = { optional = true, version = "0.0.24", package = "uu_shred", path = "src/uu/shred" }
+shuf = { optional = true, version = "0.0.24", package = "uu_shuf", path = "src/uu/shuf" }
+sleep = { optional = true, version = "0.0.24", package = "uu_sleep", path = "src/uu/sleep" }
+sort = { optional = true, version = "0.0.24", package = "uu_sort", path = "src/uu/sort" }
+split = { optional = true, version = "0.0.24", package = "uu_split", path = "src/uu/split" }
+stat = { optional = true, version = "0.0.24", package = "uu_stat", path = "src/uu/stat" }
+stdbuf = { optional = true, version = "0.0.24", package = "uu_stdbuf", path = "src/uu/stdbuf" }
+stty = { optional = true, version = "0.0.24", package = "uu_stty", path = "src/uu/stty" }
+sum = { optional = true, version = "0.0.24", package = "uu_sum", path = "src/uu/sum" }
+sync = { optional = true, version = "0.0.24", package = "uu_sync", path = "src/uu/sync" }
+tac = { optional = true, version = "0.0.24", package = "uu_tac", path = "src/uu/tac" }
+tail = { optional = true, version = "0.0.24", package = "uu_tail", path = "src/uu/tail" }
+tee = { optional = true, version = "0.0.24", package = "uu_tee", path = "src/uu/tee" }
+timeout = { optional = true, version = "0.0.24", package = "uu_timeout", path = "src/uu/timeout" }
+touch = { optional = true, version = "0.0.24", package = "uu_touch", path = "src/uu/touch" }
+tr = { optional = true, version = "0.0.24", package = "uu_tr", path = "src/uu/tr" }
+true = { optional = true, version = "0.0.24", package = "uu_true", path = "src/uu/true" }
+truncate = { optional = true, version = "0.0.24", package = "uu_truncate", path = "src/uu/truncate" }
+tsort = { optional = true, version = "0.0.24", package = "uu_tsort", path = "src/uu/tsort" }
+tty = { optional = true, version = "0.0.24", package = "uu_tty", path = "src/uu/tty" }
+uname = { optional = true, version = "0.0.24", package = "uu_uname", path = "src/uu/uname" }
+unexpand = { optional = true, version = "0.0.24", package = "uu_unexpand", path = "src/uu/unexpand" }
+uniq = { optional = true, version = "0.0.24", package = "uu_uniq", path = "src/uu/uniq" }
+unlink = { optional = true, version = "0.0.24", package = "uu_unlink", path = "src/uu/unlink" }
+uptime = { optional = true, version = "0.0.24", package = "uu_uptime", path = "src/uu/uptime" }
+users = { optional = true, version = "0.0.24", package = "uu_users", path = "src/uu/users" }
+vdir = { optional = true, version = "0.0.24", package = "uu_vdir", path = "src/uu/vdir" }
+wc = { optional = true, version = "0.0.24", package = "uu_wc", path = "src/uu/wc" }
+who = { optional = true, version = "0.0.24", package = "uu_who", path = "src/uu/who" }
+whoami = { optional = true, version = "0.0.24", package = "uu_whoami", path = "src/uu/whoami" }
+yes = { optional = true, version = "0.0.24", package = "uu_yes", path = "src/uu/yes" }
 
 # this breaks clippy linting with: "tests/by-util/test_factor_benches.rs: No such file or directory (os error 2)"
 # factor_benches = { optional = true, version = "0.0.0", package = "uu_factor_benches", path = "tests/benches/factor" }
@@ -498,6 +500,7 @@ rlimit = "0.10.1"
 [target.'cfg(unix)'.dev-dependencies]
 nix = { workspace = true, features = ["process", "signal", "user"] }
 rand_pcg = "0.3"
+xattr = { workspace = true }
 
 [build-dependencies]
 phf_codegen = { workspace = true }
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index 67b201e9cc3..6f1de3b5476 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -1,4 +1,4 @@
-<!-- spell-checker:ignore (flags) Ccodegen Coverflow Cpanic Zinstrument Zpanic reimplementing toybox RUNTEST CARGOFLAGS nextest prereq autopoint gettext texinfo automake findutils shellenv libexec gnubin toolchains -->
+<!-- spell-checker:ignore (flags) Ccodegen Coverflow Cpanic Zinstrument Zpanic reimplementing toybox RUNTEST CARGOFLAGS nextest prereq autopoint gettext texinfo automake findutils shellenv libexec gnubin toolchains gsed -->
 
 # Setting up your local development environment
 
@@ -226,8 +226,8 @@ To run uutils against the GNU test suite locally, run the following commands:
 
 ```shell
 bash util/build-gnu.sh
-# Build uutils without release optimizations
-UU_MAKE_PROFILE=debug bash util/build-gnu.sh
+# Build uutils with release optimizations
+bash util/build-gnu.sh --release-build
 bash util/run-gnu-test.sh
 # To run a single test:
 bash util/run-gnu-test.sh tests/touch/not-owner.sh # for example
@@ -241,6 +241,12 @@ DEBUG=1 bash util/run-gnu-test.sh tests/misc/sm3sum.pl
 
 Note that GNU test suite relies on individual utilities (not the multicall binary).
 
+On FreeBSD, you need to install packages for GNU coreutils and sed (used in shell scripts instead of system commands):
+
+```shell
+pkg install coreutils gsed
+```
+
 ## Code coverage report
 
 Code coverage report can be generated using [grcov](https://github.com/mozilla/grcov).
diff --git a/LICENSE b/LICENSE
index 49fdbd4cf5f..21bd44404e3 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) Jordi Boggiano and many others
+Copyright (c) uutils developers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
diff --git a/README.md b/README.md
index 4f341638b3f..c8ca0d8a316 100644
--- a/README.md
+++ b/README.md
@@ -305,7 +305,7 @@ Below is the evolution of how many GNU tests uutils passes. A more detailed
 breakdown of the GNU test results of the main branch can be found
 [in the user manual](https://uutils.github.io/coreutils/book/test_coverage.html).
 
-See <https://github.com/uutils/coreutils/issues/3336> for the main meta bugs
+See <https://github.com/orgs/uutils/projects/1> for the main meta bugs
 (many are missing).
 
 ![Evolution over time](https://github.com/uutils/coreutils-tracking/blob/main/gnu-results.png?raw=true)
diff --git a/deny.toml b/deny.toml
index 03301ad7cd4..d7c04ad2d5b 100644
--- a/deny.toml
+++ b/deny.toml
@@ -62,10 +62,14 @@ skip = [
   { name = "linux-raw-sys", version = "0.3.8" },
   # terminal_size
   { name = "rustix", version = "0.37.26" },
-  # various crates
+  # notify
   { name = "windows-sys", version = "0.45.0" },
+  # various crates
+  { name = "windows-sys", version = "0.48.0" },
   # windows-sys
   { name = "windows-targets", version = "0.42.2" },
+  # windows-sys
+  { name = "windows-targets", version = "0.48.0" },
   # windows-targets
   { name = "windows_aarch64_gnullvm", version = "0.42.2" },
   # windows-targets
@@ -80,12 +84,24 @@ skip = [
   { name = "windows_x86_64_gnullvm", version = "0.42.2" },
   # windows-targets
   { name = "windows_x86_64_msvc", version = "0.42.2" },
+  # windows-targets
+  { name = "windows_aarch64_gnullvm", version = "0.48.0" },
+  # windows-targets
+  { name = "windows_aarch64_msvc", version = "0.48.0" },
+  # windows-targets
+  { name = "windows_i686_gnu", version = "0.48.0" },
+  # windows-targets
+  { name = "windows_i686_msvc", version = "0.48.0" },
+  # windows-targets
+  { name = "windows_x86_64_gnu", version = "0.48.0" },
+  # windows-targets
+  { name = "windows_x86_64_gnullvm", version = "0.48.0" },
+  # windows-targets
+  { name = "windows_x86_64_msvc", version = "0.48.0" },
   # various crates
   { name = "syn", version = "1.0.109" },
   # various crates
   { name = "bitflags", version = "1.3.2" },
-  # various crates
-  { name = "redox_syscall", version = "0.3.5" },
   # clap_builder, textwrap
   { name = "terminal_size", version = "0.2.6" },
 ]
diff --git a/docs/src/installation.md b/docs/src/installation.md
index da124ead977..dc631d240ca 100644
--- a/docs/src/installation.md
+++ b/docs/src/installation.md
@@ -1,4 +1,4 @@
-<!-- spell-checker:ignore pacman pamac nixpkgs openmandriva conda -->
+<!-- spell-checker:ignore pacman pamac nixpkgs openmandriva conda winget -->
 
 # Installation
 
@@ -6,13 +6,13 @@ This is a list of uutils packages in various distributions and package managers.
 Note that these are packaged by third-parties and the packages might contain
 patches.
 
-You can also [build uutils from source](/build.md).
+You can also [build uutils from source](build.md).
 
 <!-- toc -->
 
 ## Cargo
 
-[![crates.io package](https://repology.org/badge/version-for-repo/crates_io/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
+[![crates.io package](https://repology.org/badge/version-for-repo/crates_io/uutils-coreutils.svg)](https://crates.io/crates/coreutils)
 
 ```shell
 # Linux
@@ -53,8 +53,6 @@ apt install rust-coreutils
 export PATH=/usr/lib/cargo/bin/coreutils:$PATH
 ```
 
-> **Note**: Only available from Bookworm (Debian 12)
-
 ### Gentoo
 
 [![Gentoo package](https://repology.org/badge/version-for-repo/gentoo/uutils-coreutils.svg)](https://packages.gentoo.org/packages/sys-apps/uutils-coreutils)
@@ -65,9 +63,9 @@ emerge -pv sys-apps/uutils-coreutils
 
 ### Manjaro
 
-![Manjaro Stable package](https://repology.org/badge/version-for-repo/manjaro_stable/uutils-coreutils.svg)
-[![Manjaro Testing package](https://repology.org/badge/version-for-repo/manjaro_testing/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
-[![Manjaro Unstable package](https://repology.org/badge/version-for-repo/manjaro_unstable/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
+[![Manjaro Stable package](https://repology.org/badge/version-for-repo/manjaro_stable/uutils-coreutils.svg)](https://packages.manjaro.org/?query=uutils-coreutils)
+[![Manjaro Testing package](https://repology.org/badge/version-for-repo/manjaro_testing/uutils-coreutils.svg)](https://packages.manjaro.org/?query=uutils-coreutils)
+[![Manjaro Unstable package](https://repology.org/badge/version-for-repo/manjaro_unstable/uutils-coreutils.svg)](https://packages.manjaro.org/?query=uutils-coreutils)
 
 ```shell
 pacman -S uutils-coreutils
@@ -77,7 +75,7 @@ pamac install uutils-coreutils
 
 ### NixOS
 
-[![nixpkgs unstable package](https://repology.org/badge/version-for-repo/nix_unstable/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
+[![nixpkgs unstable package](https://repology.org/badge/version-for-repo/nix_unstable/uutils-coreutils.svg)](https://search.nixos.org/packages?query=uutils-coreutils)
 
 ```shell
 nix-env -iA nixos.uutils-coreutils
@@ -101,8 +99,6 @@ apt install rust-coreutils
 export PATH=/usr/lib/cargo/bin/coreutils:$PATH
 ```
 
-> **Note**: Only available from Kinetic (Ubuntu 22.10)
-
 ## MacOS
 
 ### Homebrew
@@ -123,7 +119,7 @@ port install coreutils-uutils
 
 ## FreeBSD
 
-[![FreeBSD port](https://repology.org/badge/version-for-repo/freebsd/uutils-coreutils.svg)](https://repology.org/project/uutils-coreutils/versions)
+[![FreeBSD port](https://repology.org/badge/version-for-repo/freebsd/rust-coreutils.svg)](https://repology.org/project/rust-coreutils/versions)
 
 ```sh
 pkg install rust-coreutils
@@ -131,9 +127,15 @@ pkg install rust-coreutils
 
 ## Windows
 
+### Winget
+
+```shell
+winget install uutils.coreutils
+```
+
 ### Scoop
 
-[![Scoop package](https://repology.org/badge/version-for-repo/scoop/uutils-coreutils.svg)](https://scoop.sh/#/apps?q=uutils-coreutils&s=0&d=1&o=true)
+[Scoop package](https://scoop.sh/#/apps?q=uutils-coreutils&s=0&d=1&o=true)
 
 ```shell
 scoop install uutils-coreutils
@@ -146,7 +148,7 @@ scoop install uutils-coreutils
 [Conda package](https://anaconda.org/conda-forge/uutils-coreutils)
 
 ```
-conda install -c conda-forge uutils-coreutils 
+conda install -c conda-forge uutils-coreutils
 ```
 
 ## Non-standard packages
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index 549f9a6b762..dfb62aba5e1 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -10,13 +10,21 @@ cargo-fuzz = true
 [dependencies]
 libfuzzer-sys = "0.4"
 libc = "0.2"
+tempfile = "3"
 rand = { version = "0.8", features = ["small_rng"] }
+similar = "2"
 
 uucore = { path = "../src/uucore/" }
 uu_date = { path = "../src/uu/date/" }
 uu_test = { path = "../src/uu/test/" }
 uu_expr = { path = "../src/uu/expr/" }
-
+uu_printf = { path = "../src/uu/printf/" }
+uu_echo = { path = "../src/uu/echo/" }
+uu_seq = { path = "../src/uu/seq/" }
+uu_sort = { path = "../src/uu/sort/" }
+uu_wc = { path = "../src/uu/wc/" }
+uu_cut = { path = "../src/uu/cut/" }
+uu_split = { path = "../src/uu/split/" }
 
 # Prevent this from interfering with workspaces
 [workspace]
@@ -28,6 +36,48 @@ path = "fuzz_targets/fuzz_date.rs"
 test = false
 doc = false
 
+[[bin]]
+name = "fuzz_printf"
+path = "fuzz_targets/fuzz_printf.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_echo"
+path = "fuzz_targets/fuzz_echo.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_seq"
+path = "fuzz_targets/fuzz_seq.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_sort"
+path = "fuzz_targets/fuzz_sort.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_split"
+path = "fuzz_targets/fuzz_split.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_cut"
+path = "fuzz_targets/fuzz_cut.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_wc"
+path = "fuzz_targets/fuzz_wc.rs"
+test = false
+doc = false
+
 [[bin]]
 name = "fuzz_expr"
 path = "fuzz_targets/fuzz_expr.rs"
diff --git a/fuzz/fuzz_targets/fuzz_common.rs b/fuzz/fuzz_targets/fuzz_common.rs
index 2adbb3dd677..cf56268d75a 100644
--- a/fuzz/fuzz_targets/fuzz_common.rs
+++ b/fuzz/fuzz_targets/fuzz_common.rs
@@ -3,16 +3,18 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use libc::STDIN_FILENO;
 use libc::{close, dup, dup2, pipe, STDERR_FILENO, STDOUT_FILENO};
 use rand::prelude::SliceRandom;
 use rand::Rng;
+use similar::TextDiff;
 use std::ffi::OsString;
-use std::io;
-use std::io::Write;
-use std::os::fd::RawFd;
-use std::process::Command;
+use std::io::{Seek, SeekFrom, Write};
+use std::os::fd::{AsRawFd, RawFd};
+use std::process::{Command, Stdio};
 use std::sync::atomic::Ordering;
 use std::sync::{atomic::AtomicBool, Once};
+use std::{io, thread};
 
 /// Represents the result of running a command, including its standard output,
 /// standard error, and exit code.
@@ -49,20 +51,25 @@ pub fn is_gnu_cmd(cmd_path: &str) -> Result<(), std::io::Error> {
     }
 }
 
-pub fn generate_and_run_uumain<F>(args: &[OsString], uumain_function: F) -> CommandResult
+pub fn generate_and_run_uumain<F>(
+    args: &[OsString],
+    uumain_function: F,
+    pipe_input: Option<&str>,
+) -> CommandResult
 where
-    F: FnOnce(std::vec::IntoIter<OsString>) -> i32,
+    F: FnOnce(std::vec::IntoIter<OsString>) -> i32 + Send + 'static,
 {
     // Duplicate the stdout and stderr file descriptors
     let original_stdout_fd = unsafe { dup(STDOUT_FILENO) };
     let original_stderr_fd = unsafe { dup(STDERR_FILENO) };
     if original_stdout_fd == -1 || original_stderr_fd == -1 {
         return CommandResult {
-            stdout: "Failed to duplicate STDOUT_FILENO or STDERR_FILENO".to_string(),
-            stderr: "".to_string(),
+            stdout: "".to_string(),
+            stderr: "Failed to duplicate STDOUT_FILENO or STDERR_FILENO".to_string(),
             exit_code: -1,
         };
     }
+
     println!("Running test {:?}", &args[0..]);
     let mut pipe_stdout_fds = [-1; 2];
     let mut pipe_stderr_fds = [-1; 2];
@@ -72,8 +79,8 @@ where
         || unsafe { pipe(pipe_stderr_fds.as_mut_ptr()) } == -1
     {
         return CommandResult {
-            stdout: "Failed to create pipes".to_string(),
-            stderr: "".to_string(),
+            stdout: "".to_string(),
+            stderr: "Failed to create pipes".to_string(),
             exit_code: -1,
         };
     }
@@ -89,47 +96,85 @@ where
             close(pipe_stderr_fds[1]);
         }
         return CommandResult {
-            stdout: "Failed to redirect STDOUT_FILENO or STDERR_FILENO".to_string(),
-            stderr: "".to_string(),
+            stdout: "".to_string(),
+            stderr: "Failed to redirect STDOUT_FILENO or STDERR_FILENO".to_string(),
             exit_code: -1,
         };
     }
 
-    let uumain_exit_status = uumain_function(args.to_owned().into_iter());
+    let original_stdin_fd = if let Some(input_str) = pipe_input {
+        // we have pipe input
+        let mut input_file = tempfile::tempfile().unwrap();
+        write!(input_file, "{}", input_str).unwrap();
+        input_file.seek(SeekFrom::Start(0)).unwrap();
+
+        // Redirect stdin to read from the in-memory file
+        let original_stdin_fd = unsafe { dup(STDIN_FILENO) };
+        if original_stdin_fd == -1 || unsafe { dup2(input_file.as_raw_fd(), STDIN_FILENO) } == -1 {
+            return CommandResult {
+                stdout: "".to_string(),
+                stderr: "Failed to set up stdin redirection".to_string(),
+                exit_code: -1,
+            };
+        }
+        Some(original_stdin_fd)
+    } else {
+        None
+    };
 
-    io::stdout().flush().unwrap();
-    io::stderr().flush().unwrap();
+    let (uumain_exit_status, captured_stdout, captured_stderr) = thread::scope(|s| {
+        let out = s.spawn(|| read_from_fd(pipe_stdout_fds[0]));
+        let err = s.spawn(|| read_from_fd(pipe_stderr_fds[0]));
+        let status = uumain_function(args.to_owned().into_iter());
+        // Reset the exit code global variable in case we run another test after this one
+        // See https://github.com/uutils/coreutils/issues/5777
+        uucore::error::set_exit_code(0);
+        io::stdout().flush().unwrap();
+        io::stderr().flush().unwrap();
+        unsafe {
+            close(pipe_stdout_fds[1]);
+            close(pipe_stderr_fds[1]);
+            close(STDOUT_FILENO);
+            close(STDERR_FILENO);
+        }
+        (status, out.join().unwrap(), err.join().unwrap())
+    });
 
     // Restore the original stdout and stderr
     if unsafe { dup2(original_stdout_fd, STDOUT_FILENO) } == -1
         || unsafe { dup2(original_stderr_fd, STDERR_FILENO) } == -1
     {
         return CommandResult {
-            stdout: "Failed to restore the original STDOUT_FILENO or STDERR_FILENO".to_string(),
-            stderr: "".to_string(),
+            stdout: "".to_string(),
+            stderr: "Failed to restore the original STDOUT_FILENO or STDERR_FILENO".to_string(),
             exit_code: -1,
         };
     }
     unsafe {
         close(original_stdout_fd);
         close(original_stderr_fd);
-
-        close(pipe_stdout_fds[1]);
-        close(pipe_stderr_fds[1]);
     }
 
-    let captured_stdout = read_from_fd(pipe_stdout_fds[0]).trim().to_string();
-    let captured_stderr = read_from_fd(pipe_stderr_fds[0]).to_string();
-    let captured_stderr = captured_stderr
-        .split_once(':')
-        .map(|x| x.1)
-        .unwrap_or("")
-        .trim()
-        .to_string();
+    // Restore the original stdin if it was modified
+    if let Some(fd) = original_stdin_fd {
+        if unsafe { dup2(fd, STDIN_FILENO) } == -1 {
+            return CommandResult {
+                stdout: "".to_string(),
+                stderr: "Failed to restore the original STDIN".to_string(),
+                exit_code: -1,
+            };
+        }
+        unsafe { close(fd) };
+    }
 
     CommandResult {
         stdout: captured_stdout,
-        stderr: captured_stderr,
+        stderr: captured_stderr
+            .split_once(':')
+            .map(|x| x.1)
+            .unwrap_or("")
+            .trim()
+            .to_string(),
         exit_code: uumain_exit_status,
     }
 }
@@ -165,6 +210,7 @@ pub fn run_gnu_cmd(
     cmd_path: &str,
     args: &[OsString],
     check_gnu: bool,
+    pipe_input: Option<&str>,
 ) -> Result<CommandResult, CommandResult> {
     if check_gnu {
         match is_gnu_cmd(cmd_path) {
@@ -185,18 +231,43 @@ pub fn run_gnu_cmd(
         command.arg(arg);
     }
 
-    let output = match command.output() {
-        Ok(output) => output,
-        Err(e) => {
-            return Err(CommandResult {
-                stdout: String::new(),
-                stderr: e.to_string(),
-                exit_code: -1,
-            });
+    let output = if let Some(input_str) = pipe_input {
+        // We have an pipe input
+        command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+
+        let mut child = command.spawn().expect("Failed to execute command");
+        let child_stdin = child.stdin.as_mut().unwrap();
+        child_stdin
+            .write_all(input_str.as_bytes())
+            .expect("Failed to write to stdin");
+
+        match child.wait_with_output() {
+            Ok(output) => output,
+            Err(e) => {
+                return Err(CommandResult {
+                    stdout: String::new(),
+                    stderr: e.to_string(),
+                    exit_code: -1,
+                });
+            }
+        }
+    } else {
+        // Just run with args
+        match command.output() {
+            Ok(output) => output,
+            Err(e) => {
+                return Err(CommandResult {
+                    stdout: String::new(),
+                    stderr: e.to_string(),
+                    exit_code: -1,
+                });
+            }
         }
     };
     let exit_code = output.status.code().unwrap_or(-1);
-
     // Here we get stdout and stderr as Strings
     let stdout = String::from_utf8_lossy(&output.stdout).to_string();
     let stderr = String::from_utf8_lossy(&output.stderr).to_string();
@@ -222,41 +293,51 @@ pub fn run_gnu_cmd(
     }
 }
 
+/// Compare results from two different implementations of a command.
+///
+/// # Arguments
+/// * `test_type` - The command.
+/// * `input` - The input provided to the command.
+/// * `rust_result` - The result of running the command with the Rust implementation.
+/// * `gnu_result` - The result of running the command with the GNU implementation.
+/// * `fail_on_stderr_diff` - Whether to fail the test if there is a difference in stderr output.
 pub fn compare_result(
     test_type: &str,
     input: &str,
-    rust_stdout: &str,
-    gnu_stdout: &str,
-    rust_stderr: &str,
-    gnu_stderr: &str,
-    rust_exit_code: i32,
-    gnu_exit_code: i32,
+    pipe_input: Option<&str>,
+    rust_result: &CommandResult,
+    gnu_result: &CommandResult,
     fail_on_stderr_diff: bool,
 ) {
     println!("Test Type: {}", test_type);
     println!("Input: {}", input);
+    if let Some(pipe) = pipe_input {
+        println!("Pipe: {}", pipe);
+    }
 
     let mut discrepancies = Vec::new();
     let mut should_panic = false;
 
-    if rust_stdout.trim() != gnu_stdout.trim() {
+    if rust_result.stdout.trim() != gnu_result.stdout.trim() {
         discrepancies.push("stdout differs");
-        println!("Rust stdout: {}", rust_stdout);
-        println!("GNU stdout: {}", gnu_stdout);
+        println!("Rust stdout: {}", rust_result.stdout);
+        println!("GNU stdout: {}", gnu_result.stdout);
+        print_diff(&rust_result.stdout, &gnu_result.stdout);
         should_panic = true;
     }
-    if rust_stderr.trim() != gnu_stderr.trim() {
+    if rust_result.stderr.trim() != gnu_result.stderr.trim() {
         discrepancies.push("stderr differs");
-        println!("Rust stderr: {}", rust_stderr);
-        println!("GNU stderr: {}", gnu_stderr);
+        println!("Rust stderr: {}", rust_result.stderr);
+        println!("GNU stderr: {}", gnu_result.stderr);
+        print_diff(&rust_result.stderr, &gnu_result.stderr);
         if fail_on_stderr_diff {
             should_panic = true;
         }
     }
-    if rust_exit_code != gnu_exit_code {
+    if rust_result.exit_code != gnu_result.exit_code {
         discrepancies.push("exit code differs");
-        println!("Rust exit code: {}", rust_exit_code);
-        println!("GNU exit code: {}", gnu_exit_code);
+        println!("Rust exit code: {}", rust_result.exit_code);
+        println!("GNU exit code: {}", gnu_result.exit_code);
         should_panic = true;
     }
 
@@ -275,6 +356,16 @@ pub fn compare_result(
     }
 }
 
+/// When we have different outputs, print the diff
+fn print_diff(rust_output: &str, gnu_output: &str) {
+    println!("Diff=");
+    let diff = TextDiff::from_lines(rust_output, gnu_output);
+    for change in diff.iter_all_changes() {
+        print!("{}{}", change.tag(), change);
+    }
+    println!();
+}
+
 pub fn generate_random_string(max_length: usize) -> String {
     let mut rng = rand::thread_rng();
     let valid_utf8: Vec<char> = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
diff --git a/fuzz/fuzz_targets/fuzz_cut.rs b/fuzz/fuzz_targets/fuzz_cut.rs
new file mode 100644
index 00000000000..fa5f8fcc472
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_cut.rs
@@ -0,0 +1,87 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_cut::uumain;
+
+use rand::Rng;
+use std::ffi::OsString;
+
+mod fuzz_common;
+use crate::fuzz_common::{
+    compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd, CommandResult,
+};
+static CMD_PATH: &str = "cut";
+
+fn generate_cut_args() -> String {
+    let mut rng = rand::thread_rng();
+    let arg_count = rng.gen_range(1..=6);
+    let mut args = Vec::new();
+
+    for _ in 0..arg_count {
+        if rng.gen_bool(0.1) {
+            args.push(generate_random_string(rng.gen_range(1..=20)));
+        } else {
+            match rng.gen_range(0..=4) {
+                0 => args.push(String::from("-b") + &rng.gen_range(1..=10).to_string()),
+                1 => args.push(String::from("-c") + &rng.gen_range(1..=10).to_string()),
+                2 => args.push(String::from("-d,") + &generate_random_string(1)), // Using a comma as a default delimiter
+                3 => args.push(String::from("-f") + &rng.gen_range(1..=5).to_string()),
+                _ => (),
+            }
+        }
+    }
+
+    args.join(" ")
+}
+
+fn generate_delimited_data(count: usize) -> String {
+    let mut rng = rand::thread_rng();
+    let mut lines = Vec::new();
+
+    for _ in 0..count {
+        let fields = (0..rng.gen_range(1..=5))
+            .map(|_| generate_random_string(rng.gen_range(1..=10)))
+            .collect::<Vec<_>>()
+            .join(",");
+        lines.push(fields);
+    }
+
+    lines.join("\n")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let cut_args = generate_cut_args();
+    let mut args = vec![OsString::from("cut")];
+    args.extend(cut_args.split_whitespace().map(OsString::from));
+
+    let input_lines = generate_delimited_data(10);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_lines));
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, Some(&input_lines)) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "cut",
+        &format!("{:?}", &args[1..]),
+        Some(&input_lines),
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_echo.rs b/fuzz/fuzz_targets/fuzz_echo.rs
new file mode 100644
index 00000000000..3f15b257e6e
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_echo.rs
@@ -0,0 +1,86 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_echo::uumain;
+
+use rand::prelude::SliceRandom;
+use rand::Rng;
+use std::ffi::OsString;
+
+mod fuzz_common;
+use crate::fuzz_common::CommandResult;
+use crate::fuzz_common::{
+    compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd,
+};
+
+static CMD_PATH: &str = "echo";
+
+fn generate_echo() -> String {
+    let mut rng = rand::thread_rng();
+    let mut echo_str = String::new();
+
+    // Randomly decide whether to include options
+    let include_n = rng.gen_bool(0.1); // 10% chance
+    let include_e = rng.gen_bool(0.1); // 10% chance
+    let include_E = rng.gen_bool(0.1); // 10% chance
+
+    if include_n {
+        echo_str.push_str("-n ");
+    }
+    if include_e {
+        echo_str.push_str("-e ");
+    }
+    if include_E {
+        echo_str.push_str("-E ");
+    }
+
+    // Add a random string
+    echo_str.push_str(&generate_random_string(rng.gen_range(1..=10)));
+
+    // Include escape sequences if -e is enabled
+    if include_e {
+        // Add a 10% chance of including an escape sequence
+        if rng.gen_bool(0.1) {
+            echo_str.push_str(&generate_escape_sequence(&mut rng));
+        }
+    }
+
+    echo_str
+}
+
+fn generate_escape_sequence(rng: &mut impl Rng) -> String {
+    let escape_sequences = [
+        "\\\\", "\\a", "\\b", "\\c", "\\e", "\\f", "\\n", "\\r", "\\t", "\\v", "\\0NNN", "\\xHH",
+    ];
+    // \0NNN and \xHH need more work
+    escape_sequences.choose(rng).unwrap().to_string()
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let echo_input = generate_echo();
+    let mut args = vec![OsString::from("echo")];
+    args.extend(echo_input.split_whitespace().map(OsString::from));
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "echo",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        true,
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_expr.rs b/fuzz/fuzz_targets/fuzz_expr.rs
index 8d1848545ff..8bc18fae47e 100644
--- a/fuzz/fuzz_targets/fuzz_expr.rs
+++ b/fuzz/fuzz_targets/fuzz_expr.rs
@@ -21,7 +21,9 @@ static CMD_PATH: &str = "expr";
 
 fn generate_expr(max_depth: u32) -> String {
     let mut rng = rand::thread_rng();
-    let ops = ["+", "-", "*", "/", "%", "<", ">", "=", "&", "|"];
+    let ops = [
+        "+", "-", "*", "/", "%", "<", ">", "=", "&", "|", "!=", "<=", ">=", ":", "index", "length", "substr",
+    ];
 
     let mut expr = String::new();
     let mut depth = 0;
@@ -67,9 +69,9 @@ fuzz_target!(|_data: &[u8]| {
     // because uutils expr doesn't support localization yet
     // TODO remove once uutils expr supports localization
     env::set_var("LC_COLLATE", "C");
-    let rust_result = generate_and_run_uumain(&args, uumain);
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
 
-    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false) {
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
         Ok(result) => result,
         Err(error_result) => {
             eprintln!("Failed to run GNU command:");
@@ -86,12 +88,9 @@ fuzz_target!(|_data: &[u8]| {
     compare_result(
         "expr",
         &format!("{:?}", &args[1..]),
-        &rust_result.stdout,
-        &gnu_result.stdout,
-        &rust_result.stderr,
-        &gnu_result.stderr,
-        rust_result.exit_code,
-        gnu_result.exit_code,
+        None,
+        &rust_result,
+        &gnu_result,
         false, // Set to true if you want to fail on stderr diff
     );
 });
diff --git a/fuzz/fuzz_targets/fuzz_printf.rs b/fuzz/fuzz_targets/fuzz_printf.rs
new file mode 100644
index 00000000000..72fac540b17
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_printf.rs
@@ -0,0 +1,107 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_printf::uumain;
+
+use rand::seq::SliceRandom;
+use rand::Rng;
+use std::ffi::OsString;
+
+mod fuzz_common;
+use crate::fuzz_common::CommandResult;
+use crate::fuzz_common::{
+    compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd,
+};
+
+static CMD_PATH: &str = "printf";
+
+fn generate_escape_sequence(rng: &mut impl Rng) -> String {
+    let escape_sequences = [
+        "\\\"",
+        "\\\\",
+        "\\a",
+        "\\b",
+        "\\c",
+        "\\e",
+        "\\f",
+        "\\n",
+        "\\r",
+        "\\t",
+        "\\v",
+        "\\000",
+        "\\x00",
+        "\\u0000",
+        "\\U00000000",
+        "%%",
+    ];
+    escape_sequences.choose(rng).unwrap().to_string()
+}
+
+fn generate_printf() -> String {
+    let mut rng = rand::thread_rng();
+    let format_specifiers = ["%s", "%d", "%f", "%x", "%o", "%c", "%b", "%q"];
+    let mut printf_str = String::new();
+    // Add a 20% chance of generating an invalid format specifier
+    if rng.gen_bool(0.2) {
+        printf_str.push_str("%z"); // Invalid format specifier
+    } else {
+        let specifier = *format_specifiers.choose(&mut rng).unwrap();
+        printf_str.push_str(specifier);
+
+        // Add a 20% chance of introducing complex format strings
+        if rng.gen_bool(0.2) {
+            printf_str.push_str(&format!(" %{}", rng.gen_range(1..=1000)));
+        } else {
+            // Add a random string or number after the specifier
+            if specifier == "%s" {
+                printf_str.push_str(&format!(
+                    " {}",
+                    generate_random_string(rng.gen_range(1..=10))
+                ));
+            } else {
+                printf_str.push_str(&format!(" {}", rng.gen_range(1..=1000)));
+            }
+        }
+    }
+
+    // Add a 10% chance of including an escape sequence
+    if rng.gen_bool(0.1) {
+        printf_str.push_str(&generate_escape_sequence(&mut rng));
+    }
+    printf_str
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let printf_input = generate_printf();
+    let mut args = vec![OsString::from("printf")];
+    args.extend(printf_input.split_whitespace().map(OsString::from));
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "printf",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_seq.rs b/fuzz/fuzz_targets/fuzz_seq.rs
new file mode 100644
index 00000000000..7bb4f8af956
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_seq.rs
@@ -0,0 +1,75 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_seq::uumain;
+
+use rand::Rng;
+use std::ffi::OsString;
+
+mod fuzz_common;
+use crate::fuzz_common::CommandResult;
+use crate::fuzz_common::{
+    compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd,
+};
+static CMD_PATH: &str = "seq";
+
+fn generate_seq() -> String {
+    let mut rng = rand::thread_rng();
+
+    // Generate 1 to 3 numbers for seq arguments
+    let arg_count = rng.gen_range(1..=3);
+    let mut args = Vec::new();
+
+    for _ in 0..arg_count {
+        if rng.gen_ratio(1, 100) {
+            // 1% chance to add a random string
+            args.push(generate_random_string(rng.gen_range(1..=10)));
+        } else {
+            // 99% chance to add a numeric value
+            match rng.gen_range(0..=3) {
+                0 => args.push(rng.gen_range(-10000..=10000).to_string()), // Large or small integers
+                1 => args.push(rng.gen_range(-100.0..100.0).to_string()),  // Floating-point numbers
+                2 => args.push(rng.gen_range(-100..0).to_string()),        // Negative integers
+                _ => args.push(rng.gen_range(1..=100).to_string()),        // Regular integers
+            }
+        }
+    }
+
+    args.join(" ")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let seq = generate_seq();
+    let mut args = vec![OsString::from("seq")];
+    args.extend(seq.split_whitespace().map(OsString::from));
+
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "seq",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_sort.rs b/fuzz/fuzz_targets/fuzz_sort.rs
new file mode 100644
index 00000000000..3520bbaefed
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_sort.rs
@@ -0,0 +1,86 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_sort::uumain;
+
+use rand::Rng;
+use std::env;
+use std::ffi::OsString;
+
+mod fuzz_common;
+use crate::fuzz_common::CommandResult;
+use crate::fuzz_common::{
+    compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd,
+};
+static CMD_PATH: &str = "sort";
+
+fn generate_sort_args() -> String {
+    let mut rng = rand::thread_rng();
+
+    let arg_count = rng.gen_range(1..=5);
+    let mut args = Vec::new();
+
+    for _ in 0..arg_count {
+        match rng.gen_range(0..=4) {
+            0 => args.push(String::from("-r")), // Reverse the result of comparisons
+            1 => args.push(String::from("-n")), // Compare according to string numerical value
+            2 => args.push(String::from("-f")), // Fold lower case to upper case characters
+            3 => args.push(generate_random_string(rng.gen_range(1..=10))), // Random string (to simulate file names)
+            _ => args.push(String::from("-k") + &rng.gen_range(1..=5).to_string()), // Sort via a specified field
+        }
+    }
+
+    args.join(" ")
+}
+
+fn generate_random_lines(count: usize) -> String {
+    let mut rng = rand::thread_rng();
+    let mut lines = Vec::new();
+
+    for _ in 0..count {
+        lines.push(generate_random_string(rng.gen_range(1..=20)));
+    }
+
+    lines.join("\n")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let sort_args = generate_sort_args();
+    let mut args = vec![OsString::from("sort")];
+    args.extend(sort_args.split_whitespace().map(OsString::from));
+
+    // Generate random lines to sort
+    let input_lines = generate_random_lines(10);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_lines));
+
+    // TODO remove once uutils sort supports localization
+    env::set_var("LC_COLLATE", "C");
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, Some(&input_lines)) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "sort",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_split.rs b/fuzz/fuzz_targets/fuzz_split.rs
new file mode 100644
index 00000000000..876c8dd21d4
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_split.rs
@@ -0,0 +1,105 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_split::uumain;
+
+use rand::Rng;
+use std::ffi::OsString;
+
+mod fuzz_common;
+use crate::fuzz_common::{
+    compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd, CommandResult,
+};
+static CMD_PATH: &str = "split";
+
+fn generate_split_args() -> String {
+    let mut rng = rand::thread_rng();
+    let mut args = Vec::new();
+
+    match rng.gen_range(0..=9) {
+        0 => {
+            args.push(String::from("-a")); // Suffix length
+            args.push(rng.gen_range(1..=8).to_string());
+        }
+        1 => {
+            args.push(String::from("--additional-suffix"));
+            args.push(generate_random_string(5)); // Random suffix
+        }
+        2 => {
+            args.push(String::from("-b")); // Bytes per output file
+            args.push(rng.gen_range(1..=1024).to_string() + "K");
+        }
+        3 => {
+            args.push(String::from("-C")); // Line bytes
+            args.push(rng.gen_range(1..=1024).to_string());
+        }
+        4 => args.push(String::from("-d")), // Use numeric suffixes
+        5 => args.push(String::from("-x")), // Use hex suffixes
+        6 => {
+            args.push(String::from("-l")); // Number of lines per output file
+            args.push(rng.gen_range(1..=1000).to_string());
+        }
+        7 => {
+            args.push(String::from("--filter"));
+            args.push(String::from("cat > /dev/null")); // Example filter command
+        }
+        8 => {
+            args.push(String::from("-t")); // Separator
+            args.push(String::from("\n")); // Newline as separator
+        }
+        9 => args.push(String::from("--verbose")), // Verbose
+        _ => (),
+    }
+
+    args.join(" ")
+}
+
+// Function to generate a random string of lines
+fn generate_random_lines(count: usize) -> String {
+    let mut rng = rand::thread_rng();
+    let mut lines = Vec::new();
+
+    for _ in 0..count {
+        lines.push(generate_random_string(rng.gen_range(1..=20)));
+    }
+
+    lines.join("\n")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let split_args = generate_split_args();
+    let mut args = vec![OsString::from("split")];
+    args.extend(split_args.split_whitespace().map(OsString::from));
+
+    let input_lines = generate_random_lines(10);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_lines));
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, Some(&input_lines)) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "split",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_test.rs b/fuzz/fuzz_targets/fuzz_test.rs
index 38cd691b389..bed7ca77088 100644
--- a/fuzz/fuzz_targets/fuzz_test.rs
+++ b/fuzz/fuzz_targets/fuzz_test.rs
@@ -184,9 +184,9 @@ fuzz_target!(|_data: &[u8]| {
         args.push(OsString::from(generate_test_arg()));
     }
 
-    let rust_result = generate_and_run_uumain(&args, uumain);
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
 
-    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false) {
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
         Ok(result) => result,
         Err(error_result) => {
             eprintln!("Failed to run GNU command:");
@@ -203,12 +203,9 @@ fuzz_target!(|_data: &[u8]| {
     compare_result(
         "test",
         &format!("{:?}", &args[1..]),
-        &rust_result.stdout,
-        &gnu_result.stdout,
-        &rust_result.stderr,
-        &gnu_result.stderr,
-        rust_result.exit_code,
-        gnu_result.exit_code,
+        None,
+        &rust_result,
+        &gnu_result,
         false, // Set to true if you want to fail on stderr diff
     );
 });
diff --git a/fuzz/fuzz_targets/fuzz_wc.rs b/fuzz/fuzz_targets/fuzz_wc.rs
new file mode 100644
index 00000000000..dc85bbc3541
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_wc.rs
@@ -0,0 +1,99 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_wc::uumain;
+
+use rand::Rng;
+use std::ffi::OsString;
+
+mod fuzz_common;
+use crate::fuzz_common::{
+    compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd, CommandResult,
+};
+static CMD_PATH: &str = "wc";
+
+fn generate_wc_args() -> String {
+    let mut rng = rand::thread_rng();
+    let arg_count = rng.gen_range(1..=6);
+    let mut args = Vec::new();
+
+    for _ in 0..arg_count {
+        // Introduce a chance to add invalid arguments
+        if rng.gen_bool(0.1) {
+            args.push(generate_random_string(rng.gen_range(1..=20)));
+        } else {
+            match rng.gen_range(0..=5) {
+                0 => args.push(String::from("-c")),
+                1 => args.push(String::from("-m")),
+                2 => args.push(String::from("-l")),
+                3 => args.push(String::from("-L")),
+                4 => args.push(String::from("-w")),
+                // TODO
+                5 => {
+                    args.push(String::from("--files0-from"));
+                    if rng.gen_bool(0.5) {
+                        args.push(generate_random_string(50)); // Longer invalid file name
+                    } else {
+                        args.push(generate_random_string(5));
+                    }
+                }
+                _ => (),
+            }
+        }
+    }
+
+    args.join(" ")
+}
+
+// Function to generate a random string of lines, including invalid ones
+fn generate_random_lines(count: usize) -> String {
+    let mut rng = rand::thread_rng();
+    let mut lines = Vec::new();
+
+    for _ in 0..count {
+        if rng.gen_bool(0.1) {
+            lines.push(generate_random_string(rng.gen_range(1000..=5000))); // Very long invalid line
+        } else {
+            lines.push(generate_random_string(rng.gen_range(1..=20)));
+        }
+    }
+
+    lines.join("\n")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let wc_args = generate_wc_args();
+    let mut args = vec![OsString::from("wc")];
+    args.extend(wc_args.split_whitespace().map(OsString::from));
+
+    let input_lines = generate_random_lines(10);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_lines));
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, Some(&input_lines)) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "wc",
+        &format!("{:?}", &args[1..]),
+        Some(&input_lines),
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/src/uu/arch/Cargo.toml b/src/uu/arch/Cargo.toml
index edb15f846c2..b4d07b26c59 100644
--- a/src/uu/arch/Cargo.toml
+++ b/src/uu/arch/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_arch"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "arch ~ (uutils) display machine architecture"
diff --git a/src/uu/base32/Cargo.toml b/src/uu/base32/Cargo.toml
index 71fbe325fe8..1c27e14cf3f 100644
--- a/src/uu/base32/Cargo.toml
+++ b/src/uu/base32/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_base32"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "base32 ~ (uutils) decode/encode input (base32-encoding)"
diff --git a/src/uu/base32/src/base_common.rs b/src/uu/base32/src/base_common.rs
index 74c3dc80879..68c40287db7 100644
--- a/src/uu/base32/src/base_common.rs
+++ b/src/uu/base32/src/base_common.rs
@@ -6,7 +6,7 @@
 use std::io::{stdout, Read, Write};
 
 use uucore::display::Quotable;
-use uucore::encoding::{wrap_print, Data, Format};
+use uucore::encoding::{wrap_print, Data, EncodeError, Format};
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
 use uucore::format_usage;
 
@@ -87,8 +87,7 @@ pub fn parse_base_cmd_args(
     usage: &str,
 ) -> UResult<Config> {
     let command = base_app(about, usage);
-    let arg_list = args.collect_lossy();
-    Config::from(&command.try_get_matches_from(arg_list)?)
+    Config::from(&command.try_get_matches_from(args)?)
 }
 
 pub fn base_app(about: &'static str, usage: &str) -> Command {
@@ -175,6 +174,7 @@ pub fn handle_input<R: Read>(
                 wrap_print(&data, &s);
                 Ok(())
             }
+            Err(EncodeError::InvalidInput) => Err(USimpleError::new(1, "error: invalid input")),
             Err(_) => Err(USimpleError::new(
                 1,
                 "error: invalid input (length must be multiple of 4 characters)",
diff --git a/src/uu/base64/Cargo.toml b/src/uu/base64/Cargo.toml
index e52665bb692..204b880bf72 100644
--- a/src/uu/base64/Cargo.toml
+++ b/src/uu/base64/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_base64"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "base64 ~ (uutils) decode/encode input (base64-encoding)"
diff --git a/src/uu/basename/Cargo.toml b/src/uu/basename/Cargo.toml
index 3de240e04a9..51202235b15 100644
--- a/src/uu/basename/Cargo.toml
+++ b/src/uu/basename/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_basename"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "basename ~ (uutils) display PATHNAME with leading directory components removed"
diff --git a/src/uu/basenc/Cargo.toml b/src/uu/basenc/Cargo.toml
index 54a5a53a118..26a2364282f 100644
--- a/src/uu/basenc/Cargo.toml
+++ b/src/uu/basenc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_basenc"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "basenc ~ (uutils) decode/encode input"
diff --git a/src/uu/basenc/basenc.md b/src/uu/basenc/basenc.md
index 17916bd4ab8..001babe9e6b 100644
--- a/src/uu/basenc/basenc.md
+++ b/src/uu/basenc/basenc.md
@@ -1,7 +1,7 @@
 # basenc
 
 ```
-basenc [OPTION]... [FILE]"
+basenc [OPTION]... [FILE]
 ```
 
 Encode/decode data and print to standard output
diff --git a/src/uu/cat/Cargo.toml b/src/uu/cat/Cargo.toml
index 14383895e7d..cce6561c084 100644
--- a/src/uu/cat/Cargo.toml
+++ b/src/uu/cat/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_cat"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "cat ~ (uutils) concatenate and display input"
diff --git a/src/uu/cat/src/cat.rs b/src/uu/cat/src/cat.rs
index 34eb265129d..af55442ca5e 100644
--- a/src/uu/cat/src/cat.rs
+++ b/src/uu/cat/src/cat.rs
@@ -174,8 +174,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let number_mode = if matches.get_flag(options::NUMBER_NONBLANK) {
@@ -465,7 +463,6 @@ fn write_fast<R: FdReadable>(handle: &mut InputHandle<R>) -> CatResult<()> {
 
 /// Outputs file contents to stdout in a line-by-line fashion,
 /// propagating any errors that might occur.
-#[allow(clippy::cognitive_complexity)]
 fn write_lines<R: FdReadable>(
     handle: &mut InputHandle<R>,
     options: &OutputOptions,
@@ -484,22 +481,7 @@ fn write_lines<R: FdReadable>(
         while pos < n {
             // skip empty line_number enumerating them if needed
             if in_buf[pos] == b'\n' {
-                // \r followed by \n is printed as ^M when show_ends is enabled, so that \r\n prints as ^M$
-                if state.skipped_carriage_return && options.show_ends {
-                    writer.write_all(b"^M")?;
-                    state.skipped_carriage_return = false;
-                }
-                if !state.at_line_start || !options.squeeze_blank || !state.one_blank_kept {
-                    state.one_blank_kept = true;
-                    if state.at_line_start && options.number == NumberingMode::All {
-                        write!(writer, "{0:6}\t", state.line_number)?;
-                        state.line_number += 1;
-                    }
-                    writer.write_all(options.end_of_line().as_bytes())?;
-                    if handle.is_interactive {
-                        writer.flush()?;
-                    }
-                }
+                write_new_line(&mut writer, options, state, handle.is_interactive)?;
                 state.at_line_start = true;
                 pos += 1;
                 continue;
@@ -516,13 +498,8 @@ fn write_lines<R: FdReadable>(
             }
 
             // print to end of line or end of buffer
-            let offset = if options.show_nonprint {
-                write_nonprint_to_end(&in_buf[pos..], &mut writer, options.tab().as_bytes())
-            } else if options.show_tabs {
-                write_tab_to_end(&in_buf[pos..], &mut writer)
-            } else {
-                write_to_end(&in_buf[pos..], &mut writer)
-            };
+            let offset = write_end(&mut writer, &in_buf[pos..], options);
+
             // end of buffer?
             if offset + pos == in_buf.len() {
                 state.at_line_start = false;
@@ -533,10 +510,11 @@ fn write_lines<R: FdReadable>(
             } else {
                 assert_eq!(in_buf[pos + offset], b'\n');
                 // print suitable end of line
-                writer.write_all(options.end_of_line().as_bytes())?;
-                if handle.is_interactive {
-                    writer.flush()?;
-                }
+                write_end_of_line(
+                    &mut writer,
+                    options.end_of_line().as_bytes(),
+                    handle.is_interactive,
+                )?;
                 state.at_line_start = true;
             }
             pos += offset + 1;
@@ -546,6 +524,41 @@ fn write_lines<R: FdReadable>(
     Ok(())
 }
 
+// \r followed by \n is printed as ^M when show_ends is enabled, so that \r\n prints as ^M$
+fn write_new_line<W: Write>(
+    writer: &mut W,
+    options: &OutputOptions,
+    state: &mut OutputState,
+    is_interactive: bool,
+) -> CatResult<()> {
+    if state.skipped_carriage_return && options.show_ends {
+        writer.write_all(b"^M")?;
+        state.skipped_carriage_return = false;
+    }
+    if !state.at_line_start || !options.squeeze_blank || !state.one_blank_kept {
+        state.one_blank_kept = true;
+        if state.at_line_start && options.number == NumberingMode::All {
+            write!(writer, "{0:6}\t", state.line_number)?;
+            state.line_number += 1;
+        }
+        writer.write_all(options.end_of_line().as_bytes())?;
+        if is_interactive {
+            writer.flush()?;
+        }
+    }
+    Ok(())
+}
+
+fn write_end<W: Write>(writer: &mut W, in_buf: &[u8], options: &OutputOptions) -> usize {
+    if options.show_nonprint {
+        write_nonprint_to_end(in_buf, writer, options.tab().as_bytes())
+    } else if options.show_tabs {
+        write_tab_to_end(in_buf, writer)
+    } else {
+        write_to_end(in_buf, writer)
+    }
+}
+
 // write***_to_end methods
 // Write all symbols till \n or \r or end of buffer is reached
 // We need to stop at \r because it may be written as ^M depending on the byte after and settings;
@@ -612,6 +625,18 @@ fn write_nonprint_to_end<W: Write>(in_buf: &[u8], writer: &mut W, tab: &[u8]) ->
     count
 }
 
+fn write_end_of_line<W: Write>(
+    writer: &mut W,
+    end_of_line: &[u8],
+    is_interactive: bool,
+) -> CatResult<()> {
+    writer.write_all(end_of_line)?;
+    if is_interactive {
+        writer.flush()?;
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use std::io::{stdout, BufWriter};
diff --git a/src/uu/chcon/Cargo.toml b/src/uu/chcon/Cargo.toml
index d21da4cf04d..021e435823a 100644
--- a/src/uu/chcon/Cargo.toml
+++ b/src/uu/chcon/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chcon"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chcon ~ (uutils) change file security context"
diff --git a/src/uu/chgrp/Cargo.toml b/src/uu/chgrp/Cargo.toml
index 79942033f1e..bbad8d31e6e 100644
--- a/src/uu/chgrp/Cargo.toml
+++ b/src/uu/chgrp/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chgrp"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chgrp ~ (uutils) change the group ownership of FILE"
diff --git a/src/uu/chmod/Cargo.toml b/src/uu/chmod/Cargo.toml
index ebfe00fe1c5..e779469deda 100644
--- a/src/uu/chmod/Cargo.toml
+++ b/src/uu/chmod/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chmod"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chmod ~ (uutils) change mode of FILE"
diff --git a/src/uu/chown/Cargo.toml b/src/uu/chown/Cargo.toml
index aab8f20b6c1..dfa9dba32a1 100644
--- a/src/uu/chown/Cargo.toml
+++ b/src/uu/chown/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chown"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chown ~ (uutils) change the ownership of FILE"
diff --git a/src/uu/chroot/Cargo.toml b/src/uu/chroot/Cargo.toml
index a78c89685bf..12533b6542a 100644
--- a/src/uu/chroot/Cargo.toml
+++ b/src/uu/chroot/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_chroot"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chroot ~ (uutils) run COMMAND under a new root directory"
diff --git a/src/uu/chroot/src/chroot.rs b/src/uu/chroot/src/chroot.rs
index 6366775c36d..fb20b0ccc46 100644
--- a/src/uu/chroot/src/chroot.rs
+++ b/src/uu/chroot/src/chroot.rs
@@ -33,8 +33,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
 
     let default_shell: &'static str = "/bin/sh";
@@ -253,7 +251,7 @@ fn set_main_group(group: &str) -> UResult<()> {
     Ok(())
 }
 
-#[cfg(any(target_vendor = "apple", target_os = "freebsd"))]
+#[cfg(any(target_vendor = "apple", target_os = "freebsd", target_os = "openbsd"))]
 fn set_groups(groups: &[libc::gid_t]) -> libc::c_int {
     unsafe { setgroups(groups.len() as libc::c_int, groups.as_ptr()) }
 }
diff --git a/src/uu/cksum/Cargo.toml b/src/uu/cksum/Cargo.toml
index 9a811fafdbc..47b4d73592a 100644
--- a/src/uu/cksum/Cargo.toml
+++ b/src/uu/cksum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_cksum"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "cksum ~ (uutils) display CRC and size of input"
diff --git a/src/uu/cksum/src/cksum.rs b/src/uu/cksum/src/cksum.rs
index 629bb457fd8..36dfbbe1e3d 100644
--- a/src/uu/cksum/src/cksum.rs
+++ b/src/uu/cksum/src/cksum.rs
@@ -4,16 +4,19 @@
 // file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) fname, algo
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{crate_version, value_parser, Arg, ArgAction, Command};
+use hex::decode;
 use hex::encode;
+use std::error::Error;
 use std::ffi::OsStr;
+use std::fmt::Display;
 use std::fs::File;
-use std::io::{self, stdin, BufReader, Read};
+use std::io::{self, stdin, stdout, BufReader, Read, Write};
 use std::iter;
 use std::path::Path;
 use uucore::{
-    error::{FromIo, UResult},
-    format_usage, help_about, help_section, help_usage,
+    error::{FromIo, UError, UResult, USimpleError},
+    format_usage, help_about, help_section, help_usage, show,
     sum::{
         div_ceil, Blake2b, Digest, DigestWriter, Md5, Sha1, Sha224, Sha256, Sha384, Sha512, Sm3,
         BSD, CRC, SYSV,
@@ -36,7 +39,35 @@ const ALGORITHM_OPTIONS_SHA512: &str = "sha512";
 const ALGORITHM_OPTIONS_BLAKE2B: &str = "blake2b";
 const ALGORITHM_OPTIONS_SM3: &str = "sm3";
 
-fn detect_algo(program: &str) -> (&'static str, Box<dyn Digest + 'static>, usize) {
+#[derive(Debug)]
+enum CkSumError {
+    RawMultipleFiles,
+}
+
+impl UError for CkSumError {
+    fn code(&self) -> i32 {
+        match self {
+            Self::RawMultipleFiles => 1,
+        }
+    }
+}
+
+impl Error for CkSumError {}
+
+impl Display for CkSumError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::RawMultipleFiles => {
+                write!(f, "the --raw option is not supported with multiple files")
+            }
+        }
+    }
+}
+
+fn detect_algo(
+    program: &str,
+    length: Option<usize>,
+) -> (&'static str, Box<dyn Digest + 'static>, usize) {
     match program {
         ALGORITHM_OPTIONS_SYSV => (
             ALGORITHM_OPTIONS_SYSV,
@@ -85,7 +116,11 @@ fn detect_algo(program: &str) -> (&'static str, Box<dyn Digest + 'static>, usize
         ),
         ALGORITHM_OPTIONS_BLAKE2B => (
             ALGORITHM_OPTIONS_BLAKE2B,
-            Box::new(Blake2b::new()) as Box<dyn Digest>,
+            Box::new(if let Some(length) = length {
+                Blake2b::with_output_bytes(length)
+            } else {
+                Blake2b::new()
+            }) as Box<dyn Digest>,
             512,
         ),
         ALGORITHM_OPTIONS_SM3 => (
@@ -102,6 +137,8 @@ struct Options {
     digest: Box<dyn Digest + 'static>,
     output_bits: usize,
     untagged: bool,
+    length: Option<usize>,
+    raw: bool,
 }
 
 /// Calculate checksum
@@ -115,6 +152,11 @@ fn cksum<'a, I>(mut options: Options, files: I) -> UResult<()>
 where
     I: Iterator<Item = &'a OsStr>,
 {
+    let files: Vec<_> = files.collect();
+    if options.raw && files.len() > 1 {
+        return Err(Box::new(CkSumError::RawMultipleFiles));
+    }
+
     for filename in files {
         let filename = Path::new(filename);
         let stdin_buf;
@@ -126,13 +168,35 @@ where
         } else if filename.is_dir() {
             Box::new(BufReader::new(io::empty())) as Box<dyn Read>
         } else {
-            file_buf =
-                File::open(filename).map_err_context(|| filename.to_str().unwrap().to_string())?;
+            file_buf = match File::open(filename) {
+                Ok(file) => file,
+                Err(err) => {
+                    show!(err.map_err_context(|| filename.to_string_lossy().to_string()));
+                    continue;
+                }
+            };
             Box::new(file_buf) as Box<dyn Read>
         });
         let (sum, sz) = digest_read(&mut options.digest, &mut file, options.output_bits)
             .map_err_context(|| "failed to read input".to_string())?;
-
+        if filename.is_dir() {
+            show!(USimpleError::new(
+                1,
+                format!("{}: Is a directory", filename.display())
+            ));
+            continue;
+        }
+        if options.raw {
+            let bytes = match options.algo_name {
+                ALGORITHM_OPTIONS_CRC => sum.parse::<u32>().unwrap().to_be_bytes().to_vec(),
+                ALGORITHM_OPTIONS_SYSV | ALGORITHM_OPTIONS_BSD => {
+                    sum.parse::<u16>().unwrap().to_be_bytes().to_vec()
+                }
+                _ => decode(sum).unwrap(),
+            };
+            stdout().write_all(&bytes)?;
+            return Ok(());
+        }
         // The BSD checksum output is 5 digit integer
         let bsd_width = 5;
         match (options.algo_name, not_file) {
@@ -161,7 +225,12 @@ where
             (ALGORITHM_OPTIONS_CRC, true) => println!("{sum} {sz}"),
             (ALGORITHM_OPTIONS_CRC, false) => println!("{sum} {sz} {}", filename.display()),
             (ALGORITHM_OPTIONS_BLAKE2B, _) if !options.untagged => {
-                println!("BLAKE2b ({}) = {sum}", filename.display());
+                if let Some(length) = options.length {
+                    // Multiply by 8 here, as we want to print the length in bits.
+                    println!("BLAKE2b-{} ({}) = {sum}", length * 8, filename.display());
+                } else {
+                    println!("BLAKE2b ({}) = {sum}", filename.display());
+                }
             }
             _ => {
                 if options.untagged {
@@ -217,12 +286,12 @@ mod options {
     pub const ALGORITHM: &str = "algorithm";
     pub const FILE: &str = "file";
     pub const UNTAGGED: &str = "untagged";
+    pub const LENGTH: &str = "length";
+    pub const RAW: &str = "raw";
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let algo_name: &str = match matches.get_one::<String>(options::ALGORITHM) {
@@ -230,12 +299,56 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         None => ALGORITHM_OPTIONS_CRC,
     };
 
-    let (name, algo, bits) = detect_algo(algo_name);
+    let input_length = matches.get_one::<usize>(options::LENGTH);
+    let length = if let Some(length) = input_length {
+        match length.to_owned() {
+            0 => None,
+            n if n % 8 != 0 => {
+                // GNU's implementation seem to use these quotation marks
+                // in their error messages, so we do the same.
+                uucore::show_error!("invalid length: \u{2018}{length}\u{2019}");
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "length is not a multiple of 8",
+                )
+                .into());
+            }
+            n if n > 512 => {
+                uucore::show_error!("invalid length: \u{2018}{length}\u{2019}");
+
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "maximum digest length for \u{2018}BLAKE2b\u{2019} is 512 bits",
+                )
+                .into());
+            }
+            n => {
+                if algo_name != ALGORITHM_OPTIONS_BLAKE2B {
+                    return Err(io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "--length is only supported with --algorithm=blake2b",
+                    )
+                    .into());
+                }
+
+                // Divide by 8, as our blake2b implementation expects bytes
+                // instead of bits.
+                Some(n / 8)
+            }
+        }
+    } else {
+        None
+    };
+
+    let (name, algo, bits) = detect_algo(algo_name, length);
+
     let opts = Options {
         algo_name: name,
         digest: algo,
         output_bits: bits,
+        length,
         untagged: matches.get_flag(options::UNTAGGED),
+        raw: matches.get_flag(options::RAW),
     };
 
     match matches.get_many::<String>(options::FILE) {
@@ -284,5 +397,19 @@ pub fn uu_app() -> Command {
                 .help("create a reversed style checksum, without digest type")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::LENGTH)
+                .long(options::LENGTH)
+                .value_parser(value_parser!(usize))
+                .short('l')
+                .help("digest length in bits; must not exceed the max for the blake2 algorithm and must be a multiple of 8")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::RAW)
+            .long(options::RAW)
+            .help("emit a raw binary digest, not hexadecimal")
+            .action(ArgAction::SetTrue),
+        )
         .after_help(AFTER_HELP)
 }
diff --git a/src/uu/comm/Cargo.toml b/src/uu/comm/Cargo.toml
index 71ed0ad717f..cd759aad246 100644
--- a/src/uu/comm/Cargo.toml
+++ b/src/uu/comm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_comm"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "comm ~ (uutils) compare sorted inputs"
diff --git a/src/uu/comm/src/comm.rs b/src/uu/comm/src/comm.rs
index e6977142ef5..dd49ef53b02 100644
--- a/src/uu/comm/src/comm.rs
+++ b/src/uu/comm/src/comm.rs
@@ -145,8 +145,6 @@ fn open_file(name: &str, line_ending: LineEnding) -> io::Result<LineReader> {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
     let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED));
     let filename1 = matches.get_one::<String>(options::FILE_1).unwrap();
diff --git a/src/uu/cp/Cargo.toml b/src/uu/cp/Cargo.toml
index 179b4668e68..7db6b202bb2 100644
--- a/src/uu/cp/Cargo.toml
+++ b/src/uu/cp/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_cp"
-version = "0.0.23"
+version = "0.0.24"
 authors = [
   "Jordy Dickinson <jordy.dickinson@gmail.com>",
   "Joshua S. Miller <jsmiller@uchicago.edu>",
diff --git a/src/uu/cp/src/copydir.rs b/src/uu/cp/src/copydir.rs
index 763d66c0b03..7a9d797e81c 100644
--- a/src/uu/cp/src/copydir.rs
+++ b/src/uu/cp/src/copydir.rs
@@ -17,7 +17,9 @@ use std::path::{Path, PathBuf, StripPrefixError};
 use indicatif::ProgressBar;
 use uucore::display::Quotable;
 use uucore::error::UIoError;
-use uucore::fs::{canonicalize, FileInformation, MissingHandling, ResolveMode};
+use uucore::fs::{
+    canonicalize, path_ends_with_terminator, FileInformation, MissingHandling, ResolveMode,
+};
 use uucore::show;
 use uucore::show_error;
 use uucore::uio_error;
@@ -170,7 +172,14 @@ impl Entry {
         let mut descendant =
             get_local_to_root_parent(&source_absolute, context.root_parent.as_deref())?;
         if no_target_dir {
-            descendant = descendant.strip_prefix(context.root)?.to_path_buf();
+            let source_is_dir = direntry.path().is_dir();
+            if path_ends_with_terminator(context.target) && source_is_dir {
+                if let Err(e) = std::fs::create_dir_all(context.target) {
+                    eprintln!("Failed to create directory: {}", e);
+                }
+            } else {
+                descendant = descendant.strip_prefix(context.root)?.to_path_buf();
+            }
         }
 
         let local_to_target = context.target.join(descendant);
@@ -324,7 +333,7 @@ pub(crate) fn copy_directory(
     source_in_command_line: bool,
 ) -> CopyResult<()> {
     if !options.recursive {
-        return Err(format!("omitting directory {}", root.quote()).into());
+        return Err(format!("-r not specified; omitting directory {}", root.quote()).into());
     }
 
     // if no-dereference is enabled and this is a symlink, copy it as a file
diff --git a/src/uu/cp/src/cp.rs b/src/uu/cp/src/cp.rs
index 7265e89f12a..28e9b678471 100644
--- a/src/uu/cp/src/cp.rs
+++ b/src/uu/cp/src/cp.rs
@@ -32,8 +32,8 @@ use platform::copy_on_write;
 use uucore::display::Quotable;
 use uucore::error::{set_exit_code, UClapError, UError, UResult, UUsageError};
 use uucore::fs::{
-    canonicalize, is_symlink_loop, paths_refer_to_same_file, FileInformation, MissingHandling,
-    ResolveMode,
+    are_hardlinks_to_same_file, canonicalize, is_symlink_loop, path_ends_with_terminator,
+    paths_refer_to_same_file, FileInformation, MissingHandling, ResolveMode,
 };
 use uucore::{backup_control, update_control};
 // These are exposed for projects (e.g. nushell) that want to create an `Options` value, which
@@ -150,6 +150,7 @@ pub enum TargetType {
 }
 
 /// Copy action to perform
+#[derive(PartialEq)]
 pub enum CopyMode {
     Link,
     SymLink,
@@ -825,6 +826,7 @@ impl Attributes {
         ownership: Preserve::Yes { required: true },
         mode: Preserve::Yes { required: true },
         timestamps: Preserve::Yes { required: true },
+        xattr: Preserve::Yes { required: true },
         ..Self::NONE
     };
 
@@ -1171,6 +1173,9 @@ pub fn copy(sources: &[PathBuf], target: &Path, options: &Options) -> CopyResult
     //
     // key is the source file's information and the value is the destination filepath.
     let mut copied_files: HashMap<FileInformation, PathBuf> = HashMap::with_capacity(sources.len());
+    // remember the copied destinations for further usage.
+    // we can't use copied_files as it is because the key is the source file's information.
+    let mut copied_destinations: HashSet<PathBuf> = HashSet::with_capacity(sources.len());
 
     let progress_bar = if options.progress_bar {
         let pb = ProgressBar::new(disk_usage(sources, options.recursive)?)
@@ -1190,18 +1195,39 @@ pub fn copy(sources: &[PathBuf], target: &Path, options: &Options) -> CopyResult
     for source in sources {
         if seen_sources.contains(source) {
             // FIXME: compare sources by the actual file they point to, not their path. (e.g. dir/file == dir/../dir/file in most cases)
-            show_warning!("source {} specified more than once", source.quote());
-        } else if let Err(error) = copy_source(
-            &progress_bar,
-            source,
-            target,
-            target_type,
-            options,
-            &mut symlinked_files,
-            &mut copied_files,
-        ) {
-            show_error_if_needed(&error);
-            non_fatal_errors = true;
+            show_warning!("source file {} specified more than once", source.quote());
+        } else {
+            let dest = construct_dest_path(source, target, target_type, options)
+                .unwrap_or_else(|_| target.to_path_buf());
+
+            if fs::metadata(&dest).is_ok() && !fs::symlink_metadata(&dest)?.file_type().is_symlink()
+            {
+                // There is already a file and it isn't a symlink (managed in a different place)
+                if copied_destinations.contains(&dest)
+                    && options.backup != BackupMode::NumberedBackup
+                {
+                    // If the target file was already created in this cp call, do not overwrite
+                    return Err(Error::Error(format!(
+                        "will not overwrite just-created '{}' with '{}'",
+                        dest.display(),
+                        source.display()
+                    )));
+                }
+            }
+
+            if let Err(error) = copy_source(
+                &progress_bar,
+                source,
+                target,
+                target_type,
+                options,
+                &mut symlinked_files,
+                &mut copied_files,
+            ) {
+                show_error_if_needed(&error);
+                non_fatal_errors = true;
+            }
+            copied_destinations.insert(dest.clone());
         }
         seen_sources.insert(source);
     }
@@ -1416,7 +1442,7 @@ pub(crate) fn copy_attributes(
     })?;
 
     handle_preserve(&attributes.xattr, || -> CopyResult<()> {
-        #[cfg(unix)]
+        #[cfg(all(unix, not(target_os = "android")))]
         {
             let xattrs = xattr::list(source)?;
             for attr in xattrs {
@@ -1425,7 +1451,7 @@ pub(crate) fn copy_attributes(
                 }
             }
         }
-        #[cfg(not(unix))]
+        #[cfg(not(all(unix, not(target_os = "android"))))]
         {
             // The documentation for GNU cp states:
             //
@@ -1472,7 +1498,11 @@ fn context_for(src: &Path, dest: &Path) -> String {
 /// Implements a simple backup copy for the destination file.
 /// TODO: for the backup, should this function be replaced by `copy_file(...)`?
 fn backup_dest(dest: &Path, backup_path: &Path) -> CopyResult<PathBuf> {
-    fs::copy(dest, backup_path)?;
+    if dest.is_symlink() {
+        fs::rename(dest, backup_path)?;
+    } else {
+        fs::copy(dest, backup_path)?;
+    }
     Ok(backup_path.into())
 }
 
@@ -1481,7 +1511,7 @@ fn backup_dest(dest: &Path, backup_path: &Path) -> CopyResult<PathBuf> {
 ///
 /// Copying to the same file is only allowed if both `--backup` and
 /// `--force` are specified and the file is a regular file.
-fn is_forbidden_copy_to_same_file(
+fn is_forbidden_to_copy_to_same_file(
     source: &Path,
     dest: &Path,
     options: &Options,
@@ -1493,6 +1523,7 @@ fn is_forbidden_copy_to_same_file(
         options.dereference(source_in_command_line) || !source.is_symlink();
     paths_refer_to_same_file(source, dest, dereference_to_compare)
         && !(options.force() && options.backup != BackupMode::NoBackup)
+        && !(dest.is_symlink() && options.backup != BackupMode::NoBackup)
 }
 
 /// Back up, remove, or leave intact the destination file, depending on the options.
@@ -1504,7 +1535,7 @@ fn handle_existing_dest(
 ) -> CopyResult<()> {
     // Disallow copying a file to itself, unless `--force` and
     // `--backup` are both specified.
-    if is_forbidden_copy_to_same_file(source, dest, options, source_in_command_line) {
+    if is_forbidden_to_copy_to_same_file(source, dest, options, source_in_command_line) {
         return Err(format!("{} and {} are the same file", source.quote(), dest.quote()).into());
     }
 
@@ -1672,7 +1703,24 @@ fn copy_file(
         }
     }
 
+    if are_hardlinks_to_same_file(source, dest)
+        && matches!(
+            options.overwrite,
+            OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+        )
+    {
+        fs::remove_file(dest)?;
+    }
+
     if file_or_link_exists(dest) {
+        if are_hardlinks_to_same_file(source, dest)
+            && !options.force()
+            && options.backup == BackupMode::NoBackup
+            && source != dest
+            || (source == dest && options.copy_mode == CopyMode::Link)
+        {
+            return Ok(());
+        }
         handle_existing_dest(source, dest, options, source_in_command_line)?;
     }
 
@@ -1815,7 +1863,13 @@ fn copy_file(
                             symlinked_files,
                         )?;
                     }
-                    update_control::UpdateMode::ReplaceNone => return Ok(()),
+                    update_control::UpdateMode::ReplaceNone => {
+                        if options.debug {
+                            println!("skipped {}", dest.quote());
+                        }
+
+                        return Ok(());
+                    }
                     update_control::UpdateMode::ReplaceIfOlder => {
                         let dest_metadata = fs::symlink_metadata(dest)?;
 
@@ -1896,6 +1950,7 @@ fn handle_no_preserve_mode(options: &Options, org_mode: u32) -> u32 {
             target_os = "macos",
             target_os = "macos-12",
             target_os = "freebsd",
+            target_os = "redox",
         )))]
         {
             const MODE_RW_UGO: u32 = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
@@ -1911,6 +1966,7 @@ fn handle_no_preserve_mode(options: &Options, org_mode: u32) -> u32 {
             target_os = "macos",
             target_os = "macos-12",
             target_os = "freebsd",
+            target_os = "redox",
         ))]
         {
             const MODE_RW_UGO: u32 =
@@ -1942,6 +1998,10 @@ fn copy_helper(
         fs::create_dir_all(parent)?;
     }
 
+    if path_ends_with_terminator(dest) && !dest.is_dir() {
+        return Err(Error::NotADirectory(dest.to_path_buf()));
+    }
+
     if source.as_os_str() == "/dev/null" {
         /* workaround a limitation of fs::copy
          * https://github.com/rust-lang/rust/issues/79390
diff --git a/src/uu/csplit/Cargo.toml b/src/uu/csplit/Cargo.toml
index e68b1258253..5e2f310cb51 100644
--- a/src/uu/csplit/Cargo.toml
+++ b/src/uu/csplit/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_csplit"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "csplit ~ (uutils) Output pieces of FILE separated by PATTERN(s) to files 'xx00', 'xx01', ..., and output byte counts of each piece to standard output"
diff --git a/src/uu/csplit/src/csplit.rs b/src/uu/csplit/src/csplit.rs
index d33be1a5d54..00bebbf4dcb 100644
--- a/src/uu/csplit/src/csplit.rs
+++ b/src/uu/csplit/src/csplit.rs
@@ -552,8 +552,6 @@ where
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     // get the file to split
diff --git a/src/uu/csplit/src/patterns.rs b/src/uu/csplit/src/patterns.rs
index 8e7b76e6bb4..6e7483b7f9f 100644
--- a/src/uu/csplit/src/patterns.rs
+++ b/src/uu/csplit/src/patterns.rs
@@ -196,7 +196,7 @@ mod tests {
             .collect();
         let patterns = get_patterns(input.as_slice()).unwrap();
         assert_eq!(patterns.len(), 3);
-        match patterns.get(0) {
+        match patterns.first() {
             Some(Pattern::UpToLine(24, ExecutePattern::Times(1))) => (),
             _ => panic!("expected UpToLine pattern"),
         };
@@ -227,7 +227,7 @@ mod tests {
         .collect();
         let patterns = get_patterns(input.as_slice()).unwrap();
         assert_eq!(patterns.len(), 5);
-        match patterns.get(0) {
+        match patterns.first() {
             Some(Pattern::UpToMatch(reg, 0, ExecutePattern::Times(1))) => {
                 let parsed_reg = format!("{reg}");
                 assert_eq!(parsed_reg, "test1.*end$");
@@ -281,7 +281,7 @@ mod tests {
         .collect();
         let patterns = get_patterns(input.as_slice()).unwrap();
         assert_eq!(patterns.len(), 5);
-        match patterns.get(0) {
+        match patterns.first() {
             Some(Pattern::SkipToMatch(reg, 0, ExecutePattern::Times(1))) => {
                 let parsed_reg = format!("{reg}");
                 assert_eq!(parsed_reg, "test1.*end$");
diff --git a/src/uu/cut/Cargo.toml b/src/uu/cut/Cargo.toml
index e572d987ec4..c98bec5bc42 100644
--- a/src/uu/cut/Cargo.toml
+++ b/src/uu/cut/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_cut"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "cut ~ (uutils) display byte/field columns of input lines"
diff --git a/src/uu/cut/cut.md b/src/uu/cut/cut.md
index 972fcb6322e..5c21d23dcf9 100644
--- a/src/uu/cut/cut.md
+++ b/src/uu/cut/cut.md
@@ -3,7 +3,7 @@
 <!-- spell-checker:ignore sourcefile sourcefiles -->
 
 ```
-cut [-d|-w] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+
+cut OPTION... [FILE]...
 ```
 
 Prints specified byte or field columns from each line of stdin or the input files
diff --git a/src/uu/cut/src/cut.rs b/src/uu/cut/src/cut.rs
index 05e8bc6e424..2a3196d002e 100644
--- a/src/uu/cut/src/cut.rs
+++ b/src/uu/cut/src/cut.rs
@@ -17,7 +17,7 @@ use uucore::line_ending::LineEnding;
 use self::searcher::Searcher;
 use matcher::{ExactMatcher, Matcher, WhitespaceMatcher};
 use uucore::ranges::Range;
-use uucore::{format_usage, help_about, help_section, help_usage, show, show_error, show_if_err};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error, show_if_err};
 
 mod matcher;
 mod searcher;
@@ -426,7 +426,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                             delim = "";
                         }
                         if delim.chars().count() > 1 {
-                            Err("invalid input: The '--delimiter' ('-d') option expects empty or 1 character long, but was provided a value 2 characters or longer".into())
+                            Err("the delimiter must be a single character".into())
                         } else {
                             let delim = if delim.is_empty() {
                                 "\0".to_owned()
@@ -510,6 +510,7 @@ pub fn uu_app() -> Command {
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::BYTES)
                 .short('b')
diff --git a/src/uu/date/Cargo.toml b/src/uu/date/Cargo.toml
index c5682f83e5a..11ad64bbef7 100644
--- a/src/uu/date/Cargo.toml
+++ b/src/uu/date/Cargo.toml
@@ -1,7 +1,7 @@
 # spell-checker:ignore datetime
 [package]
 name = "uu_date"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "date ~ (uutils) display or set the current time"
diff --git a/src/uu/date/src/date.rs b/src/uu/date/src/date.rs
index b5ab8993acd..ee3c7bfdfae 100644
--- a/src/uu/date/src/date.rs
+++ b/src/uu/date/src/date.rs
@@ -16,7 +16,6 @@ use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 use uucore::display::Quotable;
-#[cfg(not(any(target_os = "redox")))]
 use uucore::error::FromIo;
 use uucore::error::{UResult, USimpleError};
 use uucore::{format_usage, help_about, help_usage, show};
diff --git a/src/uu/dd/Cargo.toml b/src/uu/dd/Cargo.toml
index 7db05b422f3..1dbb37bde55 100644
--- a/src/uu/dd/Cargo.toml
+++ b/src/uu/dd/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_dd"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "dd ~ (uutils) copy and convert files"
@@ -18,7 +18,7 @@ path = "src/dd.rs"
 clap = { workspace = true }
 gcd = { workspace = true }
 libc = { workspace = true }
-uucore = { workspace = true, features = ["memo"] }
+uucore = { workspace = true, features = ["format", "quoting-style"] }
 
 [target.'cfg(any(target_os = "linux"))'.dependencies]
 nix = { workspace = true, features = ["fs"] }
diff --git a/src/uu/dd/src/bufferedoutput.rs b/src/uu/dd/src/bufferedoutput.rs
new file mode 100644
index 00000000000..6ac3b430046
--- /dev/null
+++ b/src/uu/dd/src/bufferedoutput.rs
@@ -0,0 +1,206 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//
+// spell-checker:ignore wstat towrite cdefg bufferedoutput
+//! Buffer partial output blocks until they are completed.
+//!
+//! Use the [`BufferedOutput`] struct to create a buffered form of the
+//! [`Output`] writer.
+use crate::{Output, WriteStat};
+
+/// Buffer partial output blocks until they are completed.
+///
+/// Complete blocks are written immediately to the inner [`Output`],
+/// but partial blocks are stored in an internal buffer until they are
+/// completed.
+pub(crate) struct BufferedOutput<'a> {
+    /// The unbuffered inner block writer.
+    inner: Output<'a>,
+
+    /// The internal buffer that stores a partial block.
+    ///
+    /// The size of this buffer is always less than the output block
+    /// size (that is, the value of the `obs` command-line option).
+    buf: Vec<u8>,
+}
+
+impl<'a> BufferedOutput<'a> {
+    /// Add partial block buffering to the given block writer.
+    ///
+    /// The internal buffer size is at most the value of `obs` as
+    /// defined in `inner`.
+    pub(crate) fn new(inner: Output<'a>) -> Self {
+        let obs = inner.settings.obs;
+        Self {
+            inner,
+            buf: Vec::with_capacity(obs),
+        }
+    }
+
+    pub(crate) fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+        self.inner.discard_cache(offset, len);
+    }
+
+    /// Flush the partial block stored in the internal buffer.
+    pub(crate) fn flush(&mut self) -> std::io::Result<WriteStat> {
+        let wstat = self.inner.write_blocks(&self.buf)?;
+        let n = wstat.bytes_total.try_into().unwrap();
+        self.buf.drain(0..n);
+        Ok(wstat)
+    }
+
+    /// Synchronize the inner block writer.
+    pub(crate) fn sync(&mut self) -> std::io::Result<()> {
+        self.inner.sync()
+    }
+
+    /// Truncate the underlying file to the current stream position, if possible.
+    pub(crate) fn truncate(&mut self) -> std::io::Result<()> {
+        self.inner.dst.truncate()
+    }
+
+    /// Write the given bytes one block at a time.
+    ///
+    /// Only complete blocks will be written. Partial blocks will be
+    /// buffered until enough bytes have been provided to complete a
+    /// block. The returned [`WriteStat`] object will include the
+    /// number of blocks written during execution of this function.
+    pub(crate) fn write_blocks(&mut self, buf: &[u8]) -> std::io::Result<WriteStat> {
+        // Split the incoming buffer into two parts: the bytes to write
+        // and the bytes to buffer for next time.
+        //
+        // If `buf` does not include enough bytes to form a full block,
+        // just buffer the whole thing and write zero blocks.
+        let n = self.buf.len() + buf.len();
+        let rem = n % self.inner.settings.obs;
+        let i = buf.len().saturating_sub(rem);
+        let (to_write, to_buffer) = buf.split_at(i);
+
+        // Concatenate the old partial block with the new bytes to form
+        // some number of complete blocks.
+        self.buf.extend_from_slice(to_write);
+
+        // Write all complete blocks to the inner block writer.
+        //
+        // For example, if the output block size were 3, the buffered
+        // partial block were `b"ab"` and the new incoming bytes were
+        // `b"cdefg"`, then we would write blocks `b"abc"` and
+        // b`"def"` to the inner block writer.
+        let wstat = self.inner.write_blocks(&self.buf)?;
+
+        // Buffer any remaining bytes as a partial block.
+        //
+        // Continuing the example above, the last byte `b"g"` would be
+        // buffered as a partial block until the next call to
+        // `write_blocks()`.
+        self.buf.clear();
+        self.buf.extend_from_slice(to_buffer);
+
+        Ok(wstat)
+    }
+}
+
+#[cfg(unix)]
+#[cfg(test)]
+mod tests {
+    use crate::bufferedoutput::BufferedOutput;
+    use crate::{Dest, Output, Settings};
+
+    #[test]
+    fn test_buffered_output_write_blocks_empty() {
+        let settings = Settings {
+            obs: 3,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput::new(inner);
+        let wstat = output.write_blocks(&[]).unwrap();
+        assert_eq!(wstat.writes_complete, 0);
+        assert_eq!(wstat.writes_partial, 0);
+        assert_eq!(wstat.bytes_total, 0);
+        assert_eq!(output.buf, vec![]);
+    }
+
+    #[test]
+    fn test_buffered_output_write_blocks_partial() {
+        let settings = Settings {
+            obs: 3,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput::new(inner);
+        let wstat = output.write_blocks(b"ab").unwrap();
+        assert_eq!(wstat.writes_complete, 0);
+        assert_eq!(wstat.writes_partial, 0);
+        assert_eq!(wstat.bytes_total, 0);
+        assert_eq!(output.buf, b"ab");
+    }
+
+    #[test]
+    fn test_buffered_output_write_blocks_complete() {
+        let settings = Settings {
+            obs: 3,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput::new(inner);
+        let wstat = output.write_blocks(b"abcd").unwrap();
+        assert_eq!(wstat.writes_complete, 1);
+        assert_eq!(wstat.writes_partial, 0);
+        assert_eq!(wstat.bytes_total, 3);
+        assert_eq!(output.buf, b"d");
+    }
+
+    #[test]
+    fn test_buffered_output_write_blocks_append() {
+        let settings = Settings {
+            obs: 3,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput {
+            inner,
+            buf: b"ab".to_vec(),
+        };
+        let wstat = output.write_blocks(b"cdefg").unwrap();
+        assert_eq!(wstat.writes_complete, 2);
+        assert_eq!(wstat.writes_partial, 0);
+        assert_eq!(wstat.bytes_total, 6);
+        assert_eq!(output.buf, b"g");
+    }
+
+    #[test]
+    fn test_buffered_output_flush() {
+        let settings = Settings {
+            obs: 10,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput {
+            inner,
+            buf: b"abc".to_vec(),
+        };
+        let wstat = output.flush().unwrap();
+        assert_eq!(wstat.writes_complete, 0);
+        assert_eq!(wstat.writes_partial, 1);
+        assert_eq!(wstat.bytes_total, 3);
+        assert_eq!(output.buf, vec![]);
+    }
+}
diff --git a/src/uu/dd/src/dd.rs b/src/uu/dd/src/dd.rs
index b79ae22da4e..07a754deb51 100644
--- a/src/uu/dd/src/dd.rs
+++ b/src/uu/dd/src/dd.rs
@@ -3,23 +3,21 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore fname, ftype, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rremain, rsofar, rstat, sigusr, wlen, wstat seekable oconv canonicalized fadvise Fadvise FADV DONTNEED ESPIPE
+// spell-checker:ignore fname, ftype, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rremain, rsofar, rstat, sigusr, wlen, wstat seekable oconv canonicalized fadvise Fadvise FADV DONTNEED ESPIPE bufferedoutput
 
+mod blocks;
+mod bufferedoutput;
+mod conversion_tables;
 mod datastructures;
-use datastructures::*;
-
+mod numbers;
 mod parseargs;
-use parseargs::Parser;
-
-mod conversion_tables;
-
 mod progress;
-use progress::{gen_prog_updater, ProgUpdate, ReadStat, StatusLevel, WriteStat};
 
-mod blocks;
+use crate::bufferedoutput::BufferedOutput;
 use blocks::conv_block_unblock_helper;
-
-mod numbers;
+use datastructures::*;
+use parseargs::Parser;
+use progress::{gen_prog_updater, ProgUpdate, ReadStat, StatusLevel, WriteStat};
 
 use std::cmp;
 use std::env;
@@ -52,9 +50,9 @@ use uucore::display::Quotable;
 #[cfg(unix)]
 use uucore::error::set_exit_code;
 use uucore::error::{FromIo, UResult};
-use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 #[cfg(target_os = "linux")]
-use uucore::{show, show_if_err};
+use uucore::show_if_err;
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 
 const ABOUT: &str = help_about!("dd.md");
 const AFTER_HELP: &str = help_section!("after help", "dd.md");
@@ -76,6 +74,8 @@ struct Settings {
     oconv: OConvFlags,
     oflags: OFlags,
     status: Option<StatusLevel>,
+    /// Whether the output writer should buffer partial blocks until complete.
+    buffered: bool,
 }
 
 /// A timer which triggers on a given interval
@@ -128,6 +128,12 @@ enum Num {
     Bytes(u64),
 }
 
+impl Default for Num {
+    fn default() -> Self {
+        Self::Blocks(0)
+    }
+}
+
 impl Num {
     fn force_bytes_if(self, force: bool) -> Self {
         match self {
@@ -796,6 +802,68 @@ impl<'a> Output<'a> {
             Ok(())
         }
     }
+
+    /// Truncate the underlying file to the current stream position, if possible.
+    fn truncate(&mut self) -> std::io::Result<()> {
+        self.dst.truncate()
+    }
+}
+
+/// The block writer either with or without partial block buffering.
+enum BlockWriter<'a> {
+    /// Block writer with partial block buffering.
+    ///
+    /// Partial blocks are buffered until completed.
+    Buffered(BufferedOutput<'a>),
+
+    /// Block writer without partial block buffering.
+    ///
+    /// Partial blocks are written immediately.
+    Unbuffered(Output<'a>),
+}
+
+impl<'a> BlockWriter<'a> {
+    fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+        match self {
+            Self::Unbuffered(o) => o.discard_cache(offset, len),
+            Self::Buffered(o) => o.discard_cache(offset, len),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<WriteStat> {
+        match self {
+            Self::Unbuffered(_) => Ok(WriteStat::default()),
+            Self::Buffered(o) => o.flush(),
+        }
+    }
+
+    fn sync(&mut self) -> io::Result<()> {
+        match self {
+            Self::Unbuffered(o) => o.sync(),
+            Self::Buffered(o) => o.sync(),
+        }
+    }
+
+    /// Truncate the file to the final cursor location.
+    fn truncate(&mut self) {
+        // Calling `set_len()` may result in an error (for example,
+        // when calling it on `/dev/null`), but we don't want to
+        // terminate the process when that happens. Instead, we
+        // suppress the error by calling `Result::ok()`. This matches
+        // the behavior of GNU `dd` when given the command-line
+        // argument `of=/dev/null`.
+        match self {
+            Self::Unbuffered(o) => o.truncate().ok(),
+            Self::Buffered(o) => o.truncate().ok(),
+        };
+    }
+
+    fn write_blocks(&mut self, buf: &[u8]) -> std::io::Result<WriteStat> {
+        match self {
+            Self::Unbuffered(o) => o.write_blocks(buf),
+            Self::Buffered(o) => o.write_blocks(buf),
+        }
+    }
 }
 
 /// Copy the given input data to this output, consuming both.
@@ -809,7 +877,7 @@ impl<'a> Output<'a> {
 ///
 /// If there is a problem reading from the input or writing to
 /// this output.
-fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
+fn dd_copy(mut i: Input, o: Output) -> std::io::Result<()> {
     // The read and write statistics.
     //
     // These objects are counters, initialized to zero. After each
@@ -846,6 +914,9 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
     let (prog_tx, rx) = mpsc::channel();
     let output_thread = thread::spawn(gen_prog_updater(rx, i.settings.status));
 
+    // Whether to truncate the output file after all blocks have been written.
+    let truncate = !o.settings.oconv.notrunc;
+
     // Optimization: if no blocks are to be written, then don't
     // bother allocating any buffers.
     if let Some(Num::Blocks(0) | Num::Bytes(0)) = i.settings.count {
@@ -870,7 +941,15 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
             let len = o.dst.len()?.try_into().unwrap();
             o.discard_cache(offset, len);
         }
-        return finalize(&mut o, rstat, wstat, start, &prog_tx, output_thread);
+        return finalize(
+            BlockWriter::Unbuffered(o),
+            rstat,
+            wstat,
+            start,
+            &prog_tx,
+            output_thread,
+            truncate,
+        );
     };
 
     // Create a common buffer with a capacity of the block size.
@@ -890,13 +969,23 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
     let mut read_offset = 0;
     let mut write_offset = 0;
 
+    let input_nocache = i.settings.iflags.nocache;
+    let output_nocache = o.settings.oflags.nocache;
+
+    // Add partial block buffering, if needed.
+    let mut o = if o.settings.buffered {
+        BlockWriter::Buffered(BufferedOutput::new(o))
+    } else {
+        BlockWriter::Unbuffered(o)
+    };
+
     // The main read/write loop.
     //
     // Each iteration reads blocks from the input and writes
     // blocks to this output. Read/write statistics are updated on
     // each iteration and cumulative statistics are reported to
     // the progress reporting thread.
-    while below_count_limit(&i.settings.count, &rstat, &wstat) {
+    while below_count_limit(&i.settings.count, &rstat) {
         // Read a block from the input then write the block to the output.
         //
         // As an optimization, make an educated guess about the
@@ -914,7 +1003,7 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
         //
         // TODO Better error handling for overflowing `offset` and `len`.
         let read_len = rstat_update.bytes_total;
-        if i.settings.iflags.nocache {
+        if input_nocache {
             let offset = read_offset.try_into().unwrap();
             let len = read_len.try_into().unwrap();
             i.discard_cache(offset, len);
@@ -926,7 +1015,7 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
         //
         // TODO Better error handling for overflowing `offset` and `len`.
         let write_len = wstat_update.bytes_total;
-        if o.settings.oflags.nocache {
+        if output_nocache {
             let offset = write_offset.try_into().unwrap();
             let len = write_len.try_into().unwrap();
             o.discard_cache(offset, len);
@@ -946,34 +1035,33 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
             prog_tx.send(prog_update).unwrap_or(());
         }
     }
-    finalize(&mut o, rstat, wstat, start, &prog_tx, output_thread)
+    finalize(o, rstat, wstat, start, &prog_tx, output_thread, truncate)
 }
 
 /// Flush output, print final stats, and join with the progress thread.
 fn finalize<T>(
-    output: &mut Output,
+    mut output: BlockWriter,
     rstat: ReadStat,
     wstat: WriteStat,
     start: Instant,
     prog_tx: &mpsc::Sender<ProgUpdate>,
     output_thread: thread::JoinHandle<T>,
+    truncate: bool,
 ) -> std::io::Result<()> {
-    // Flush the output, if configured to do so.
+    // Flush the output in case a partial write has been buffered but
+    // not yet written.
+    let wstat_update = output.flush()?;
+
+    // Sync the output, if configured to do so.
     output.sync()?;
 
     // Truncate the file to the final cursor location.
-    //
-    // Calling `set_len()` may result in an error (for example,
-    // when calling it on `/dev/null`), but we don't want to
-    // terminate the process when that happens. Instead, we
-    // suppress the error by calling `Result::ok()`. This matches
-    // the behavior of GNU `dd` when given the command-line
-    // argument `of=/dev/null`.
-    if !output.settings.oconv.notrunc {
-        output.dst.truncate().ok();
+    if truncate {
+        output.truncate();
     }
 
     // Print the final read/write statistics.
+    let wstat = wstat + wstat_update;
     let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), true);
     prog_tx.send(prog_update).unwrap_or(());
     // Wait for the output thread to finish
@@ -1093,7 +1181,7 @@ fn calc_loop_bsize(
             cmp::min(ideal_bsize as u64, rremain * ibs as u64) as usize
         }
         Some(Num::Bytes(bmax)) => {
-            let bmax: u128 = (*bmax).try_into().unwrap();
+            let bmax: u128 = (*bmax).into();
             let bremain: u128 = bmax - wstat.bytes_total;
             cmp::min(ideal_bsize as u128, bremain) as usize
         }
@@ -1103,16 +1191,10 @@ fn calc_loop_bsize(
 
 // Decide if the current progress is below a count=N limit or return
 // true if no such limit is set.
-fn below_count_limit(count: &Option<Num>, rstat: &ReadStat, wstat: &WriteStat) -> bool {
+fn below_count_limit(count: &Option<Num>, rstat: &ReadStat) -> bool {
     match count {
-        Some(Num::Blocks(n)) => {
-            let n = *n;
-            rstat.reads_complete + rstat.reads_partial <= n
-        }
-        Some(Num::Bytes(n)) => {
-            let n = (*n).try_into().unwrap();
-            wstat.bytes_total <= n
-        }
+        Some(Num::Blocks(n)) => rstat.reads_complete + rstat.reads_partial < *n,
+        Some(Num::Bytes(n)) => rstat.bytes_total < *n,
         None => true,
     }
 }
@@ -1185,8 +1267,6 @@ fn is_fifo(filename: &str) -> bool {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let settings: Settings = Parser::new().parse(
diff --git a/src/uu/dd/src/parseargs.rs b/src/uu/dd/src/parseargs.rs
index 0ff6e752c02..60ce9a6971f 100644
--- a/src/uu/dd/src/parseargs.rs
+++ b/src/uu/dd/src/parseargs.rs
@@ -35,41 +35,28 @@ pub enum ParseError {
 }
 
 /// Contains a temporary state during parsing of the arguments
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Default)]
 pub struct Parser {
     infile: Option<String>,
     outfile: Option<String>,
-    ibs: usize,
-    obs: usize,
+    /// The block size option specified on the command-line, if any.
+    bs: Option<usize>,
+    /// The input block size option specified on the command-line, if any.
+    ibs: Option<usize>,
+    /// The output block size option specified on the command-line, if any.
+    obs: Option<usize>,
     cbs: Option<usize>,
     skip: Num,
     seek: Num,
     count: Option<Num>,
     conv: ConvFlags,
+    /// Whether a data-transforming `conv` option has been specified.
+    is_conv_specified: bool,
     iflag: IFlags,
     oflag: OFlags,
     status: Option<StatusLevel>,
 }
 
-impl Default for Parser {
-    fn default() -> Self {
-        Self {
-            ibs: 512,
-            obs: 512,
-            cbs: None,
-            infile: None,
-            outfile: None,
-            skip: Num::Blocks(0),
-            seek: Num::Blocks(0),
-            count: None,
-            conv: ConvFlags::default(),
-            iflag: IFlags::default(),
-            oflag: OFlags::default(),
-            status: None,
-        }
-    }
-}
-
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ConvFlags {
     ascii: bool,
@@ -212,15 +199,34 @@ impl Parser {
             fsync: conv.fsync,
         };
 
+        // Input and output block sizes.
+        //
+        // The `bs` option takes precedence. If either is not
+        // provided, `ibs` and `obs` are each 512 bytes by default.
+        let (ibs, obs) = match self.bs {
+            None => (self.ibs.unwrap_or(512), self.obs.unwrap_or(512)),
+            Some(bs) => (bs, bs),
+        };
+
+        // Whether to buffer partial output blocks until they are completed.
+        //
+        // From the GNU `dd` documentation for the `bs=BYTES` option:
+        //
+        // > [...] if no data-transforming 'conv' option is specified,
+        // > input is copied to the output as soon as it's read, even if
+        // > it is smaller than the block size.
+        //
+        let buffered = self.bs.is_none() || self.is_conv_specified;
+
         let skip = self
             .skip
             .force_bytes_if(self.iflag.skip_bytes)
-            .to_bytes(self.ibs as u64);
+            .to_bytes(ibs as u64);
 
         let seek = self
             .seek
             .force_bytes_if(self.oflag.seek_bytes)
-            .to_bytes(self.obs as u64);
+            .to_bytes(obs as u64);
 
         let count = self.count.map(|c| c.force_bytes_if(self.iflag.count_bytes));
 
@@ -230,8 +236,9 @@ impl Parser {
             count,
             iconv,
             oconv,
-            ibs: self.ibs,
-            obs: self.obs,
+            ibs,
+            obs,
+            buffered,
             infile: self.infile,
             outfile: self.outfile,
             iflags: self.iflag,
@@ -244,18 +251,17 @@ impl Parser {
         match operand.split_once('=') {
             None => return Err(ParseError::UnrecognizedOperand(operand.to_string())),
             Some((k, v)) => match k {
-                "bs" => {
-                    let bs = Self::parse_bytes(k, v)?;
-                    self.ibs = bs;
-                    self.obs = bs;
-                }
+                "bs" => self.bs = Some(Self::parse_bytes(k, v)?),
                 "cbs" => self.cbs = Some(Self::parse_bytes(k, v)?),
-                "conv" => self.parse_conv_flags(v)?,
+                "conv" => {
+                    self.is_conv_specified = true;
+                    self.parse_conv_flags(v)?;
+                }
                 "count" => self.count = Some(Self::parse_n(v)?),
-                "ibs" => self.ibs = Self::parse_bytes(k, v)?,
+                "ibs" => self.ibs = Some(Self::parse_bytes(k, v)?),
                 "if" => self.infile = Some(v.to_string()),
                 "iflag" => self.parse_input_flags(v)?,
-                "obs" => self.obs = Self::parse_bytes(k, v)?,
+                "obs" => self.obs = Some(Self::parse_bytes(k, v)?),
                 "of" => self.outfile = Some(v.to_string()),
                 "oflag" => self.parse_output_flags(v)?,
                 "seek" | "oseek" => self.seek = Self::parse_n(v)?,
diff --git a/src/uu/dd/src/parseargs/unit_tests.rs b/src/uu/dd/src/parseargs/unit_tests.rs
index 142e49fd0ba..51b0933e926 100644
--- a/src/uu/dd/src/parseargs/unit_tests.rs
+++ b/src/uu/dd/src/parseargs/unit_tests.rs
@@ -358,6 +358,7 @@ fn parse_icf_tokens_remaining() {
                 fsync: true,
                 ..Default::default()
             },
+            is_conv_specified: true,
             ..Default::default()
         })
     );
diff --git a/src/uu/dd/src/progress.rs b/src/uu/dd/src/progress.rs
index 4fe04cb0e67..238b2ab39a2 100644
--- a/src/uu/dd/src/progress.rs
+++ b/src/uu/dd/src/progress.rs
@@ -13,8 +13,10 @@ use std::io::Write;
 use std::sync::mpsc;
 use std::time::Duration;
 
-use uucore::error::UResult;
-use uucore::memo::sprintf;
+use uucore::{
+    error::UResult,
+    format::num_format::{FloatVariant, Formatter},
+};
 
 use crate::numbers::{to_magnitude_and_suffix, SuffixType};
 
@@ -152,7 +154,14 @@ impl ProgUpdate {
         let (carriage_return, newline) = if rewrite { ("\r", "") } else { ("", "\n") };
 
         // The duration should be formatted as in `printf %g`.
-        let duration_str = sprintf("%g", &[duration.to_string()])?;
+        let mut duration_str = Vec::new();
+        uucore::format::num_format::Float {
+            variant: FloatVariant::Shortest,
+            ..Default::default()
+        }
+        .fmt(&mut duration_str, duration)?;
+        // We assume that printf will output valid UTF-8
+        let duration_str = std::str::from_utf8(&duration_str).unwrap();
 
         // If the number of bytes written is sufficiently large, then
         // print a more concise representation of the number, like
@@ -379,6 +388,17 @@ impl std::ops::AddAssign for WriteStat {
     }
 }
 
+impl std::ops::Add for WriteStat {
+    type Output = Self;
+    fn add(self, other: Self) -> Self {
+        Self {
+            writes_complete: self.writes_complete + other.writes_complete,
+            writes_partial: self.writes_partial + other.writes_partial,
+            bytes_total: self.bytes_total + other.bytes_total,
+        }
+    }
+}
+
 /// How much detail to report when printing transfer statistics.
 ///
 /// This corresponds to the available settings of the `status`
diff --git a/src/uu/df/Cargo.toml b/src/uu/df/Cargo.toml
index d074e6be74f..e9aa192e820 100644
--- a/src/uu/df/Cargo.toml
+++ b/src/uu/df/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_df"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "df ~ (uutils) display file system information"
diff --git a/src/uu/df/src/df.rs b/src/uu/df/src/df.rs
index 78325f3d2ad..c21ba98471a 100644
--- a/src/uu/df/src/df.rs
+++ b/src/uu/df/src/df.rs
@@ -336,7 +336,7 @@ fn filter_mount_list(vmi: Vec<MountInfo>, opt: &Options) -> Vec<MountInfo> {
 fn get_all_filesystems(opt: &Options) -> Result<Vec<Filesystem>, std::io::Error> {
     // Run a sync call before any operation if so instructed.
     if opt.sync {
-        #[cfg(not(windows))]
+        #[cfg(not(any(windows, target_os = "redox")))]
         unsafe {
             #[cfg(not(target_os = "android"))]
             uucore::libc::sync();
diff --git a/src/uu/dir/Cargo.toml b/src/uu/dir/Cargo.toml
index 628c0fb8cfe..b82298ce319 100644
--- a/src/uu/dir/Cargo.toml
+++ b/src/uu/dir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_dir"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shortcut to ls -C -b"
diff --git a/src/uu/dircolors/Cargo.toml b/src/uu/dircolors/Cargo.toml
index 6099b5a8428..1bf87c22cc1 100644
--- a/src/uu/dircolors/Cargo.toml
+++ b/src/uu/dircolors/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_dircolors"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "dircolors ~ (uutils) display commands to set LS_COLORS"
@@ -16,7 +16,7 @@ path = "src/dircolors.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["colors"] }
 
 [[bin]]
 name = "dircolors"
diff --git a/src/uu/dircolors/src/colors.rs b/src/uu/dircolors/src/colors.rs
deleted file mode 100644
index c0a981db89c..00000000000
--- a/src/uu/dircolors/src/colors.rs
+++ /dev/null
@@ -1,225 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) EIGHTBIT ETERM MULTIHARDLINK cpio dtterm jfbterm konsole kterm mlterm rmvb rxvt stat'able svgz tmux webm xspf COLORTERM tzst avif tzst mjpg mjpeg webp dpkg rpmnew rpmorig rpmsave
-
-pub const INTERNAL_DB: &str = r#"# Configuration file for dircolors, a utility to help you set the
-# LS_COLORS environment variable used by GNU ls with the --color option.
-# Copyright (C) 1996-2022 Free Software Foundation, Inc.
-# Copying and distribution of this file, with or without modification,
-# are permitted provided the copyright notice and this notice are preserved.
-# The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the
-# slackware version of dircolors) are recognized but ignored.
-# Global config options can be specified before TERM or COLORTERM entries
-# Below are TERM or COLORTERM entries, which can be glob patterns, which
-# restrict following config to systems with matching environment variables.
-COLORTERM ?*
-TERM Eterm
-TERM ansi
-TERM *color*
-TERM con[0-9]*x[0-9]*
-TERM cons25
-TERM console
-TERM cygwin
-TERM *direct*
-TERM dtterm
-TERM gnome
-TERM hurd
-TERM jfbterm
-TERM konsole
-TERM kterm
-TERM linux
-TERM linux-c
-TERM mlterm
-TERM putty
-TERM rxvt*
-TERM screen*
-TERM st
-TERM terminator
-TERM tmux*
-TERM vt100
-TERM xterm*
-# Below are the color init strings for the basic file types.
-# One can use codes for 256 or more colors supported by modern terminals.
-# The default color codes use the capabilities of an 8 color terminal
-# with some additional attributes as per the following codes:
-# Attribute codes:
-# 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
-# Text color codes:
-# 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
-# Background color codes:
-# 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
-#NORMAL 00 # no color code at all
-#FILE 00 # regular file: use no color at all
-RESET 0 # reset to "normal" color
-DIR 01;34 # directory
-LINK 01;36 # symbolic link. (If you set this to 'target' instead of a
- # numerical value, the color is as for the file pointed to.)
-MULTIHARDLINK 00 # regular file with more than one link
-FIFO 40;33 # pipe
-SOCK 01;35 # socket
-DOOR 01;35 # door
-BLK 40;33;01 # block device driver
-CHR 40;33;01 # character device driver
-ORPHAN 40;31;01 # symlink to nonexistent file, or non-stat'able file ...
-MISSING 00 # ... and the files they point to
-SETUID 37;41 # file that is setuid (u+s)
-SETGID 30;43 # file that is setgid (g+s)
-CAPABILITY 00 # file with capability (very expensive to lookup)
-STICKY_OTHER_WRITABLE 30;42 # dir that is sticky and other-writable (+t,o+w)
-OTHER_WRITABLE 34;42 # dir that is other-writable (o+w) and not sticky
-STICKY 37;44 # dir with the sticky bit set (+t) and not other-writable
-# This is for files with execute permission:
-EXEC 01;32
-# List any file extensions like '.gz' or '.tar' that you would like ls
-# to color below. Put the extension, a space, and the color init string.
-# (and any comments you want to add after a '#')
-# If you use DOS-style suffixes, you may want to uncomment the following:
-#.cmd 01;32 # executables (bright green)
-#.exe 01;32
-#.com 01;32
-#.btm 01;32
-#.bat 01;32
-# Or if you want to color scripts even if they do not have the
-# executable bit actually set.
-#.sh 01;32
-#.csh 01;32
- # archives or compressed (bright red)
-.tar 01;31
-.tgz 01;31
-.arc 01;31
-.arj 01;31
-.taz 01;31
-.lha 01;31
-.lz4 01;31
-.lzh 01;31
-.lzma 01;31
-.tlz 01;31
-.txz 01;31
-.tzo 01;31
-.t7z 01;31
-.zip 01;31
-.z 01;31
-.dz 01;31
-.gz 01;31
-.lrz 01;31
-.lz 01;31
-.lzo 01;31
-.xz 01;31
-.zst 01;31
-.tzst 01;31
-.bz2 01;31
-.bz 01;31
-.tbz 01;31
-.tbz2 01;31
-.tz 01;31
-.deb 01;31
-.rpm 01;31
-.jar 01;31
-.war 01;31
-.ear 01;31
-.sar 01;31
-.rar 01;31
-.alz 01;31
-.ace 01;31
-.zoo 01;31
-.cpio 01;31
-.7z 01;31
-.rz 01;31
-.cab 01;31
-.wim 01;31
-.swm 01;31
-.dwm 01;31
-.esd 01;31
-# image formats
-.avif 01;35
-.jpg 01;35
-.jpeg 01;35
-.mjpg 01;35
-.mjpeg 01;35
-.gif 01;35
-.bmp 01;35
-.pbm 01;35
-.pgm 01;35
-.ppm 01;35
-.tga 01;35
-.xbm 01;35
-.xpm 01;35
-.tif 01;35
-.tiff 01;35
-.png 01;35
-.svg 01;35
-.svgz 01;35
-.mng 01;35
-.pcx 01;35
-.mov 01;35
-.mpg 01;35
-.mpeg 01;35
-.m2v 01;35
-.mkv 01;35
-.webm 01;35
-.webp 01;35
-.ogm 01;35
-.mp4 01;35
-.m4v 01;35
-.mp4v 01;35
-.vob 01;35
-.qt 01;35
-.nuv 01;35
-.wmv 01;35
-.asf 01;35
-.rm 01;35
-.rmvb 01;35
-.flc 01;35
-.avi 01;35
-.fli 01;35
-.flv 01;35
-.gl 01;35
-.dl 01;35
-.xcf 01;35
-.xwd 01;35
-.yuv 01;35
-.cgm 01;35
-.emf 01;35
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
-.ogv 01;35
-.ogx 01;35
-# audio formats
-.aac 00;36
-.au 00;36
-.flac 00;36
-.m4a 00;36
-.mid 00;36
-.midi 00;36
-.mka 00;36
-.mp3 00;36
-.mpc 00;36
-.ogg 00;36
-.ra 00;36
-.wav 00;36
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
-.oga 00;36
-.opus 00;36
-.spx 00;36
-.xspf 00;36
-# backup files
-*~ 00;90
-*# 00;90
-.bak 00;90
-.old 00;90
-.orig 00;90
-.part 00;90
-.rej 00;90
-.swp 00;90
-.tmp 00;90
-.dpkg-dist 00;90
-.dpkg-old 00;90
-.ucf-dist 00;90
-.ucf-new 00;90
-.ucf-old 00;90
-.rpmnew 00;90
-.rpmorig 00;90
-.rpmsave 00;90
-# Subsequent TERM or COLORTERM entries, can be used to add / override
-# config specific to those matching environment variables."#;
diff --git a/src/uu/dircolors/src/dircolors.rs b/src/uu/dircolors/src/dircolors.rs
index 2e3087d810b..531c3ee474c 100644
--- a/src/uu/dircolors/src/dircolors.rs
+++ b/src/uu/dircolors/src/dircolors.rs
@@ -8,10 +8,12 @@
 use std::borrow::Borrow;
 use std::env;
 use std::fs::File;
+//use std::io::IsTerminal;
 use std::io::{BufRead, BufReader};
 use std::path::Path;
 
 use clap::{crate_version, Arg, ArgAction, Command};
+use uucore::colors::{FILE_ATTRIBUTE_CODES, FILE_COLORS, FILE_TYPES, TERMS};
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError, UUsageError};
 use uucore::{help_about, help_section, help_usage};
@@ -28,9 +30,6 @@ const USAGE: &str = help_usage!("dircolors.md");
 const ABOUT: &str = help_about!("dircolors.md");
 const AFTER_HELP: &str = help_section!("after help", "dircolors.md");
 
-mod colors;
-use self::colors::INTERNAL_DB;
-
 #[derive(PartialEq, Eq, Debug)]
 pub enum OutputFmt {
     Shell,
@@ -57,10 +56,79 @@ pub fn guess_syntax() -> OutputFmt {
     }
 }
 
+fn get_colors_format_strings(fmt: &OutputFmt) -> (String, String) {
+    let prefix = match fmt {
+        OutputFmt::Shell => "LS_COLORS='".to_string(),
+        OutputFmt::CShell => "setenv LS_COLORS '".to_string(),
+        OutputFmt::Display => String::new(),
+        OutputFmt::Unknown => unreachable!(),
+    };
+
+    let suffix = match fmt {
+        OutputFmt::Shell => "';\nexport LS_COLORS".to_string(),
+        OutputFmt::CShell => "'".to_string(),
+        OutputFmt::Display => String::new(),
+        OutputFmt::Unknown => unreachable!(),
+    };
+
+    (prefix, suffix)
+}
+
+pub fn generate_type_output(fmt: &OutputFmt) -> String {
+    match fmt {
+        OutputFmt::Display => FILE_TYPES
+            .iter()
+            .map(|&(_, key, val)| format!("\x1b[{}m{}\t{}\x1b[0m", val, key, val))
+            .collect::<Vec<String>>()
+            .join("\n"),
+        _ => {
+            // Existing logic for other formats
+            FILE_TYPES
+                .iter()
+                .map(|&(_, v1, v2)| format!("{}={}", v1, v2))
+                .collect::<Vec<String>>()
+                .join(":")
+        }
+    }
+}
+
+fn generate_ls_colors(fmt: &OutputFmt, sep: &str) -> String {
+    match fmt {
+        OutputFmt::Display => {
+            let mut display_parts = vec![];
+            let type_output = generate_type_output(fmt);
+            display_parts.push(type_output);
+            for &(extension, code) in FILE_COLORS {
+                let prefix = if extension.starts_with('*') { "" } else { "*" };
+                let formatted_extension =
+                    format!("\x1b[{}m{}{}\t{}\x1b[0m", code, prefix, extension, code);
+                display_parts.push(formatted_extension);
+            }
+            display_parts.join("\n")
+        }
+        _ => {
+            // existing logic for other formats
+            let mut parts = vec![];
+            for &(extension, code) in FILE_COLORS {
+                let prefix = if extension.starts_with('*') { "" } else { "*" };
+                let formatted_extension = format!("{}{}", prefix, extension);
+                parts.push(format!("{}={}", formatted_extension, code));
+            }
+            let (prefix, suffix) = get_colors_format_strings(fmt);
+            let ls_colors = parts.join(sep);
+            format!(
+                "{}{}:{}:{}",
+                prefix,
+                generate_type_output(fmt),
+                ls_colors,
+                suffix
+            )
+        }
+    }
+}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let files = matches
@@ -97,7 +165,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 ),
             ));
         }
-        println!("{INTERNAL_DB}");
+
+        println!("{}", generate_dircolors_config());
         return Ok(());
     }
 
@@ -125,7 +194,20 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let result;
     if files.is_empty() {
-        result = parse(INTERNAL_DB.lines(), &out_format, "");
+        println!("{}", generate_ls_colors(&out_format, ":"));
+        return Ok(());
+        /*
+        // Check if data is being piped into the program
+        if std::io::stdin().is_terminal() {
+            // No data piped, use default behavior
+            println!("{}", generate_ls_colors(&out_format, ":"));
+            return Ok(());
+        } else {
+            // Data is piped, process the input from stdin
+            let fin = BufReader::new(std::io::stdin());
+            result = parse(fin.lines().map_while(Result::ok), &out_format, "-");
+        }
+         */
     } else if files.len() > 1 {
         return Err(UUsageError::new(
             1,
@@ -133,6 +215,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         ));
     } else if files[0].eq("-") {
         let fin = BufReader::new(std::io::stdin());
+        // For example, for echo "owt 40;33"|dircolors -b -
         result = parse(fin.lines().map_while(Result::ok), &out_format, files[0]);
     } else {
         let path = Path::new(files[0]);
@@ -276,69 +359,25 @@ enum ParseState {
     Pass,
 }
 
-use std::collections::HashMap;
 use uucore::{format_usage, parse_glob};
 
 #[allow(clippy::cognitive_complexity)]
-fn parse<T>(lines: T, fmt: &OutputFmt, fp: &str) -> Result<String, String>
+fn parse<T>(user_input: T, fmt: &OutputFmt, fp: &str) -> Result<String, String>
 where
     T: IntoIterator,
     T::Item: Borrow<str>,
 {
-    // 1790 > $(dircolors | wc -m)
     let mut result = String::with_capacity(1790);
-    match fmt {
-        OutputFmt::Shell => result.push_str("LS_COLORS='"),
-        OutputFmt::CShell => result.push_str("setenv LS_COLORS '"),
-        OutputFmt::Display => (),
-        OutputFmt::Unknown => unreachable!(),
-    }
+    let (prefix, suffix) = get_colors_format_strings(fmt);
 
-    let mut table: HashMap<&str, &str> = HashMap::with_capacity(48);
-    table.insert("normal", "no");
-    table.insert("norm", "no");
-    table.insert("file", "fi");
-    table.insert("reset", "rs");
-    table.insert("dir", "di");
-    table.insert("lnk", "ln");
-    table.insert("link", "ln");
-    table.insert("symlink", "ln");
-    table.insert("orphan", "or");
-    table.insert("missing", "mi");
-    table.insert("fifo", "pi");
-    table.insert("pipe", "pi");
-    table.insert("sock", "so");
-    table.insert("blk", "bd");
-    table.insert("block", "bd");
-    table.insert("chr", "cd");
-    table.insert("char", "cd");
-    table.insert("door", "do");
-    table.insert("exec", "ex");
-    table.insert("left", "lc");
-    table.insert("leftcode", "lc");
-    table.insert("right", "rc");
-    table.insert("rightcode", "rc");
-    table.insert("end", "ec");
-    table.insert("endcode", "ec");
-    table.insert("suid", "su");
-    table.insert("setuid", "su");
-    table.insert("sgid", "sg");
-    table.insert("setgid", "sg");
-    table.insert("sticky", "st");
-    table.insert("other_writable", "ow");
-    table.insert("owr", "ow");
-    table.insert("sticky_other_writable", "tw");
-    table.insert("owt", "tw");
-    table.insert("capability", "ca");
-    table.insert("multihardlink", "mh");
-    table.insert("clrtoeol", "cl");
+    result.push_str(&prefix);
 
     let term = env::var("TERM").unwrap_or_else(|_| "none".to_owned());
     let term = term.as_str();
 
     let mut state = ParseState::Global;
 
-    for (num, line) in lines.into_iter().enumerate() {
+    for (num, line) in user_input.into_iter().enumerate() {
         let num = num + 1;
         let line = line.borrow().purify();
         if line.is_empty() {
@@ -350,13 +389,13 @@ where
         let (key, val) = line.split_two();
         if val.is_empty() {
             return Err(format!(
+                // The double space is what GNU is doing
                 "{}:{}: invalid line;  missing second token",
                 fp.maybe_quote(),
                 num
             ));
         }
         let lower = key.to_lowercase();
-
         if lower == "term" || lower == "colorterm" {
             if term.fnmatch(val) {
                 state = ParseState::Matched;
@@ -370,6 +409,8 @@ where
                 state = ParseState::Continue;
             }
             if state != ParseState::Pass {
+                let search_key = lower.as_str();
+
                 if key.starts_with('.') {
                     if *fmt == OutputFmt::Display {
                         result.push_str(format!("\x1b[{val}m*{key}\t{val}\x1b[0m\n").as_str());
@@ -384,7 +425,10 @@ where
                     }
                 } else if lower == "options" || lower == "color" || lower == "eightbit" {
                     // Slackware only. Ignore
-                } else if let Some(s) = table.get(lower.as_str()) {
+                } else if let Some((_, s)) = FILE_ATTRIBUTE_CODES
+                    .iter()
+                    .find(|&&(key, _)| key == search_key)
+                {
                     if *fmt == OutputFmt::Display {
                         result.push_str(format!("\x1b[{val}m{s}\t{val}\x1b[0m\n").as_str());
                     } else {
@@ -402,15 +446,11 @@ where
         }
     }
 
-    match fmt {
-        OutputFmt::Shell => result.push_str("';\nexport LS_COLORS"),
-        OutputFmt::CShell => result.push('\''),
-        OutputFmt::Display => {
-            // remove latest "\n"
-            result.pop();
-        }
-        OutputFmt::Unknown => unreachable!(),
+    if fmt == &OutputFmt::Display {
+        // remove latest "\n"
+        result.pop();
     }
+    result.push_str(&suffix);
 
     Ok(result)
 }
@@ -436,6 +476,58 @@ fn escape(s: &str) -> String {
     result
 }
 
+pub fn generate_dircolors_config() -> String {
+    let mut config = String::new();
+
+    config.push_str(
+        "\
+         # Configuration file for dircolors, a utility to help you set the\n\
+         # LS_COLORS environment variable used by GNU ls with the --color option.\n\
+         # The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the\n\
+         # slackware version of dircolors) are recognized but ignored.\n\
+         # Global config options can be specified before TERM or COLORTERM entries\n\
+         # Below are TERM or COLORTERM entries, which can be glob patterns, which\n\
+         # restrict following config to systems with matching environment variables.\n\
+        ",
+    );
+    config.push_str("COLORTERM ?*\n");
+    for term in TERMS {
+        config.push_str(&format!("TERM {}\n", term));
+    }
+
+    config.push_str(
+        "\
+        # Below are the color init strings for the basic file types.\n\
+        # One can use codes for 256 or more colors supported by modern terminals.\n\
+        # The default color codes use the capabilities of an 8 color terminal\n\
+        # with some additional attributes as per the following codes:\n\
+        # Attribute codes:\n\
+        # 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed\n\
+        # Text color codes:\n\
+        # 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white\n\
+        # Background color codes:\n\
+        # 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white\n\
+        #NORMAL 00 # no color code at all\n\
+        #FILE 00 # regular file: use no color at all\n\
+        ",
+    );
+
+    for (name, _, code) in FILE_TYPES {
+        config.push_str(&format!("{} {}\n", name, code));
+    }
+
+    config.push_str("# List any file extensions like '.gz' or '.tar' that you would like ls\n");
+    config.push_str("# to color below. Put the extension, a space, and the color init string.\n");
+
+    for (ext, color) in FILE_COLORS {
+        config.push_str(&format!("{} {}\n", ext, color));
+    }
+    config.push_str("# Subsequent TERM or COLORTERM entries, can be used to add / override\n");
+    config.push_str("# config specific to those matching environment variables.");
+
+    config
+}
+
 #[cfg(test)]
 mod tests {
     use super::escape;
diff --git a/src/uu/dirname/Cargo.toml b/src/uu/dirname/Cargo.toml
index b093ce3c55c..85391859663 100644
--- a/src/uu/dirname/Cargo.toml
+++ b/src/uu/dirname/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_dirname"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "dirname ~ (uutils) display parent directory of PATHNAME"
diff --git a/src/uu/dirname/src/dirname.rs b/src/uu/dirname/src/dirname.rs
index 51935cb7f23..a645b05fd72 100644
--- a/src/uu/dirname/src/dirname.rs
+++ b/src/uu/dirname/src/dirname.rs
@@ -21,8 +21,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
 
     let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO));
diff --git a/src/uu/du/Cargo.toml b/src/uu/du/Cargo.toml
index 5e87b2f4381..8b9eb062e48 100644
--- a/src/uu/du/Cargo.toml
+++ b/src/uu/du/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_du"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "du ~ (uutils) display disk usage"
diff --git a/src/uu/du/src/du.rs b/src/uu/du/src/du.rs
index 148b197df33..62fcfceda01 100644
--- a/src/uu/du/src/du.rs
+++ b/src/uu/du/src/du.rs
@@ -3,35 +3,30 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use chrono::prelude::DateTime;
-use chrono::Local;
-use clap::ArgAction;
-use clap::{crate_version, Arg, ArgMatches, Command};
+use chrono::{DateTime, Local};
+use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use glob::Pattern;
 use std::collections::HashSet;
 use std::env;
-use std::fs;
-use std::fs::File;
+use std::error::Error;
+use std::fmt::Display;
 #[cfg(not(windows))]
 use std::fs::Metadata;
-use std::io::BufRead;
-use std::io::BufReader;
-use std::io::Result;
-use std::iter;
+use std::fs::{self, File};
+use std::io::{BufRead, BufReader};
 #[cfg(not(windows))]
 use std::os::unix::fs::MetadataExt;
 #[cfg(windows)]
 use std::os::windows::fs::MetadataExt;
 #[cfg(windows)]
 use std::os::windows::io::AsRawHandle;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
+use std::sync::mpsc;
+use std::thread;
 use std::time::{Duration, UNIX_EPOCH};
-use std::{error::Error, fmt::Display};
 use uucore::display::{print_verbatim, Quotable};
-use uucore::error::FromIo;
-use uucore::error::{set_exit_code, UError, UResult, USimpleError};
+use uucore::error::{set_exit_code, FromIo, UError, UResult, USimpleError};
 use uucore::line_ending::LineEnding;
 use uucore::parse_glob;
 use uucore::parse_size::{parse_size_u64, ParseSizeError};
@@ -70,6 +65,7 @@ mod options {
     pub const INODES: &str = "inodes";
     pub const EXCLUDE: &str = "exclude";
     pub const EXCLUDE_FROM: &str = "exclude-from";
+    pub const FILES0_FROM: &str = "files0-from";
     pub const VERBOSE: &str = "verbose";
     pub const FILE: &str = "FILE";
 }
@@ -81,25 +77,49 @@ const USAGE: &str = help_usage!("du.md");
 // TODO: Support Z & Y (currently limited by size of u64)
 const UNITS: [(char, u32); 6] = [('E', 6), ('P', 5), ('T', 4), ('G', 3), ('M', 2), ('K', 1)];
 
-struct Options {
+struct TraversalOptions {
     all: bool,
-    max_depth: Option<usize>,
-    total: bool,
     separate_dirs: bool,
     one_file_system: bool,
     dereference: Deref,
     count_links: bool,
-    inodes: bool,
     verbose: bool,
+    excludes: Vec<Pattern>,
+}
+
+struct StatPrinter {
+    total: bool,
+    inodes: bool,
+    max_depth: Option<usize>,
+    threshold: Option<Threshold>,
+    apparent_size: bool,
+    size_format: SizeFormat,
+    time: Option<Time>,
+    time_format: String,
+    line_ending: LineEnding,
+    summarize: bool,
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Clone)]
 enum Deref {
     All,
     Args(Vec<PathBuf>),
     None,
 }
 
+#[derive(Clone, Copy)]
+enum Time {
+    Accessed,
+    Modified,
+    Created,
+}
+
+#[derive(Clone)]
+enum SizeFormat {
+    Human(u64),
+    BlockSize(u64),
+}
+
 #[derive(PartialEq, Eq, Hash, Clone, Copy)]
 struct FileInfo {
     file_id: u128,
@@ -119,7 +139,7 @@ struct Stat {
 }
 
 impl Stat {
-    fn new(path: &Path, options: &Options) -> Result<Self> {
+    fn new(path: &Path, options: &TraversalOptions) -> std::io::Result<Self> {
         // Determine whether to dereference (follow) the symbolic link
         let should_dereference = match &options.dereference {
             Deref::All => true,
@@ -277,39 +297,23 @@ fn read_block_size(s: Option<&str>) -> UResult<u64> {
     }
 }
 
-fn choose_size(matches: &ArgMatches, stat: &Stat) -> u64 {
-    if matches.get_flag(options::INODES) {
-        stat.inodes
-    } else if matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES) {
-        stat.size
-    } else {
-        // The st_blocks field indicates the number of blocks allocated to the file, 512-byte units.
-        // See: http://linux.die.net/man/2/stat
-        stat.blocks * 512
-    }
-}
-
 // this takes `my_stat` to avoid having to stat files multiple times.
-// XXX: this should use the impl Trait return type when it is stabilized
 #[allow(clippy::cognitive_complexity)]
 fn du(
     mut my_stat: Stat,
-    options: &Options,
+    options: &TraversalOptions,
     depth: usize,
     seen_inodes: &mut HashSet<FileInfo>,
-    exclude: &[Pattern],
-) -> Box<dyn DoubleEndedIterator<Item = Stat>> {
-    let mut stats = vec![];
-    let mut futures = vec![];
-
+    print_tx: &mpsc::Sender<UResult<StatPrintInfo>>,
+) -> Result<Stat, Box<mpsc::SendError<UResult<StatPrintInfo>>>> {
     if my_stat.is_dir {
         let read = match fs::read_dir(&my_stat.path) {
             Ok(read) => read,
             Err(e) => {
-                show!(
-                    e.map_err_context(|| format!("cannot read directory {}", my_stat.path.quote()))
-                );
-                return Box::new(iter::once(my_stat));
+                print_tx.send(Err(e.map_err_context(|| {
+                    format!("cannot read directory {}", my_stat.path.quote())
+                })))?;
+                return Ok(my_stat);
             }
         };
 
@@ -319,7 +323,7 @@ fn du(
                     match Stat::new(&entry.path(), options) {
                         Ok(this_stat) => {
                             // We have an exclude list
-                            for pattern in exclude {
+                            for pattern in &options.excludes {
                                 // Look at all patterns with both short and long paths
                                 // if we have 'du foo' but search to exclude 'foo/bar'
                                 // we need the full path
@@ -354,90 +358,42 @@ fn du(
                                         }
                                     }
                                 }
-                                futures.push(du(
-                                    this_stat,
-                                    options,
-                                    depth + 1,
-                                    seen_inodes,
-                                    exclude,
-                                ));
+
+                                let this_stat =
+                                    du(this_stat, options, depth + 1, seen_inodes, print_tx)?;
+
+                                if !options.separate_dirs {
+                                    my_stat.size += this_stat.size;
+                                    my_stat.blocks += this_stat.blocks;
+                                    my_stat.inodes += this_stat.inodes;
+                                }
+                                print_tx.send(Ok(StatPrintInfo {
+                                    stat: this_stat,
+                                    depth: depth + 1,
+                                }))?;
                             } else {
                                 my_stat.size += this_stat.size;
                                 my_stat.blocks += this_stat.blocks;
                                 my_stat.inodes += 1;
                                 if options.all {
-                                    stats.push(this_stat);
+                                    print_tx.send(Ok(StatPrintInfo {
+                                        stat: this_stat,
+                                        depth: depth + 1,
+                                    }))?;
                                 }
                             }
                         }
-                        Err(e) => show!(
-                            e.map_err_context(|| format!("cannot access {}", entry.path().quote()))
-                        ),
+                        Err(e) => print_tx.send(Err(e.map_err_context(|| {
+                            format!("cannot access {}", entry.path().quote())
+                        })))?,
                     }
                 }
-                Err(error) => show_error!("{}", error),
+                Err(error) => print_tx.send(Err(error.into()))?,
             }
         }
     }
 
-    stats.extend(futures.into_iter().flatten().filter(|stat| {
-        if !options.separate_dirs && stat.path.parent().unwrap() == my_stat.path {
-            my_stat.size += stat.size;
-            my_stat.blocks += stat.blocks;
-            my_stat.inodes += stat.inodes;
-        }
-        options
-            .max_depth
-            .map_or(true, |max_depth| depth < max_depth)
-    }));
-    stats.push(my_stat);
-    Box::new(stats.into_iter())
-}
-
-fn convert_size_human(size: u64, multiplier: u64, _block_size: u64) -> String {
-    for &(unit, power) in &UNITS {
-        let limit = multiplier.pow(power);
-        if size >= limit {
-            return format!("{:.1}{}", (size as f64) / (limit as f64), unit);
-        }
-    }
-    if size == 0 {
-        return "0".to_string();
-    }
-    format!("{size}B")
-}
-
-fn convert_size_b(size: u64, _multiplier: u64, _block_size: u64) -> String {
-    format!("{}", ((size as f64) / (1_f64)).ceil())
-}
-
-fn convert_size_k(size: u64, multiplier: u64, _block_size: u64) -> String {
-    format!("{}", ((size as f64) / (multiplier as f64)).ceil())
-}
-
-fn convert_size_m(size: u64, multiplier: u64, _block_size: u64) -> String {
-    format!(
-        "{}",
-        ((size as f64) / ((multiplier * multiplier) as f64)).ceil()
-    )
-}
-
-fn convert_size_other(size: u64, _multiplier: u64, block_size: u64) -> String {
-    format!("{}", ((size as f64) / (block_size as f64)).ceil())
-}
-
-fn get_convert_size_fn(matches: &ArgMatches) -> Box<dyn Fn(u64, u64, u64) -> String> {
-    if matches.get_flag(options::HUMAN_READABLE) || matches.get_flag(options::SI) {
-        Box::new(convert_size_human)
-    } else if matches.get_flag(options::BYTES) {
-        Box::new(convert_size_b)
-    } else if matches.get_flag(options::BLOCK_SIZE_1K) {
-        Box::new(convert_size_k)
-    } else if matches.get_flag(options::BLOCK_SIZE_1M) {
-        Box::new(convert_size_m)
-    } else {
-        Box::new(convert_size_other)
-    }
+    Ok(my_stat)
 }
 
 #[derive(Debug)]
@@ -445,7 +401,7 @@ enum DuError {
     InvalidMaxDepthArg(String),
     SummarizeDepthConflict(String),
     InvalidTimeStyleArg(String),
-    InvalidTimeArg(String),
+    InvalidTimeArg,
     InvalidGlob(String),
 }
 
@@ -471,11 +427,9 @@ Try '{} --help' for more information.",
                 s.quote(),
                 uucore::execution_phrase()
             ),
-            Self::InvalidTimeArg(s) => write!(
+            Self::InvalidTimeArg => write!(
                 f,
-                "Invalid argument {} for --time.
-'birth' and 'creation' arguments are not supported on this platform.",
-                s.quote()
+                "'birth' and 'creation' arguments for --time are not supported on this platform.",
             ),
             Self::InvalidGlob(s) => write!(f, "Invalid exclude syntax: {s}"),
         }
@@ -490,7 +444,7 @@ impl UError for DuError {
             Self::InvalidMaxDepthArg(_)
             | Self::SummarizeDepthConflict(_)
             | Self::InvalidTimeStyleArg(_)
-            | Self::InvalidTimeArg(_)
+            | Self::InvalidTimeArg
             | Self::InvalidGlob(_) => 1,
         }
     }
@@ -532,11 +486,162 @@ fn build_exclude_patterns(matches: &ArgMatches) -> UResult<Vec<Pattern>> {
     Ok(exclude_patterns)
 }
 
+struct StatPrintInfo {
+    stat: Stat,
+    depth: usize,
+}
+
+impl StatPrinter {
+    fn choose_size(&self, stat: &Stat) -> u64 {
+        if self.inodes {
+            stat.inodes
+        } else if self.apparent_size {
+            stat.size
+        } else {
+            // The st_blocks field indicates the number of blocks allocated to the file, 512-byte units.
+            // See: http://linux.die.net/man/2/stat
+            stat.blocks * 512
+        }
+    }
+
+    fn print_stats(&self, rx: &mpsc::Receiver<UResult<StatPrintInfo>>) -> UResult<()> {
+        let mut grand_total = 0;
+        loop {
+            let received = rx.recv();
+
+            match received {
+                Ok(message) => match message {
+                    Ok(stat_info) => {
+                        let size = self.choose_size(&stat_info.stat);
+
+                        if stat_info.depth == 0 {
+                            grand_total += size;
+                        }
+
+                        if !self
+                            .threshold
+                            .map_or(false, |threshold| threshold.should_exclude(size))
+                            && self
+                                .max_depth
+                                .map_or(true, |max_depth| stat_info.depth <= max_depth)
+                            && (!self.summarize || stat_info.depth == 0)
+                        {
+                            self.print_stat(&stat_info.stat, size)?;
+                        }
+                    }
+                    Err(e) => show!(e),
+                },
+                Err(_) => break,
+            }
+        }
+
+        if self.total {
+            print!("{}\ttotal", self.convert_size(grand_total));
+            print!("{}", self.line_ending);
+        }
+
+        Ok(())
+    }
+
+    fn convert_size(&self, size: u64) -> String {
+        if self.inodes {
+            return size.to_string();
+        }
+        match self.size_format {
+            SizeFormat::Human(multiplier) => {
+                if size == 0 {
+                    return "0".to_string();
+                }
+                for &(unit, power) in &UNITS {
+                    let limit = multiplier.pow(power);
+                    if size >= limit {
+                        return format!("{:.1}{}", (size as f64) / (limit as f64), unit);
+                    }
+                }
+                format!("{size}B")
+            }
+            SizeFormat::BlockSize(block_size) => div_ceil(size, block_size).to_string(),
+        }
+    }
+
+    fn print_stat(&self, stat: &Stat, size: u64) -> UResult<()> {
+        if let Some(time) = self.time {
+            let secs = get_time_secs(time, stat)?;
+            let tm = DateTime::<Local>::from(UNIX_EPOCH + Duration::from_secs(secs));
+            let time_str = tm.format(&self.time_format).to_string();
+            print!("{}\t{}\t", self.convert_size(size), time_str);
+        } else {
+            print!("{}\t", self.convert_size(size));
+        }
+
+        print_verbatim(&stat.path).unwrap();
+        print!("{}", self.line_ending);
+
+        Ok(())
+    }
+}
+
+// This can be replaced with u64::div_ceil once it is stabilized.
+// This implementation approach is optimized for when `b` is a constant,
+// particularly a power of two.
+pub fn div_ceil(a: u64, b: u64) -> u64 {
+    (a + b - 1) / b
+}
+
+// Read file paths from the specified file, separated by null characters
+fn read_files_from(file_name: &str) -> Result<Vec<PathBuf>, std::io::Error> {
+    let reader: Box<dyn BufRead> = if file_name == "-" {
+        // Read from standard input
+        Box::new(BufReader::new(std::io::stdin()))
+    } else {
+        // First, check if the file_name is a directory
+        let path = PathBuf::from(file_name);
+        if path.is_dir() {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                format!("{}: read error: Is a directory", file_name),
+            ));
+        }
+
+        // Attempt to open the file and handle the error if it does not exist
+        match File::open(file_name) {
+            Ok(file) => Box::new(BufReader::new(file)),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    format!(
+                        "cannot open '{}' for reading: No such file or directory",
+                        file_name
+                    ),
+                ))
+            }
+            Err(e) => return Err(e),
+        }
+    };
+
+    let mut paths = Vec::new();
+
+    for (i, line) in reader.split(b'\0').enumerate() {
+        let path = line?;
+
+        if path.is_empty() {
+            let line_number = i + 1;
+            show_error!("{file_name}:{line_number}: invalid zero-length file name");
+            set_exit_code(1);
+        } else {
+            let p = PathBuf::from(String::from_utf8_lossy(&path).to_string());
+            if !paths.contains(&p) {
+                paths.push(p);
+            }
+        }
+    }
+
+    Ok(paths)
+}
+
 #[uucore::main]
 #[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let summarize = matches.get_flag(options::SUMMARIZE);
@@ -548,19 +653,59 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         summarize,
     )?;
 
-    let files = match matches.get_one::<String>(options::FILE) {
-        Some(_) => matches
-            .get_many::<String>(options::FILE)
-            .unwrap()
-            .map(PathBuf::from)
-            .collect(),
-        None => vec![PathBuf::from(".")],
+    let files = if let Some(file_from) = matches.get_one::<String>(options::FILES0_FROM) {
+        if file_from == "-" && matches.get_one::<String>(options::FILE).is_some() {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                format!(
+                    "extra operand {}\nfile operands cannot be combined with --files0-from",
+                    matches.get_one::<String>(options::FILE).unwrap().quote()
+                ),
+            )
+            .into());
+        }
+
+        read_files_from(file_from)?
+    } else {
+        match matches.get_one::<String>(options::FILE) {
+            Some(_) => matches
+                .get_many::<String>(options::FILE)
+                .unwrap()
+                .map(PathBuf::from)
+                .collect(),
+            None => vec![PathBuf::from(".")],
+        }
+    };
+
+    let time = matches.contains_id(options::TIME).then(|| {
+        match matches.get_one::<String>(options::TIME).map(AsRef::as_ref) {
+            None | Some("ctime" | "status") => Time::Modified,
+            Some("access" | "atime" | "use") => Time::Accessed,
+            Some("birth" | "creation") => Time::Created,
+            _ => unreachable!("should be caught by clap"),
+        }
+    });
+
+    let size_format = if matches.get_flag(options::HUMAN_READABLE) {
+        SizeFormat::Human(1024)
+    } else if matches.get_flag(options::SI) {
+        SizeFormat::Human(1000)
+    } else if matches.get_flag(options::BYTES) {
+        SizeFormat::BlockSize(1)
+    } else if matches.get_flag(options::BLOCK_SIZE_1K) {
+        SizeFormat::BlockSize(1024)
+    } else if matches.get_flag(options::BLOCK_SIZE_1M) {
+        SizeFormat::BlockSize(1024 * 1024)
+    } else {
+        SizeFormat::BlockSize(read_block_size(
+            matches
+                .get_one::<String>(options::BLOCK_SIZE)
+                .map(AsRef::as_ref),
+        )?)
     };
 
-    let options = Options {
+    let traversal_options = TraversalOptions {
         all: matches.get_flag(options::ALL),
-        max_depth,
-        total: matches.get_flag(options::TOTAL),
         separate_dirs: matches.get_flag(options::SEPARATE_DIRS),
         one_file_system: matches.get_flag(options::ONE_FILE_SYSTEM),
         dereference: if matches.get_flag(options::DEREFERENCE) {
@@ -572,67 +717,49 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             Deref::None
         },
         count_links: matches.get_flag(options::COUNT_LINKS),
-        inodes: matches.get_flag(options::INODES),
         verbose: matches.get_flag(options::VERBOSE),
+        excludes: build_exclude_patterns(&matches)?,
+    };
+
+    let stat_printer = StatPrinter {
+        max_depth,
+        size_format,
+        summarize,
+        total: matches.get_flag(options::TOTAL),
+        inodes: matches.get_flag(options::INODES),
+        threshold: matches
+            .get_one::<String>(options::THRESHOLD)
+            .map(|s| {
+                Threshold::from_str(s).map_err(|e| {
+                    USimpleError::new(1, format_error_message(&e, s, options::THRESHOLD))
+                })
+            })
+            .transpose()?,
+        apparent_size: matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES),
+        time,
+        time_format: parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?
+            .to_string(),
+        line_ending: LineEnding::from_zero_flag(matches.get_flag(options::NULL)),
     };
 
-    if options.inodes
+    if stat_printer.inodes
         && (matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES))
     {
         show_warning!("options --apparent-size and -b are ineffective with --inodes");
     }
 
-    let block_size = read_block_size(
-        matches
-            .get_one::<String>(options::BLOCK_SIZE)
-            .map(|s| s.as_str()),
-    )?;
-
-    let threshold = match matches.get_one::<String>(options::THRESHOLD) {
-        Some(s) => match Threshold::from_str(s) {
-            Ok(t) => Some(t),
-            Err(e) => {
-                return Err(USimpleError::new(
-                    1,
-                    format_error_message(&e, s, options::THRESHOLD),
-                ))
-            }
-        },
-        None => None,
-    };
-
-    let multiplier: u64 = if matches.get_flag(options::SI) {
-        1000
-    } else {
-        1024
-    };
-
-    let convert_size_fn = get_convert_size_fn(&matches);
-
-    let convert_size = |size: u64| {
-        if options.inodes {
-            size.to_string()
-        } else {
-            convert_size_fn(size, multiplier, block_size)
-        }
-    };
-
-    let time_format_str =
-        parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?;
-
-    let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::NULL));
+    // Use separate thread to print output, so we can print finished results while computation is still running
+    let (print_tx, rx) = mpsc::channel::<UResult<StatPrintInfo>>();
+    let printing_thread = thread::spawn(move || stat_printer.print_stats(&rx));
 
-    let excludes = build_exclude_patterns(&matches)?;
-
-    let mut grand_total = 0;
     'loop_file: for path in files {
         // Skip if we don't want to ignore anything
-        if !&excludes.is_empty() {
+        if !&traversal_options.excludes.is_empty() {
             let path_string = path.to_string_lossy();
-            for pattern in &excludes {
+            for pattern in &traversal_options.excludes {
                 if pattern.matches(&path_string) {
                     // if the directory is ignored, leave early
-                    if options.verbose {
+                    if traversal_options.verbose {
                         println!("{} ignored", path_string.quote());
                     }
                     continue 'loop_file;
@@ -641,79 +768,46 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
 
         // Check existence of path provided in argument
-        if let Ok(stat) = Stat::new(&path, &options) {
+        if let Ok(stat) = Stat::new(&path, &traversal_options) {
             // Kick off the computation of disk usage from the initial path
             let mut seen_inodes: HashSet<FileInfo> = HashSet::new();
             if let Some(inode) = stat.inode {
                 seen_inodes.insert(inode);
             }
-            let iter = du(stat, &options, 0, &mut seen_inodes, &excludes);
-
-            // Sum up all the returned `Stat`s and display results
-            let (_, len) = iter.size_hint();
-            let len = len.unwrap();
-            for (index, stat) in iter.enumerate() {
-                let size = choose_size(&matches, &stat);
+            let stat = du(stat, &traversal_options, 0, &mut seen_inodes, &print_tx)
+                .map_err(|e| USimpleError::new(1, e.to_string()))?;
 
-                if threshold.map_or(false, |threshold| threshold.should_exclude(size)) {
-                    continue;
-                }
-
-                if matches.contains_id(options::TIME) {
-                    let tm = {
-                        let secs = matches
-                            .get_one::<String>(options::TIME)
-                            .map(|s| get_time_secs(s, &stat))
-                            .transpose()?
-                            .unwrap_or(stat.modified);
-                        DateTime::<Local>::from(UNIX_EPOCH + Duration::from_secs(secs))
-                    };
-                    if !summarize || index == len - 1 {
-                        let time_str = tm.format(time_format_str).to_string();
-                        print!("{}\t{}\t", convert_size(size), time_str);
-                        print_verbatim(stat.path).unwrap();
-                        print!("{line_ending}");
-                    }
-                } else if !summarize || index == len - 1 {
-                    print!("{}\t", convert_size(size));
-                    print_verbatim(stat.path).unwrap();
-                    print!("{line_ending}");
-                }
-                if options.total && index == (len - 1) {
-                    // The last element will be the total size of the the path under
-                    // path_string.  We add it to the grand total.
-                    grand_total += size;
-                }
-            }
+            print_tx
+                .send(Ok(StatPrintInfo { stat, depth: 0 }))
+                .map_err(|e| USimpleError::new(1, e.to_string()))?;
         } else {
-            show_error!(
-                "{}: {}",
-                path.to_string_lossy().maybe_quote(),
-                "No such file or directory"
-            );
-            set_exit_code(1);
+            print_tx
+                .send(Err(USimpleError::new(
+                    1,
+                    format!(
+                        "{}: No such file or directory",
+                        path.to_string_lossy().maybe_quote()
+                    ),
+                )))
+                .map_err(|e| USimpleError::new(1, e.to_string()))?;
         }
     }
 
-    if options.total {
-        print!("{}\ttotal", convert_size(grand_total));
-        print!("{line_ending}");
-    }
+    drop(print_tx);
+
+    printing_thread
+        .join()
+        .map_err(|_| USimpleError::new(1, "Printing thread panicked."))??;
 
     Ok(())
 }
 
-fn get_time_secs(s: &str, stat: &Stat) -> std::result::Result<u64, DuError> {
-    let secs = match s {
-        "ctime" | "status" => stat.modified,
-        "access" | "atime" | "use" => stat.accessed,
-        "birth" | "creation" => stat
-            .created
-            .ok_or_else(|| DuError::InvalidTimeArg(s.into()))?,
-        // below should never happen as clap already restricts the values.
-        _ => unreachable!("Invalid field for --time"),
-    };
-    Ok(secs)
+fn get_time_secs(time: Time, stat: &Stat) -> Result<u64, DuError> {
+    match time {
+        Time::Modified => Ok(stat.modified),
+        Time::Accessed => Ok(stat.accessed),
+        Time::Created => stat.created.ok_or(DuError::InvalidTimeArg),
+    }
 }
 
 fn parse_time_style(s: Option<&str>) -> UResult<&str> {
@@ -927,6 +1021,14 @@ pub fn uu_app() -> Command {
                 .help("exclude files that match any pattern in FILE")
                 .action(ArgAction::Append)
         )
+        .arg(
+            Arg::new(options::FILES0_FROM)
+                .long("files0-from")
+                .value_name("FILE")
+                .value_hint(clap::ValueHint::FilePath)
+                .help("summarize device usage of the NUL-terminated file names specified in file F; if F is -, then read names from standard input")
+                .action(ArgAction::Append)
+        )
         .arg(
             Arg::new(options::TIME)
                 .long(options::TIME)
@@ -966,7 +1068,7 @@ enum Threshold {
 impl FromStr for Threshold {
     type Err = ParseSizeError;
 
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         let offset = usize::from(s.starts_with(&['-', '+'][..]));
 
         let size = parse_size_u64(&s[offset..])?;
diff --git a/src/uu/echo/Cargo.toml b/src/uu/echo/Cargo.toml
index e63977e57f7..ddb896c3389 100644
--- a/src/uu/echo/Cargo.toml
+++ b/src/uu/echo/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_echo"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "echo ~ (uutils) display TEXT"
diff --git a/src/uu/echo/src/echo.rs b/src/uu/echo/src/echo.rs
index b3707b6f898..a34c99bc91d 100644
--- a/src/uu/echo/src/echo.rs
+++ b/src/uu/echo/src/echo.rs
@@ -118,7 +118,6 @@ fn print_escaped(input: &str, mut output: impl Write) -> io::Result<ControlFlow<
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
     let matches = uu_app().get_matches_from(args);
 
     let no_newline = matches.get_flag(options::NO_NEWLINE);
@@ -154,13 +153,15 @@ pub fn uu_app() -> Command {
             Arg::new(options::ENABLE_BACKSLASH_ESCAPE)
                 .short('e')
                 .help("enable interpretation of backslash escapes")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::DISABLE_BACKSLASH_ESCAPE),
         )
         .arg(
             Arg::new(options::DISABLE_BACKSLASH_ESCAPE)
                 .short('E')
                 .help("disable interpretation of backslash escapes (default)")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::ENABLE_BACKSLASH_ESCAPE),
         )
         .arg(Arg::new(options::STRING).action(ArgAction::Append))
 }
diff --git a/src/uu/env/Cargo.toml b/src/uu/env/Cargo.toml
index a1df3563b20..26fa1ebbec8 100644
--- a/src/uu/env/Cargo.toml
+++ b/src/uu/env/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_env"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "env ~ (uutils) set each NAME to VALUE in the environment and run COMMAND"
diff --git a/src/uu/expand/Cargo.toml b/src/uu/expand/Cargo.toml
index 63425bc5ea1..87f8f8f7716 100644
--- a/src/uu/expand/Cargo.toml
+++ b/src/uu/expand/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_expand"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "expand ~ (uutils) convert input tabs to spaces"
diff --git a/src/uu/expand/src/expand.rs b/src/uu/expand/src/expand.rs
index 99b9d6b815d..1efb36c654c 100644
--- a/src/uu/expand/src/expand.rs
+++ b/src/uu/expand/src/expand.rs
@@ -11,11 +11,12 @@ use std::fmt;
 use std::fs::File;
 use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
 use std::num::IntErrorKind;
+use std::path::Path;
 use std::str::from_utf8;
 use unicode_width::UnicodeWidthChar;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult};
-use uucore::{format_usage, help_about, help_usage};
+use uucore::error::{set_exit_code, FromIo, UError, UResult};
+use uucore::{format_usage, help_about, help_usage, show_error};
 
 const ABOUT: &str = help_about!("expand.md");
 const USAGE: &str = help_usage!("expand.md");
@@ -275,6 +276,7 @@ pub fn uu_app() -> Command {
         .after_help(LONG_HELP)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::INITIAL)
                 .long(options::INITIAL)
@@ -464,6 +466,12 @@ fn expand(options: &Options) -> UResult<()> {
     let mut buf = Vec::new();
 
     for file in &options.files {
+        if Path::new(file).is_dir() {
+            show_error!("{}: Is a directory", file);
+            set_exit_code(1);
+            continue;
+        }
+
         let mut fh = open(file)?;
 
         while match fh.read_until(b'\n', &mut buf) {
diff --git a/src/uu/expr/Cargo.toml b/src/uu/expr/Cargo.toml
index a867c27c80a..17d37413e26 100644
--- a/src/uu/expr/Cargo.toml
+++ b/src/uu/expr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_expr"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "expr ~ (uutils) display the value of EXPRESSION"
diff --git a/src/uu/expr/src/expr.rs b/src/uu/expr/src/expr.rs
index ea559090c92..4e41a6929e6 100644
--- a/src/uu/expr/src/expr.rs
+++ b/src/uu/expr/src/expr.rs
@@ -3,14 +3,19 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use std::fmt::Display;
+
 use clap::{crate_version, Arg, ArgAction, Command};
+use syntax_tree::AstNode;
 use uucore::{
-    error::{UResult, USimpleError},
+    display::Quotable,
+    error::{UError, UResult},
     format_usage, help_about, help_section, help_usage,
 };
 
+use crate::syntax_tree::is_truthy;
+
 mod syntax_tree;
-mod tokens;
 
 mod options {
     pub const VERSION: &str = "version";
@@ -18,6 +23,51 @@ mod options {
     pub const EXPRESSION: &str = "expression";
 }
 
+pub type ExprResult<T> = Result<T, ExprError>;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum ExprError {
+    UnexpectedArgument(String),
+    MissingArgument(String),
+    NonIntegerArgument,
+    MissingOperand,
+    DivisionByZero,
+    InvalidRegexExpression,
+    ExpectedClosingBraceAfter(String),
+}
+
+impl Display for ExprError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::UnexpectedArgument(s) => {
+                write!(f, "syntax error: unexpected argument {}", s.quote())
+            }
+            Self::MissingArgument(s) => {
+                write!(f, "syntax error: missing argument after {}", s.quote())
+            }
+            Self::NonIntegerArgument => write!(f, "non-integer argument"),
+            Self::MissingOperand => write!(f, "missing operand"),
+            Self::DivisionByZero => write!(f, "division by zero"),
+            Self::InvalidRegexExpression => write!(f, "Invalid regex expression"),
+            Self::ExpectedClosingBraceAfter(s) => {
+                write!(f, "expected ')' after {}", s.quote())
+            }
+        }
+    }
+}
+
+impl std::error::Error for ExprError {}
+
+impl UError for ExprError {
+    fn code(&self) -> i32 {
+        2
+    }
+
+    fn usage(&self) -> bool {
+        *self == Self::MissingOperand
+    }
+}
+
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .version(crate_version!())
@@ -48,37 +98,18 @@ pub fn uu_app() -> Command {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     // For expr utility we do not want getopts.
     // The following usage should work without escaping hyphens: `expr -15 = 1 +  2 \* \( 3 - -4 \)`
     let matches = uu_app().try_get_matches_from(args)?;
-    let token_strings = matches
+    let token_strings: Vec<&str> = matches
         .get_many::<String>(options::EXPRESSION)
         .map(|v| v.into_iter().map(|s| s.as_ref()).collect::<Vec<_>>())
         .unwrap_or_default();
 
-    match process_expr(&token_strings[..]) {
-        Ok(expr_result) => print_expr_ok(&expr_result),
-        Err(expr_error) => Err(USimpleError::new(2, &expr_error)),
+    let res: String = AstNode::parse(&token_strings)?.eval()?.eval_as_string();
+    println!("{res}");
+    if !is_truthy(&res.into()) {
+        return Err(1.into());
     }
-}
-
-fn process_expr(token_strings: &[&str]) -> Result<String, String> {
-    let maybe_tokens = tokens::strings_to_tokens(token_strings);
-    let maybe_ast = syntax_tree::tokens_to_ast(maybe_tokens);
-    evaluate_ast(maybe_ast)
-}
-
-fn print_expr_ok(expr_result: &str) -> UResult<()> {
-    println!("{expr_result}");
-    if expr_result.parse::<i32>() == Ok(0) || expr_result.is_empty() {
-        Err(1.into())
-    } else {
-        Ok(())
-    }
-}
-
-fn evaluate_ast(maybe_ast: Result<Box<syntax_tree::AstNode>, String>) -> Result<String, String> {
-    maybe_ast.and_then(|ast| ast.evaluate())
+    Ok(())
 }
diff --git a/src/uu/expr/src/syntax_tree.rs b/src/uu/expr/src/syntax_tree.rs
index c55fb0bdc6a..5aa9c93986b 100644
--- a/src/uu/expr/src/syntax_tree.rs
+++ b/src/uu/expr/src/syntax_tree.rs
@@ -3,557 +3,588 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-//!
-//! Here we employ shunting-yard algorithm for building AST from tokens according to operators' precedence and associative-ness.
-//! * `<https://en.wikipedia.org/wiki/Shunting-yard_algorithm>`
-//!
-
 // spell-checker:ignore (ToDO) ints paren prec multibytes
 
-use num_bigint::BigInt;
-use num_traits::Zero;
+use num_bigint::{BigInt, ParseBigIntError};
+use num_traits::ToPrimitive;
 use onig::{Regex, RegexOptions, Syntax};
 
-use crate::tokens::Token;
+use crate::{ExprError, ExprResult};
 
-type TokenStack = Vec<(usize, Token)>;
-pub type OperandsList = Vec<Box<AstNode>>;
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinOp {
+    Relation(RelationOp),
+    Numeric(NumericOp),
+    String(StringOp),
+}
 
-#[derive(Debug)]
-pub enum AstNode {
-    Leaf {
-        token_idx: usize,
-        value: String,
-    },
-    Node {
-        token_idx: usize,
-        op_type: String,
-        operands: OperandsList,
-    },
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RelationOp {
+    Lt,
+    Leq,
+    Eq,
+    Neq,
+    Gt,
+    Geq,
 }
 
-impl AstNode {
-    fn debug_dump(&self) {
-        self.debug_dump_impl(1);
-    }
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum NumericOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+}
 
-    fn debug_dump_impl(&self, depth: usize) {
-        for _ in 0..depth {
-            print!("\t",);
-        }
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum StringOp {
+    Match,
+    Index,
+    And,
+    Or,
+}
+
+impl BinOp {
+    fn eval(&self, left: &AstNode, right: &AstNode) -> ExprResult<NumOrStr> {
         match self {
-            Self::Leaf { token_idx, value } => println!(
-                "Leaf( {} ) at #{} ( evaluate -> {:?} )",
-                value,
-                token_idx,
-                self.evaluate()
-            ),
-            Self::Node {
-                token_idx,
-                op_type,
-                operands,
-            } => {
-                println!(
-                    "Node( {} ) at #{} ( evaluate -> {:?} )",
-                    op_type,
-                    token_idx,
-                    self.evaluate()
-                );
-                for operand in operands {
-                    operand.debug_dump_impl(depth + 1);
-                }
-            }
+            Self::Relation(op) => op.eval(left, right),
+            Self::Numeric(op) => op.eval(left, right),
+            Self::String(op) => op.eval(left, right),
         }
     }
+}
 
-    fn new_node(token_idx: usize, op_type: &str, operands: OperandsList) -> Box<Self> {
-        Box::new(Self::Node {
-            token_idx,
-            op_type: op_type.into(),
-            operands,
-        })
-    }
-
-    fn new_leaf(token_idx: usize, value: &str) -> Box<Self> {
-        Box::new(Self::Leaf {
-            token_idx,
-            value: value.into(),
-        })
+impl RelationOp {
+    fn eval(&self, a: &AstNode, b: &AstNode) -> ExprResult<NumOrStr> {
+        let a = a.eval()?;
+        let b = b.eval()?;
+        let b = if let (Ok(a), Ok(b)) = (&a.to_bigint(), &b.to_bigint()) {
+            match self {
+                Self::Lt => a < b,
+                Self::Leq => a <= b,
+                Self::Eq => a == b,
+                Self::Neq => a != b,
+                Self::Gt => a > b,
+                Self::Geq => a >= b,
+            }
+        } else {
+            // These comparisons should be using locale settings
+            let a = a.eval_as_string();
+            let b = b.eval_as_string();
+            match self {
+                Self::Lt => a < b,
+                Self::Leq => a <= b,
+                Self::Eq => a == b,
+                Self::Neq => a != b,
+                Self::Gt => a > b,
+                Self::Geq => a >= b,
+            }
+        };
+        if b {
+            Ok(1.into())
+        } else {
+            Ok(0.into())
+        }
     }
+}
 
-    pub fn evaluate(&self) -> Result<String, String> {
-        match self {
-            Self::Leaf { value, .. } => Ok(value.clone()),
-            Self::Node { op_type, .. } => match self.operand_values() {
-                Err(reason) => Err(reason),
-                Ok(operand_values) => match op_type.as_ref() {
-                    "+" => {
-                        infix_operator_two_ints(|a: BigInt, b: BigInt| Ok(a + b), &operand_values)
-                    }
-                    "-" => {
-                        infix_operator_two_ints(|a: BigInt, b: BigInt| Ok(a - b), &operand_values)
-                    }
-                    "*" => {
-                        infix_operator_two_ints(|a: BigInt, b: BigInt| Ok(a * b), &operand_values)
-                    }
-                    "/" => infix_operator_two_ints(
-                        |a: BigInt, b: BigInt| {
-                            if b.is_zero() {
-                                Err("division by zero".to_owned())
-                            } else {
-                                Ok(a / b)
-                            }
-                        },
-                        &operand_values,
-                    ),
-                    "%" => infix_operator_two_ints(
-                        |a: BigInt, b: BigInt| {
-                            if b.is_zero() {
-                                Err("division by zero".to_owned())
-                            } else {
-                                Ok(a % b)
-                            }
-                        },
-                        &operand_values,
-                    ),
-                    "=" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a == b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a == b)),
-                        &operand_values,
-                    ),
-                    "!=" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a != b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a != b)),
-                        &operand_values,
-                    ),
-                    "<" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a < b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a < b)),
-                        &operand_values,
-                    ),
-                    ">" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a > b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a > b)),
-                        &operand_values,
-                    ),
-                    "<=" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a <= b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a <= b)),
-                        &operand_values,
-                    ),
-                    ">=" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a >= b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a >= b)),
-                        &operand_values,
-                    ),
-                    "|" => Ok(infix_operator_or(&operand_values)),
-                    "&" => Ok(infix_operator_and(&operand_values)),
-                    ":" | "match" => operator_match(&operand_values),
-                    "length" => Ok(prefix_operator_length(&operand_values)),
-                    "index" => Ok(prefix_operator_index(&operand_values)),
-                    "substr" => Ok(prefix_operator_substr(&operand_values)),
-
-                    _ => Err(format!("operation not implemented: {op_type}")),
-                },
+impl NumericOp {
+    fn eval(&self, left: &AstNode, right: &AstNode) -> ExprResult<NumOrStr> {
+        let a = left.eval()?.eval_as_bigint()?;
+        let b = right.eval()?.eval_as_bigint()?;
+        Ok(NumOrStr::Num(match self {
+            Self::Add => a + b,
+            Self::Sub => a - b,
+            Self::Mul => a * b,
+            Self::Div => match a.checked_div(&b) {
+                Some(x) => x,
+                None => return Err(ExprError::DivisionByZero),
             },
-        }
+            Self::Mod => {
+                if a.checked_div(&b).is_none() {
+                    return Err(ExprError::DivisionByZero);
+                };
+                a % b
+            }
+        }))
     }
+}
 
-    pub fn operand_values(&self) -> Result<Vec<String>, String> {
-        if let Self::Node {
-            operands, op_type, ..
-        } = self
-        {
-            let mut out = Vec::with_capacity(operands.len());
-            let mut operands = operands.iter();
-
-            if let Some(value) = operands.next() {
-                let value = value.evaluate()?;
-                out.push(value.clone());
-                // short-circuit evaluation for `|` and `&`
-                // push dummy to pass `assert!(values.len() == 2);`
-                match op_type.as_ref() {
-                    "|" => {
-                        if value_as_bool(&value) {
-                            out.push(String::from("dummy"));
-                            return Ok(out);
-                        }
-                    }
-                    "&" => {
-                        if !value_as_bool(&value) {
-                            out.push(String::from("dummy"));
-                            return Ok(out);
+impl StringOp {
+    fn eval(&self, left: &AstNode, right: &AstNode) -> ExprResult<NumOrStr> {
+        match self {
+            Self::Or => {
+                let left = left.eval()?;
+                if is_truthy(&left) {
+                    return Ok(left);
+                }
+                let right = right.eval()?;
+                if is_truthy(&right) {
+                    return Ok(right);
+                }
+                Ok(0.into())
+            }
+            Self::And => {
+                let left = left.eval()?;
+                if !is_truthy(&left) {
+                    return Ok(0.into());
+                }
+                let right = right.eval()?;
+                if !is_truthy(&right) {
+                    return Ok(0.into());
+                }
+                Ok(left)
+            }
+            Self::Match => {
+                let left = left.eval()?.eval_as_string();
+                let right = right.eval()?.eval_as_string();
+                let re_string = format!("^{}", right);
+                let re = Regex::with_options(
+                    &re_string,
+                    RegexOptions::REGEX_OPTION_NONE,
+                    Syntax::grep(),
+                )
+                .map_err(|_| ExprError::InvalidRegexExpression)?;
+                Ok(if re.captures_len() > 0 {
+                    re.captures(&left)
+                        .map(|captures| captures.at(1).unwrap())
+                        .unwrap_or("")
+                        .to_string()
+                } else {
+                    re.find(&left)
+                        .map_or("0".to_string(), |(start, end)| (end - start).to_string())
+                }
+                .into())
+            }
+            Self::Index => {
+                let left = left.eval()?.eval_as_string();
+                let right = right.eval()?.eval_as_string();
+                for (current_idx, ch_h) in left.chars().enumerate() {
+                    for ch_n in right.to_string().chars() {
+                        if ch_n == ch_h {
+                            return Ok((current_idx + 1).into());
                         }
                     }
-                    _ => {}
                 }
+                Ok(0.into())
             }
-
-            for operand in operands {
-                let value = operand.evaluate()?;
-                out.push(value);
-            }
-            Ok(out)
-        } else {
-            panic!("Invoked .operand_values(&self) not with ASTNode::Node")
         }
     }
 }
 
-pub fn tokens_to_ast(
-    maybe_tokens: Result<Vec<(usize, Token)>, String>,
-) -> Result<Box<AstNode>, String> {
-    maybe_tokens.and_then(|tokens| {
-        let mut out_stack: TokenStack = Vec::new();
-        let mut op_stack: TokenStack = Vec::new();
+/// Precedence for infix binary operators
+const PRECEDENCE: &[&[(&str, BinOp)]] = &[
+    &[("|", BinOp::String(StringOp::Or))],
+    &[("&", BinOp::String(StringOp::And))],
+    &[
+        ("<", BinOp::Relation(RelationOp::Lt)),
+        ("<=", BinOp::Relation(RelationOp::Leq)),
+        ("=", BinOp::Relation(RelationOp::Eq)),
+        ("!=", BinOp::Relation(RelationOp::Neq)),
+        (">=", BinOp::Relation(RelationOp::Geq)),
+        (">", BinOp::Relation(RelationOp::Gt)),
+    ],
+    &[
+        ("+", BinOp::Numeric(NumericOp::Add)),
+        ("-", BinOp::Numeric(NumericOp::Sub)),
+    ],
+    &[
+        ("*", BinOp::Numeric(NumericOp::Mul)),
+        ("/", BinOp::Numeric(NumericOp::Div)),
+        ("%", BinOp::Numeric(NumericOp::Mod)),
+    ],
+    &[(":", BinOp::String(StringOp::Match))],
+];
 
-        for (token_idx, token) in tokens {
-            push_token_to_either_stack(token_idx, &token, &mut out_stack, &mut op_stack)?;
-        }
-        move_rest_of_ops_to_out(&mut out_stack, &mut op_stack)?;
-        assert!(op_stack.is_empty());
-
-        maybe_dump_rpn(&out_stack);
-        let result = ast_from_rpn(&mut out_stack);
-        if out_stack.is_empty() {
-            maybe_dump_ast(&result);
-            result
-        } else {
-            Err(
-                "syntax error (first RPN token does not represent the root of the expression AST)"
-                    .to_owned(),
-            )
-        }
-    })
+#[derive(Debug)]
+pub enum NumOrStr {
+    Num(BigInt),
+    Str(String),
 }
 
-fn maybe_dump_ast(result: &Result<Box<AstNode>, String>) {
-    use std::env;
-    if let Ok(debug_var) = env::var("EXPR_DEBUG_AST") {
-        if debug_var == "1" {
-            println!("EXPR_DEBUG_AST");
-            match result {
-                Ok(ast) => ast.debug_dump(),
-                Err(reason) => println!("\terr: {reason:?}"),
-            }
-        }
+impl From<usize> for NumOrStr {
+    fn from(num: usize) -> Self {
+        Self::Num(BigInt::from(num))
     }
 }
 
-#[allow(clippy::ptr_arg)]
-fn maybe_dump_rpn(rpn: &TokenStack) {
-    use std::env;
-    if let Ok(debug_var) = env::var("EXPR_DEBUG_RPN") {
-        if debug_var == "1" {
-            println!("EXPR_DEBUG_RPN");
-            for token in rpn {
-                println!("\t{token:?}");
-            }
-        }
+impl From<BigInt> for NumOrStr {
+    fn from(num: BigInt) -> Self {
+        Self::Num(num)
     }
 }
 
-fn ast_from_rpn(rpn: &mut TokenStack) -> Result<Box<AstNode>, String> {
-    match rpn.pop() {
-        None => Err("syntax error (premature end of expression)".to_owned()),
-
-        Some((token_idx, Token::Value { value })) => Ok(AstNode::new_leaf(token_idx, &value)),
+impl From<String> for NumOrStr {
+    fn from(str: String) -> Self {
+        Self::Str(str)
+    }
+}
 
-        Some((token_idx, Token::InfixOp { value, .. })) => {
-            maybe_ast_node(token_idx, &value, 2, rpn)
+impl NumOrStr {
+    pub fn to_bigint(&self) -> Result<BigInt, ParseBigIntError> {
+        match self {
+            Self::Num(num) => Ok(num.clone()),
+            Self::Str(str) => str.parse::<BigInt>(),
         }
+    }
 
-        Some((token_idx, Token::PrefixOp { value, arity })) => {
-            maybe_ast_node(token_idx, &value, arity, rpn)
+    pub fn eval_as_bigint(self) -> ExprResult<BigInt> {
+        match self {
+            Self::Num(num) => Ok(num),
+            Self::Str(str) => str
+                .parse::<BigInt>()
+                .map_err(|_| ExprError::NonIntegerArgument),
         }
+    }
 
-        Some((token_idx, unexpected_token)) => {
-            panic!("unexpected token at #{token_idx} {unexpected_token:?}")
+    pub fn eval_as_string(self) -> String {
+        match self {
+            Self::Num(num) => num.to_string(),
+            Self::Str(str) => str,
         }
     }
 }
 
-fn maybe_ast_node(
-    token_idx: usize,
-    op_type: &str,
-    arity: usize,
-    rpn: &mut TokenStack,
-) -> Result<Box<AstNode>, String> {
-    let mut operands = Vec::with_capacity(arity);
-    for _ in 0..arity {
-        let operand = ast_from_rpn(rpn)?;
-        operands.push(operand);
-    }
-    operands.reverse();
-    Ok(AstNode::new_node(token_idx, op_type, operands))
+#[derive(Debug, PartialEq, Eq)]
+pub enum AstNode {
+    Leaf {
+        value: String,
+    },
+    BinOp {
+        op_type: BinOp,
+        left: Box<AstNode>,
+        right: Box<AstNode>,
+    },
+    Substr {
+        string: Box<AstNode>,
+        pos: Box<AstNode>,
+        length: Box<AstNode>,
+    },
+    Length {
+        string: Box<AstNode>,
+    },
 }
 
-fn move_rest_of_ops_to_out(
-    out_stack: &mut TokenStack,
-    op_stack: &mut TokenStack,
-) -> Result<(), String> {
-    loop {
-        match op_stack.pop() {
-            None => return Ok(()),
-            Some((token_idx, Token::ParOpen)) => {
-                return Err(format!(
-                    "syntax error (Mismatched open-parenthesis at #{token_idx})"
-                ))
-            }
-            Some((token_idx, Token::ParClose)) => {
-                return Err(format!(
-                    "syntax error (Mismatched close-parenthesis at #{token_idx})"
-                ))
+impl AstNode {
+    pub fn parse(input: &[&str]) -> ExprResult<Self> {
+        Parser::new(input).parse()
+    }
+
+    pub fn eval(&self) -> ExprResult<NumOrStr> {
+        match self {
+            Self::Leaf { value } => Ok(value.to_string().into()),
+            Self::BinOp {
+                op_type,
+                left,
+                right,
+            } => op_type.eval(left, right),
+            Self::Substr {
+                string,
+                pos,
+                length,
+            } => {
+                let string: String = string.eval()?.eval_as_string();
+
+                // The GNU docs say:
+                //
+                // > If either position or length is negative, zero, or
+                // > non-numeric, returns the null string.
+                //
+                // So we coerce errors into 0 to make that the only case we
+                // have to care about.
+                let pos = pos
+                    .eval()?
+                    .eval_as_bigint()
+                    .ok()
+                    .and_then(|n| n.to_usize())
+                    .unwrap_or(0);
+                let length = length
+                    .eval()?
+                    .eval_as_bigint()
+                    .ok()
+                    .and_then(|n| n.to_usize())
+                    .unwrap_or(0);
+
+                let (Some(pos), Some(_)) = (pos.checked_sub(1), length.checked_sub(1)) else {
+                    return Ok(String::new().into());
+                };
+
+                Ok(string
+                    .chars()
+                    .skip(pos)
+                    .take(length)
+                    .collect::<String>()
+                    .into())
             }
-            Some(other) => out_stack.push(other),
+            Self::Length { string } => Ok(string.eval()?.eval_as_string().chars().count().into()),
         }
     }
 }
 
-fn push_token_to_either_stack(
-    token_idx: usize,
-    token: &Token,
-    out_stack: &mut TokenStack,
-    op_stack: &mut TokenStack,
-) -> Result<(), String> {
-    let result = match token {
-        Token::Value { .. } => {
-            out_stack.push((token_idx, token.clone()));
-            Ok(())
-        }
+struct Parser<'a> {
+    input: &'a [&'a str],
+    index: usize,
+}
 
-        Token::InfixOp { .. } => {
-            if op_stack.is_empty() {
-                op_stack.push((token_idx, token.clone()));
-                Ok(())
-            } else {
-                push_op_to_stack(token_idx, token, out_stack, op_stack)
-            }
-        }
+impl<'a> Parser<'a> {
+    fn new(input: &'a [&'a str]) -> Self {
+        Self { input, index: 0 }
+    }
 
-        Token::PrefixOp { .. } | Token::ParOpen => {
-            op_stack.push((token_idx, token.clone()));
-            Ok(())
+    fn next(&mut self) -> ExprResult<&'a str> {
+        let next = self.input.get(self.index);
+        if let Some(next) = next {
+            self.index += 1;
+            Ok(next)
+        } else {
+            // The indexing won't panic, because we know that the input size
+            // is greater than zero.
+            Err(ExprError::MissingArgument(
+                self.input[self.index - 1].into(),
+            ))
         }
+    }
 
-        Token::ParClose => move_till_match_paren(out_stack, op_stack),
-    };
-    maybe_dump_shunting_yard_step(token_idx, token, out_stack, op_stack, &result);
-    result
-}
-
-#[allow(clippy::ptr_arg)]
-fn maybe_dump_shunting_yard_step(
-    token_idx: usize,
-    token: &Token,
-    out_stack: &TokenStack,
-    op_stack: &TokenStack,
-    result: &Result<(), String>,
-) {
-    use std::env;
-    if let Ok(debug_var) = env::var("EXPR_DEBUG_SYA_STEP") {
-        if debug_var == "1" {
-            println!("EXPR_DEBUG_SYA_STEP");
-            println!("\t{token_idx} => {token:?}");
-            println!("\t\tout: {out_stack:?}");
-            println!("\t\top : {op_stack:?}");
-            println!("\t\tresult: {result:?}");
+    fn accept<T>(&mut self, f: impl Fn(&str) -> Option<T>) -> Option<T> {
+        let next = self.input.get(self.index)?;
+        let tok = f(next);
+        if let Some(tok) = tok {
+            self.index += 1;
+            Some(tok)
+        } else {
+            None
         }
     }
-}
 
-fn push_op_to_stack(
-    token_idx: usize,
-    token: &Token,
-    out_stack: &mut TokenStack,
-    op_stack: &mut TokenStack,
-) -> Result<(), String> {
-    if let Token::InfixOp {
-        precedence: prec,
-        left_assoc: la,
-        ..
-    } = *token
-    {
-        loop {
-            match op_stack.last() {
-                None | Some(&(_, Token::ParOpen)) => {
-                    op_stack.push((token_idx, token.clone()));
-                    return Ok(());
-                }
+    fn parse(&mut self) -> ExprResult<AstNode> {
+        if self.input.is_empty() {
+            return Err(ExprError::MissingOperand);
+        }
+        let res = self.parse_expression()?;
+        if let Some(arg) = self.input.get(self.index) {
+            return Err(ExprError::UnexpectedArgument(arg.to_string()));
+        }
+        Ok(res)
+    }
 
-                Some(&(
-                    _,
-                    Token::InfixOp {
-                        precedence: prev_prec,
-                        ..
-                    },
-                )) => {
-                    if la && prev_prec >= prec || !la && prev_prec > prec {
-                        out_stack.push(op_stack.pop().unwrap());
-                    } else {
-                        op_stack.push((token_idx, token.clone()));
-                        return Ok(());
-                    }
-                }
+    fn parse_expression(&mut self) -> ExprResult<AstNode> {
+        self.parse_precedence(0)
+    }
 
-                Some(&(_, Token::PrefixOp { .. })) => {
-                    op_stack.push((token_idx, token.clone()));
-                    return Ok(());
+    fn parse_op(&mut self, precedence: usize) -> Option<BinOp> {
+        self.accept(|s| {
+            for (op_string, op) in PRECEDENCE[precedence] {
+                if s == *op_string {
+                    return Some(*op);
                 }
-
-                Some(_) => panic!("Non-operator on op_stack"),
             }
-        }
-    } else {
-        panic!("Expected infix-op")
+            None
+        })
     }
-}
 
-fn move_till_match_paren(
-    out_stack: &mut TokenStack,
-    op_stack: &mut TokenStack,
-) -> Result<(), String> {
-    loop {
-        let op = op_stack
-            .pop()
-            .ok_or_else(|| "syntax error (Mismatched close-parenthesis)".to_string())?;
-        match op {
-            (_, Token::ParOpen) => return Ok(()),
-            other => out_stack.push(other),
+    fn parse_precedence(&mut self, precedence: usize) -> ExprResult<AstNode> {
+        if precedence >= PRECEDENCE.len() {
+            return self.parse_simple_expression();
         }
-    }
-}
 
-fn infix_operator_two_ints<F>(f: F, values: &[String]) -> Result<String, String>
-where
-    F: Fn(BigInt, BigInt) -> Result<BigInt, String>,
-{
-    assert!(values.len() == 2);
-    if let Ok(left) = values[0].parse::<BigInt>() {
-        if let Ok(right) = values[1].parse::<BigInt>() {
-            return f(left, right).map(|big_int| big_int.to_string());
+        let mut left = self.parse_precedence(precedence + 1)?;
+        while let Some(op) = self.parse_op(precedence) {
+            let right = self.parse_precedence(precedence + 1)?;
+            left = AstNode::BinOp {
+                op_type: op,
+                left: Box::new(left),
+                right: Box::new(right),
+            };
         }
+        Ok(left)
     }
-    Err("Expected an integer operand".to_string())
-}
 
-fn infix_operator_two_ints_or_two_strings<FI, FS>(
-    fi: FI,
-    fs: FS,
-    values: &[String],
-) -> Result<String, String>
-where
-    FI: Fn(BigInt, BigInt) -> Result<u8, String>,
-    FS: Fn(&String, &String) -> Result<String, String>,
-{
-    assert!(values.len() == 2);
-    if let (Some(a_int), Some(b_int)) = (
-        values[0].parse::<BigInt>().ok(),
-        values[1].parse::<BigInt>().ok(),
-    ) {
-        match fi(a_int, b_int) {
-            Ok(result) => Ok(result.to_string()),
-            Err(reason) => Err(reason),
-        }
-    } else {
-        fs(&values[0], &values[1])
+    fn parse_simple_expression(&mut self) -> ExprResult<AstNode> {
+        let first = self.next()?;
+        Ok(match first {
+            "match" => {
+                let left = self.parse_expression()?;
+                let right = self.parse_expression()?;
+                AstNode::BinOp {
+                    op_type: BinOp::String(StringOp::Match),
+                    left: Box::new(left),
+                    right: Box::new(right),
+                }
+            }
+            "substr" => {
+                let string = self.parse_expression()?;
+                let pos = self.parse_expression()?;
+                let length = self.parse_expression()?;
+                AstNode::Substr {
+                    string: Box::new(string),
+                    pos: Box::new(pos),
+                    length: Box::new(length),
+                }
+            }
+            "index" => {
+                let left = self.parse_expression()?;
+                let right = self.parse_expression()?;
+                AstNode::BinOp {
+                    op_type: BinOp::String(StringOp::Index),
+                    left: Box::new(left),
+                    right: Box::new(right),
+                }
+            }
+            "length" => {
+                let string = self.parse_expression()?;
+                AstNode::Length {
+                    string: Box::new(string),
+                }
+            }
+            "+" => AstNode::Leaf {
+                value: self.next()?.into(),
+            },
+            "(" => {
+                let s = self.parse_expression()?;
+                let close_paren = self.next()?;
+                if close_paren != ")" {
+                    // Since we have parsed at least a '(', there will be a token
+                    // at `self.index - 1`. So this indexing won't panic.
+                    return Err(ExprError::ExpectedClosingBraceAfter(
+                        self.input[self.index - 1].into(),
+                    ));
+                }
+                s
+            }
+            s => AstNode::Leaf { value: s.into() },
+        })
     }
 }
 
-fn infix_operator_or(values: &[String]) -> String {
-    assert!(values.len() == 2);
-    if value_as_bool(&values[0]) {
-        values[0].clone()
-    } else if value_as_bool(&values[1]) {
-        values[1].clone()
-    } else {
-        0.to_string()
-    }
-}
+/// Determine whether `expr` should evaluate the string as "truthy"
+///
+/// Truthy strings are either empty or match the regex "-?0+".
+pub fn is_truthy(s: &NumOrStr) -> bool {
+    match s {
+        NumOrStr::Num(num) => num != &BigInt::from(0),
+        NumOrStr::Str(str) => {
+            // Edge case: `-` followed by nothing is truthy
+            if str == "-" {
+                return true;
+            }
 
-fn infix_operator_and(values: &[String]) -> String {
-    assert!(values.len() == 2);
-    if value_as_bool(&values[0]) && value_as_bool(&values[1]) {
-        values[0].clone()
-    } else {
-        0.to_string()
-    }
-}
+            let mut bytes = str.bytes();
 
-fn operator_match(values: &[String]) -> Result<String, String> {
-    assert!(values.len() == 2);
-    let re = Regex::with_options(&values[1], RegexOptions::REGEX_OPTION_NONE, Syntax::grep())
-        .map_err(|err| err.description().to_string())?;
-    Ok(if re.captures_len() > 0 {
-        re.captures(&values[0])
-            .map(|captures| captures.at(1).unwrap())
-            .unwrap_or("")
-            .to_string()
-    } else {
-        re.find(&values[0])
-            .map_or("0".to_string(), |(start, end)| (end - start).to_string())
-    })
-}
+            // Empty string is falsy
+            let Some(first) = bytes.next() else {
+                return false;
+            };
 
-fn prefix_operator_length(values: &[String]) -> String {
-    assert!(values.len() == 1);
-    // Use chars().count() as we can have some multibytes chars
-    // See https://github.com/uutils/coreutils/issues/3132
-    values[0].chars().count().to_string()
+            let is_zero = (first == b'-' || first == b'0') && bytes.all(|b| b == b'0');
+            !is_zero
+        }
+    }
 }
 
-fn prefix_operator_index(values: &[String]) -> String {
-    assert!(values.len() == 2);
-    let haystack = &values[0];
-    let needles = &values[1];
+#[cfg(test)]
+mod test {
+    use super::{AstNode, BinOp, NumericOp, RelationOp, StringOp};
 
-    for (current_idx, ch_h) in haystack.chars().enumerate() {
-        for ch_n in needles.chars() {
-            if ch_n == ch_h {
-                return (current_idx + 1).to_string();
+    impl From<&str> for AstNode {
+        fn from(value: &str) -> Self {
+            Self::Leaf {
+                value: value.into(),
             }
         }
     }
-    "0".to_string()
-}
 
-fn prefix_operator_substr(values: &[String]) -> String {
-    assert!(values.len() == 3);
-    let subj = &values[0];
-    let idx = match values[1]
-        .parse::<usize>()
-        .ok()
-        .and_then(|v| v.checked_sub(1))
-    {
-        Some(i) => i,
-        None => return String::new(),
-    };
-    let len = match values[2].parse::<usize>() {
-        Ok(i) => i,
-        Err(_) => return String::new(),
-    };
-
-    subj.chars().skip(idx).take(len).collect()
-}
+    fn op(op_type: BinOp, left: impl Into<AstNode>, right: impl Into<AstNode>) -> AstNode {
+        AstNode::BinOp {
+            op_type,
+            left: Box::new(left.into()),
+            right: Box::new(right.into()),
+        }
+    }
 
-fn bool_as_int(b: bool) -> u8 {
-    u8::from(b)
-}
+    fn length(string: impl Into<AstNode>) -> AstNode {
+        AstNode::Length {
+            string: Box::new(string.into()),
+        }
+    }
 
-fn bool_as_string(b: bool) -> String {
-    if b {
-        "1".to_string()
-    } else {
-        "0".to_string()
+    fn substr(
+        string: impl Into<AstNode>,
+        pos: impl Into<AstNode>,
+        length: impl Into<AstNode>,
+    ) -> AstNode {
+        AstNode::Substr {
+            string: Box::new(string.into()),
+            pos: Box::new(pos.into()),
+            length: Box::new(length.into()),
+        }
     }
-}
 
-fn value_as_bool(s: &str) -> bool {
-    if s.is_empty() {
-        return false;
+    #[test]
+    fn infix_operators() {
+        let cases = [
+            ("|", BinOp::String(StringOp::Or)),
+            ("&", BinOp::String(StringOp::And)),
+            ("<", BinOp::Relation(RelationOp::Lt)),
+            ("<=", BinOp::Relation(RelationOp::Leq)),
+            ("=", BinOp::Relation(RelationOp::Eq)),
+            ("!=", BinOp::Relation(RelationOp::Neq)),
+            (">=", BinOp::Relation(RelationOp::Geq)),
+            (">", BinOp::Relation(RelationOp::Gt)),
+            ("+", BinOp::Numeric(NumericOp::Add)),
+            ("-", BinOp::Numeric(NumericOp::Sub)),
+            ("*", BinOp::Numeric(NumericOp::Mul)),
+            ("/", BinOp::Numeric(NumericOp::Div)),
+            ("%", BinOp::Numeric(NumericOp::Mod)),
+            (":", BinOp::String(StringOp::Match)),
+        ];
+        for (string, value) in cases {
+            assert_eq!(AstNode::parse(&["1", string, "2"]), Ok(op(value, "1", "2")));
+        }
+    }
+
+    #[test]
+    fn other_operators() {
+        assert_eq!(
+            AstNode::parse(&["match", "1", "2"]),
+            Ok(op(BinOp::String(StringOp::Match), "1", "2")),
+        );
+        assert_eq!(
+            AstNode::parse(&["index", "1", "2"]),
+            Ok(op(BinOp::String(StringOp::Index), "1", "2")),
+        );
+        assert_eq!(AstNode::parse(&["length", "1"]), Ok(length("1")),);
+        assert_eq!(
+            AstNode::parse(&["substr", "1", "2", "3"]),
+            Ok(substr("1", "2", "3")),
+        );
     }
-    match s.parse::<BigInt>() {
-        Ok(n) => n != Zero::zero(),
-        Err(_) => true,
+
+    #[test]
+    fn precedence() {
+        assert_eq!(
+            AstNode::parse(&["1", "+", "2", "*", "3"]),
+            Ok(op(
+                BinOp::Numeric(NumericOp::Add),
+                "1",
+                op(BinOp::Numeric(NumericOp::Mul), "2", "3")
+            ))
+        );
+        assert_eq!(
+            AstNode::parse(&["(", "1", "+", "2", ")", "*", "3"]),
+            Ok(op(
+                BinOp::Numeric(NumericOp::Mul),
+                op(BinOp::Numeric(NumericOp::Add), "1", "2"),
+                "3"
+            ))
+        );
+        assert_eq!(
+            AstNode::parse(&["1", "*", "2", "+", "3"]),
+            Ok(op(
+                BinOp::Numeric(NumericOp::Add),
+                op(BinOp::Numeric(NumericOp::Mul), "1", "2"),
+                "3"
+            )),
+        );
     }
 }
diff --git a/src/uu/expr/src/tokens.rs b/src/uu/expr/src/tokens.rs
deleted file mode 100644
index f499881c138..00000000000
--- a/src/uu/expr/src/tokens.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-
-//!
-//! The following tokens are present in the expr grammar:
-//! * integer literal;
-//! * string literal;
-//! * infix binary operators;
-//! * prefix operators.
-//!
-//! According to the man-page of expr we have expression split into tokens (each token -- separate CLI-argument).
-//! Hence all we need is to map the strings into the Token structures, except for some ugly fiddling with +-escaping.
-//!
-
-// spell-checker:ignore (ToDO) paren
-
-#[derive(Debug, Clone)]
-pub enum Token {
-    Value {
-        value: String,
-    },
-
-    ParOpen,
-    ParClose,
-
-    InfixOp {
-        precedence: u8,
-        left_assoc: bool,
-        value: String,
-    },
-
-    PrefixOp {
-        arity: usize,
-        value: String,
-    },
-}
-
-impl Token {
-    fn new_infix_op(v: &str, left_assoc: bool, precedence: u8) -> Self {
-        Self::InfixOp {
-            left_assoc,
-            precedence,
-            value: v.into(),
-        }
-    }
-
-    fn new_value(v: &str) -> Self {
-        Self::Value { value: v.into() }
-    }
-
-    fn is_infix_plus(&self) -> bool {
-        match self {
-            Self::InfixOp { value, .. } => value == "+",
-            _ => false,
-        }
-    }
-
-    fn is_a_value(&self) -> bool {
-        matches!(*self, Self::Value { .. })
-    }
-
-    fn is_a_close_paren(&self) -> bool {
-        matches!(*self, Self::ParClose)
-    }
-}
-
-pub fn strings_to_tokens(strings: &[&str]) -> Result<Vec<(usize, Token)>, String> {
-    let mut tokens_acc = Vec::with_capacity(strings.len());
-    let mut tok_idx = 1;
-
-    for s in strings {
-        let token_if_not_escaped = match *s {
-            "(" => Token::ParOpen,
-            ")" => Token::ParClose,
-
-            "^" => Token::new_infix_op(s, false, 7),
-
-            ":" => Token::new_infix_op(s, true, 6),
-
-            "*" | "/" | "%" => Token::new_infix_op(s, true, 5),
-
-            "+" | "-" => Token::new_infix_op(s, true, 4),
-
-            "=" | "!=" | "<" | ">" | "<=" | ">=" => Token::new_infix_op(s, true, 3),
-
-            "&" => Token::new_infix_op(s, true, 2),
-
-            "|" => Token::new_infix_op(s, true, 1),
-
-            "match" | "index" => Token::PrefixOp {
-                arity: 2,
-                value: s.to_string(),
-            },
-            "substr" => Token::PrefixOp {
-                arity: 3,
-                value: s.to_string(),
-            },
-            "length" => Token::PrefixOp {
-                arity: 1,
-                value: s.to_string(),
-            },
-
-            _ => Token::new_value(s),
-        };
-        push_token_if_not_escaped(&mut tokens_acc, tok_idx, token_if_not_escaped, s);
-        tok_idx += 1;
-    }
-    maybe_dump_tokens_acc(&tokens_acc);
-
-    Ok(tokens_acc)
-}
-
-fn maybe_dump_tokens_acc(tokens_acc: &[(usize, Token)]) {
-    use std::env;
-
-    if let Ok(debug_var) = env::var("EXPR_DEBUG_TOKENS") {
-        if debug_var == "1" {
-            println!("EXPR_DEBUG_TOKENS");
-            for token in tokens_acc {
-                println!("\t{token:?}");
-            }
-        }
-    }
-}
-
-fn push_token_if_not_escaped(acc: &mut Vec<(usize, Token)>, tok_idx: usize, token: Token, s: &str) {
-    // `+` may be escaped such as `expr + 1` and `expr 1 + + 1`
-    let prev_is_plus = match acc.last() {
-        None => false,
-        Some(t) => t.1.is_infix_plus(),
-    };
-    let should_use_as_escaped = if prev_is_plus && acc.len() >= 2 {
-        let pre_prev = &acc[acc.len() - 2];
-        !(pre_prev.1.is_a_value() || pre_prev.1.is_a_close_paren())
-    } else {
-        prev_is_plus
-    };
-
-    if should_use_as_escaped {
-        acc.pop();
-        acc.push((tok_idx, Token::new_value(s)));
-    } else {
-        acc.push((tok_idx, token));
-    }
-}
diff --git a/src/uu/factor/Cargo.toml b/src/uu/factor/Cargo.toml
index aee67eeeaf0..a149056888a 100644
--- a/src/uu/factor/Cargo.toml
+++ b/src/uu/factor/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_factor"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "factor ~ (uutils) display the prime factors of each NUMBER"
diff --git a/src/uu/factor/src/cli.rs b/src/uu/factor/src/cli.rs
index 63a0632a3b7..d01ca625c7b 100644
--- a/src/uu/factor/src/cli.rs
+++ b/src/uu/factor/src/cli.rs
@@ -73,9 +73,18 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         let stdin = stdin();
         let lines = stdin.lock().lines();
         for line in lines {
-            for number in line.unwrap().split_whitespace() {
-                print_factors_str(number, &mut w, print_exponents)
-                    .map_err_context(|| "write error".into())?;
+            match line {
+                Ok(line) => {
+                    for number in line.split_whitespace() {
+                        print_factors_str(number, &mut w, print_exponents)
+                            .map_err_context(|| "write error".into())?;
+                    }
+                }
+                Err(e) => {
+                    set_exit_code(1);
+                    show_error!("error reading input: {}", e);
+                    return Ok(());
+                }
             }
         }
     }
diff --git a/src/uu/factor/src/factor.rs b/src/uu/factor/src/factor.rs
index a7e848bb883..d7899a7e6ee 100644
--- a/src/uu/factor/src/factor.rs
+++ b/src/uu/factor/src/factor.rs
@@ -3,6 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+#![allow(clippy::items_after_test_module)]
 use smallvec::SmallVec;
 use std::cell::RefCell;
 use std::fmt;
diff --git a/src/uu/false/Cargo.toml b/src/uu/false/Cargo.toml
index 50b5bc027d8..e88fa99783f 100644
--- a/src/uu/false/Cargo.toml
+++ b/src/uu/false/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_false"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "false ~ (uutils) do nothing and fail"
diff --git a/src/uu/fmt/Cargo.toml b/src/uu/fmt/Cargo.toml
index 688525e3b00..de415310f2f 100644
--- a/src/uu/fmt/Cargo.toml
+++ b/src/uu/fmt/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_fmt"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "fmt ~ (uutils) reformat each paragraph of input"
diff --git a/src/uu/fmt/src/fmt.rs b/src/uu/fmt/src/fmt.rs
index c30d923b76b..4380487814b 100644
--- a/src/uu/fmt/src/fmt.rs
+++ b/src/uu/fmt/src/fmt.rs
@@ -5,40 +5,42 @@
 
 // spell-checker:ignore (ToDO) PSKIP linebreak ostream parasplit tabwidth xanti xprefix
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use std::cmp;
+use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use std::fs::File;
-use std::io::{stdin, stdout, Write};
-use std::io::{BufReader, BufWriter, Read, Stdout};
+use std::io::{stdin, stdout, BufReader, BufWriter, Read, Stdout, Write};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
 use uucore::{format_usage, help_about, help_usage, show_warning};
 
-use self::linebreak::break_lines;
-use self::parasplit::ParagraphStream;
+use linebreak::break_lines;
+use parasplit::ParagraphStream;
 
 mod linebreak;
 mod parasplit;
 
-static ABOUT: &str = help_about!("fmt.md");
+const ABOUT: &str = help_about!("fmt.md");
 const USAGE: &str = help_usage!("fmt.md");
-static MAX_WIDTH: usize = 2500;
-
-static OPT_CROWN_MARGIN: &str = "crown-margin";
-static OPT_TAGGED_PARAGRAPH: &str = "tagged-paragraph";
-static OPT_PRESERVE_HEADERS: &str = "preserve-headers";
-static OPT_SPLIT_ONLY: &str = "split-only";
-static OPT_UNIFORM_SPACING: &str = "uniform-spacing";
-static OPT_PREFIX: &str = "prefix";
-static OPT_SKIP_PREFIX: &str = "skip-prefix";
-static OPT_EXACT_PREFIX: &str = "exact-prefix";
-static OPT_EXACT_SKIP_PREFIX: &str = "exact-skip-prefix";
-static OPT_WIDTH: &str = "width";
-static OPT_GOAL: &str = "goal";
-static OPT_QUICK: &str = "quick";
-static OPT_TAB_WIDTH: &str = "tab-width";
+const MAX_WIDTH: usize = 2500;
+
+mod options {
+    pub const CROWN_MARGIN: &str = "crown-margin";
+    pub const TAGGED_PARAGRAPH: &str = "tagged-paragraph";
+    pub const PRESERVE_HEADERS: &str = "preserve-headers";
+    pub const SPLIT_ONLY: &str = "split-only";
+    pub const UNIFORM_SPACING: &str = "uniform-spacing";
+    pub const PREFIX: &str = "prefix";
+    pub const SKIP_PREFIX: &str = "skip-prefix";
+    pub const EXACT_PREFIX: &str = "exact-prefix";
+    pub const EXACT_SKIP_PREFIX: &str = "exact-skip-prefix";
+    pub const WIDTH: &str = "width";
+    pub const GOAL: &str = "goal";
+    pub const QUICK: &str = "quick";
+    pub const TAB_WIDTH: &str = "tab-width";
+    pub const FILES: &str = "files";
+}
 
-static ARG_FILES: &str = "files";
+// by default, goal is 93% of width
+const DEFAULT_GOAL_TO_WIDTH_RATIO: usize = 93;
 
 pub type FileOrStdReader = BufReader<Box<dyn Read + 'static>>;
 pub struct FmtOptions {
@@ -46,11 +48,9 @@ pub struct FmtOptions {
     tagged: bool,
     mail: bool,
     split_only: bool,
-    use_prefix: bool,
-    prefix: String,
+    prefix: Option<String>,
     xprefix: bool,
-    use_anti_prefix: bool,
-    anti_prefix: String,
+    anti_prefix: Option<String>,
     xanti_prefix: bool,
     uniform: bool,
     quick: bool,
@@ -59,131 +59,92 @@ pub struct FmtOptions {
     tabwidth: usize,
 }
 
-impl Default for FmtOptions {
-    fn default() -> Self {
-        Self {
-            crown: false,
-            tagged: false,
-            mail: false,
-            uniform: false,
-            quick: false,
-            split_only: false,
-            use_prefix: false,
-            prefix: String::new(),
-            xprefix: false,
-            use_anti_prefix: false,
-            anti_prefix: String::new(),
-            xanti_prefix: false,
-            width: 75,
-            goal: 70,
-            tabwidth: 8,
-        }
-    }
-}
+impl FmtOptions {
+    fn from_matches(matches: &ArgMatches) -> UResult<Self> {
+        let mut tagged = matches.get_flag(options::TAGGED_PARAGRAPH);
+        let mut crown = matches.get_flag(options::CROWN_MARGIN);
 
-/// Parse the command line arguments and return the list of files and formatting options.
-///
-/// # Arguments
-///
-/// * `args` - Command line arguments.
-///
-/// # Returns
-///
-/// A tuple containing a vector of file names and a `FmtOptions` struct.
-#[allow(clippy::cognitive_complexity)]
-#[allow(clippy::field_reassign_with_default)]
-fn parse_arguments(args: impl uucore::Args) -> UResult<(Vec<String>, FmtOptions)> {
-    // by default, goal is 93% of width
-    const DEFAULT_GOAL_TO_WIDTH_RATIO: usize = 93;
+        let mail = matches.get_flag(options::PRESERVE_HEADERS);
+        let uniform = matches.get_flag(options::UNIFORM_SPACING);
+        let quick = matches.get_flag(options::QUICK);
+        let split_only = matches.get_flag(options::SPLIT_ONLY);
 
-    let matches = uu_app().try_get_matches_from(args)?;
-
-    let mut files: Vec<String> = matches
-        .get_many::<String>(ARG_FILES)
-        .map(|v| v.map(ToString::to_string).collect())
-        .unwrap_or_default();
-
-    let mut fmt_opts = FmtOptions::default();
-
-    fmt_opts.tagged = matches.get_flag(OPT_TAGGED_PARAGRAPH);
-    if matches.get_flag(OPT_CROWN_MARGIN) {
-        fmt_opts.crown = true;
-        fmt_opts.tagged = false;
-    }
-    fmt_opts.mail = matches.get_flag(OPT_PRESERVE_HEADERS);
-    fmt_opts.uniform = matches.get_flag(OPT_UNIFORM_SPACING);
-    fmt_opts.quick = matches.get_flag(OPT_QUICK);
-    if matches.get_flag(OPT_SPLIT_ONLY) {
-        fmt_opts.split_only = true;
-        fmt_opts.crown = false;
-        fmt_opts.tagged = false;
-    }
-    fmt_opts.xprefix = matches.contains_id(OPT_EXACT_PREFIX);
-    fmt_opts.xanti_prefix = matches.contains_id(OPT_SKIP_PREFIX);
-
-    if let Some(s) = matches.get_one::<String>(OPT_PREFIX).map(String::from) {
-        fmt_opts.prefix = s;
-        fmt_opts.use_prefix = true;
-    };
+        if crown {
+            tagged = false;
+        }
+        if split_only {
+            crown = false;
+            tagged = false;
+        }
 
-    if let Some(s) = matches.get_one::<String>(OPT_SKIP_PREFIX).map(String::from) {
-        fmt_opts.anti_prefix = s;
-        fmt_opts.use_anti_prefix = true;
-    };
+        let xprefix = matches.contains_id(options::EXACT_PREFIX);
+        let xanti_prefix = matches.contains_id(options::SKIP_PREFIX);
+
+        let prefix = matches.get_one::<String>(options::PREFIX).map(String::from);
+        let anti_prefix = matches
+            .get_one::<String>(options::SKIP_PREFIX)
+            .map(String::from);
+
+        let width_opt = matches.get_one::<usize>(options::WIDTH);
+        let goal_opt = matches.get_one::<usize>(options::GOAL);
+        let (width, goal) = match (width_opt, goal_opt) {
+            (Some(&w), Some(&g)) => {
+                if g > w {
+                    return Err(USimpleError::new(1, "GOAL cannot be greater than WIDTH."));
+                }
+                (w, g)
+            }
+            (Some(&w), None) => {
+                let g = (w * DEFAULT_GOAL_TO_WIDTH_RATIO / 100).min(w - 3);
+                (w, g)
+            }
+            (None, Some(&g)) => {
+                let w = (g * 100 / DEFAULT_GOAL_TO_WIDTH_RATIO).max(g + 3);
+                (w, g)
+            }
+            (None, None) => (75, 70),
+        };
 
-    if let Some(width) = matches.get_one::<usize>(OPT_WIDTH) {
-        fmt_opts.width = *width;
-        if fmt_opts.width > MAX_WIDTH {
+        if width > MAX_WIDTH {
             return Err(USimpleError::new(
                 1,
-                format!(
-                    "invalid width: '{}': Numerical result out of range",
-                    fmt_opts.width,
-                ),
+                format!("invalid width: '{}': Numerical result out of range", width),
             ));
         }
-        fmt_opts.goal = cmp::min(
-            fmt_opts.width * DEFAULT_GOAL_TO_WIDTH_RATIO / 100,
-            fmt_opts.width - 3,
-        );
-    };
 
-    if let Some(goal) = matches.get_one::<usize>(OPT_GOAL) {
-        fmt_opts.goal = *goal;
-        if !matches.contains_id(OPT_WIDTH) {
-            fmt_opts.width = cmp::max(
-                fmt_opts.goal * 100 / DEFAULT_GOAL_TO_WIDTH_RATIO,
-                fmt_opts.goal + 3,
-            );
-        } else if fmt_opts.goal > fmt_opts.width {
-            return Err(USimpleError::new(1, "GOAL cannot be greater than WIDTH."));
-        }
-    };
-
-    if let Some(s) = matches.get_one::<String>(OPT_TAB_WIDTH) {
-        fmt_opts.tabwidth = match s.parse::<usize>() {
-            Ok(t) => t,
-            Err(e) => {
-                return Err(USimpleError::new(
-                    1,
-                    format!("Invalid TABWIDTH specification: {}: {}", s.quote(), e),
-                ));
-            }
+        let mut tabwidth = 8;
+        if let Some(s) = matches.get_one::<String>(options::TAB_WIDTH) {
+            tabwidth = match s.parse::<usize>() {
+                Ok(t) => t,
+                Err(e) => {
+                    return Err(USimpleError::new(
+                        1,
+                        format!("Invalid TABWIDTH specification: {}: {}", s.quote(), e),
+                    ));
+                }
+            };
         };
-    };
 
-    if fmt_opts.tabwidth < 1 {
-        fmt_opts.tabwidth = 1;
-    }
-
-    // immutable now
-    let fmt_opts = fmt_opts;
+        if tabwidth < 1 {
+            tabwidth = 1;
+        }
 
-    if files.is_empty() {
-        files.push("-".to_owned());
+        Ok(Self {
+            crown,
+            tagged,
+            mail,
+            uniform,
+            quick,
+            split_only,
+            prefix,
+            xprefix,
+            anti_prefix,
+            xanti_prefix,
+            width,
+            goal,
+            tabwidth,
+        })
     }
-
-    Ok((files, fmt_opts))
 }
 
 /// Process the content of a file and format it according to the provided options.
@@ -239,7 +200,14 @@ fn process_file(
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let (files, fmt_opts) = parse_arguments(args)?;
+    let matches = uu_app().try_get_matches_from(args)?;
+
+    let files: Vec<String> = matches
+        .get_many::<String>(options::FILES)
+        .map(|v| v.map(ToString::to_string).collect())
+        .unwrap_or(vec!["-".into()]);
+
+    let fmt_opts = FmtOptions::from_matches(&matches)?;
 
     let mut ostream = BufWriter::new(stdout());
 
@@ -257,9 +225,9 @@ pub fn uu_app() -> Command {
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .arg(
-            Arg::new(OPT_CROWN_MARGIN)
+            Arg::new(options::CROWN_MARGIN)
                 .short('c')
-                .long(OPT_CROWN_MARGIN)
+                .long(options::CROWN_MARGIN)
                 .help(
                     "First and second line of paragraph \
                     may have different indentations, in which \
@@ -269,7 +237,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_TAGGED_PARAGRAPH)
+            Arg::new(options::TAGGED_PARAGRAPH)
                 .short('t')
                 .long("tagged-paragraph")
                 .help(
@@ -279,7 +247,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_PRESERVE_HEADERS)
+            Arg::new(options::PRESERVE_HEADERS)
                 .short('m')
                 .long("preserve-headers")
                 .help(
@@ -289,14 +257,14 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_SPLIT_ONLY)
+            Arg::new(options::SPLIT_ONLY)
                 .short('s')
                 .long("split-only")
                 .help("Split lines only, do not reflow.")
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_UNIFORM_SPACING)
+            Arg::new(options::UNIFORM_SPACING)
                 .short('u')
                 .long("uniform-spacing")
                 .help(
@@ -309,7 +277,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_PREFIX)
+            Arg::new(options::PREFIX)
                 .short('p')
                 .long("prefix")
                 .help(
@@ -321,7 +289,7 @@ pub fn uu_app() -> Command {
                 .value_name("PREFIX"),
         )
         .arg(
-            Arg::new(OPT_SKIP_PREFIX)
+            Arg::new(options::SKIP_PREFIX)
                 .short('P')
                 .long("skip-prefix")
                 .help(
@@ -332,7 +300,7 @@ pub fn uu_app() -> Command {
                 .value_name("PSKIP"),
         )
         .arg(
-            Arg::new(OPT_EXACT_PREFIX)
+            Arg::new(options::EXACT_PREFIX)
                 .short('x')
                 .long("exact-prefix")
                 .help(
@@ -342,7 +310,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_EXACT_SKIP_PREFIX)
+            Arg::new(options::EXACT_SKIP_PREFIX)
                 .short('X')
                 .long("exact-skip-prefix")
                 .help(
@@ -352,7 +320,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_WIDTH)
+            Arg::new(options::WIDTH)
                 .short('w')
                 .long("width")
                 .help("Fill output lines up to a maximum of WIDTH columns, default 75.")
@@ -360,7 +328,7 @@ pub fn uu_app() -> Command {
                 .value_parser(clap::value_parser!(usize)),
         )
         .arg(
-            Arg::new(OPT_GOAL)
+            Arg::new(options::GOAL)
                 .short('g')
                 .long("goal")
                 .help("Goal width, default of 93% of WIDTH. Must be less than WIDTH.")
@@ -368,7 +336,7 @@ pub fn uu_app() -> Command {
                 .value_parser(clap::value_parser!(usize)),
         )
         .arg(
-            Arg::new(OPT_QUICK)
+            Arg::new(options::QUICK)
                 .short('q')
                 .long("quick")
                 .help(
@@ -378,7 +346,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_TAB_WIDTH)
+            Arg::new(options::TAB_WIDTH)
                 .short('T')
                 .long("tab-width")
                 .help(
@@ -389,7 +357,7 @@ pub fn uu_app() -> Command {
                 .value_name("TABWIDTH"),
         )
         .arg(
-            Arg::new(ARG_FILES)
+            Arg::new(options::FILES)
                 .action(ArgAction::Append)
                 .value_hint(clap::ValueHint::FilePath),
         )
diff --git a/src/uu/fmt/src/linebreak.rs b/src/uu/fmt/src/linebreak.rs
index fbd990fff1e..7393589d0b3 100644
--- a/src/uu/fmt/src/linebreak.rs
+++ b/src/uu/fmt/src/linebreak.rs
@@ -5,12 +5,8 @@
 
 // spell-checker:ignore (ToDO) INFTY MULT accum breakwords linebreak linebreaking linebreaks linelen maxlength minlength nchars ostream overlen parasplit plass posn powf punct signum slen sstart tabwidth tlen underlen winfo wlen wordlen
 
-use std::cmp;
-use std::i64;
 use std::io::{BufWriter, Stdout, Write};
-use std::mem;
-
-use uucore::crash;
+use std::{cmp, i64, mem};
 
 use crate::parasplit::{ParaWords, Paragraph, WordInfo};
 use crate::FmtOptions;
@@ -46,7 +42,7 @@ pub fn break_lines(
     ostream: &mut BufWriter<Stdout>,
 ) -> std::io::Result<()> {
     // indent
-    let p_indent = &para.indent_str[..];
+    let p_indent = &para.indent_str;
     let p_indent_len = para.indent_len;
 
     // words
@@ -55,14 +51,12 @@ pub fn break_lines(
 
     // the first word will *always* appear on the first line
     // make sure of this here
-    let (w, w_len) = match p_words_words.next() {
-        Some(winfo) => (winfo.word, winfo.word_nchars),
-        None => {
-            return ostream.write_all(b"\n");
-        }
+    let Some(winfo) = p_words_words.next() else {
+        return ostream.write_all(b"\n");
     };
+
     // print the init, if it exists, and get its length
-    let p_init_len = w_len
+    let p_init_len = winfo.word_nchars
         + if opts.crown || opts.tagged {
             // handle "init" portion
             ostream.write_all(para.init_str.as_bytes())?;
@@ -75,8 +69,9 @@ pub fn break_lines(
             // except that mail headers get no indent at all
             0
         };
+
     // write first word after writing init
-    ostream.write_all(w.as_bytes())?;
+    ostream.write_all(winfo.word.as_bytes())?;
 
     // does this paragraph require uniform spacing?
     let uniform = para.mail_header || opts.uniform;
@@ -103,15 +98,16 @@ fn break_simple<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
     mut iter: T,
     args: &mut BreakArgs<'a>,
 ) -> std::io::Result<()> {
-    iter.try_fold((args.init_len, false), |l, winfo| {
-        accum_words_simple(args, l, winfo)
+    iter.try_fold((args.init_len, false), |(l, prev_punct), winfo| {
+        accum_words_simple(args, l, prev_punct, winfo)
     })?;
     args.ostream.write_all(b"\n")
 }
 
 fn accum_words_simple<'a>(
     args: &mut BreakArgs<'a>,
-    (l, prev_punct): (usize, bool),
+    l: usize,
+    prev_punct: bool,
     winfo: &'a WordInfo<'a>,
 ) -> std::io::Result<(usize, bool)> {
     // compute the length of this word, considering how tabs will expand at this position on the line
@@ -233,14 +229,14 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
         linebreak: None,
         break_before: false,
         demerits: 0,
-        prev_rat: 0.0f32,
+        prev_rat: 0.0,
         length: args.init_len,
         fresh: false,
     }];
     // this vec holds the current active linebreaks; next_ holds the breaks that will be active for
     // the next word
-    let active_breaks = &mut vec![0];
-    let next_active_breaks = &mut vec![];
+    let mut active_breaks = vec![0];
+    let mut next_active_breaks = vec![];
 
     let stretch = (args.opts.width - args.opts.goal) as isize;
     let minlength = args.opts.goal - stretch as usize;
@@ -248,10 +244,7 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
     let mut is_sentence_start = false;
     let mut least_demerits = 0;
     loop {
-        let w = match iter.next() {
-            None => break,
-            Some(w) => w,
-        };
+        let Some(w) = iter.next() else { break };
 
         // if this is the last word, we don't add additional demerits for this break
         let (is_last_word, is_sentence_end) = match iter.peek() {
@@ -358,38 +351,36 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
             least_demerits = cmp::max(ld_next, 0);
         }
         // swap in new list of active breaks
-        mem::swap(active_breaks, next_active_breaks);
+        mem::swap(&mut active_breaks, &mut next_active_breaks);
         // If this was the last word in a sentence, the next one must be the first in the next.
         is_sentence_start = is_sentence_end;
     }
 
     // return the best path
-    build_best_path(&linebreaks, active_breaks)
+    build_best_path(&linebreaks, &active_breaks)
 }
 
 fn build_best_path<'a>(paths: &[LineBreak<'a>], active: &[usize]) -> Vec<(&'a WordInfo<'a>, bool)> {
-    let mut breakwords = vec![];
     // of the active paths, we select the one with the fewest demerits
-    let mut best_idx = match active.iter().min_by_key(|&&a| paths[a].demerits) {
-        None => crash!(
-            1,
-            "Failed to find a k-p linebreak solution. This should never happen."
-        ),
-        Some(&s) => s,
-    };
-
-    // now, chase the pointers back through the break list, recording
-    // the words at which we should break
-    loop {
-        let next_best = &paths[best_idx];
-        match next_best.linebreak {
-            None => return breakwords,
-            Some(prev) => {
-                breakwords.push((prev, next_best.break_before));
-                best_idx = next_best.prev;
+    active
+        .iter()
+        .min_by_key(|&&a| paths[a].demerits)
+        .map(|&(mut best_idx)| {
+            let mut breakwords = vec![];
+            // now, chase the pointers back through the break list, recording
+            // the words at which we should break
+            loop {
+                let next_best = &paths[best_idx];
+                match next_best.linebreak {
+                    None => return breakwords,
+                    Some(prev) => {
+                        breakwords.push((prev, next_best.break_before));
+                        best_idx = next_best.prev;
+                    }
+                }
             }
-        }
-    }
+        })
+        .unwrap_or_default()
 }
 
 // "infinite" badness is more like (1+BAD_INFTY)^2 because of how demerits are computed
diff --git a/src/uu/fmt/src/parasplit.rs b/src/uu/fmt/src/parasplit.rs
index 68c8f78fa89..1ae8ea34f42 100644
--- a/src/uu/fmt/src/parasplit.rs
+++ b/src/uu/fmt/src/parasplit.rs
@@ -3,7 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) INFTY MULT PSKIP accum aftertab beforetab breakwords fmt's formatline linebreak linebreaking linebreaks linelen maxlength minlength nchars noformat noformatline ostream overlen parasplit pfxind plass pmatch poffset posn powf prefixindent punct signum slen sstart tabwidth tlen underlen winfo wlen wordlen wordsplits xanti xprefix
+// spell-checker:ignore (ToDO) INFTY MULT PSKIP accum aftertab beforetab breakwords fmt's formatline linebreak linebreaking linebreaks linelen maxlength minlength nchars noformat noformatline ostream overlen parasplit plass pmatch poffset posn powf prefixindent punct signum slen sstart tabwidth tlen underlen winfo wlen wordlen wordsplits xanti xprefix
 
 use std::io::{BufRead, Lines};
 use std::iter::Peekable;
@@ -52,18 +52,22 @@ impl Line {
     }
 }
 
-// each line's prefix has to be considered to know whether to merge it with
-// the next line or not
+/// Each line's prefix has to be considered to know whether to merge it with
+/// the next line or not
 #[derive(Debug)]
 pub struct FileLine {
     line: String,
-    indent_end: usize, // the end of the indent, always the start of the text
-    pfxind_end: usize, // the end of the PREFIX's indent, that is, the spaces before the prefix
-    indent_len: usize, // display length of indent taking into account tabs
-    prefix_len: usize, // PREFIX indent length taking into account tabs
+    /// The end of the indent, always the start of the text
+    indent_end: usize,
+    /// The end of the PREFIX's indent, that is, the spaces before the prefix
+    prefix_indent_end: usize,
+    /// Display length of indent taking into account tabs
+    indent_len: usize,
+    /// PREFIX indent length taking into account tabs
+    prefix_len: usize,
 }
 
-// iterator that produces a stream of Lines from a file
+/// Iterator that produces a stream of Lines from a file
 pub struct FileLines<'a> {
     opts: &'a FmtOptions,
     lines: Lines<&'a mut FileOrStdReader>,
@@ -74,26 +78,22 @@ impl<'a> FileLines<'a> {
         FileLines { opts, lines }
     }
 
-    // returns true if this line should be formatted
+    /// returns true if this line should be formatted
     fn match_prefix(&self, line: &str) -> (bool, usize) {
-        if !self.opts.use_prefix {
+        let Some(prefix) = &self.opts.prefix else {
             return (true, 0);
-        }
+        };
 
-        FileLines::match_prefix_generic(&self.opts.prefix[..], line, self.opts.xprefix)
+        FileLines::match_prefix_generic(prefix, line, self.opts.xprefix)
     }
 
-    // returns true if this line should be formatted
+    /// returns true if this line should be formatted
     fn match_anti_prefix(&self, line: &str) -> bool {
-        if !self.opts.use_anti_prefix {
+        let Some(anti_prefix) = &self.opts.anti_prefix else {
             return true;
-        }
+        };
 
-        match FileLines::match_prefix_generic(
-            &self.opts.anti_prefix[..],
-            line,
-            self.opts.xanti_prefix,
-        ) {
+        match FileLines::match_prefix_generic(anti_prefix, line, self.opts.xanti_prefix) {
             (true, _) => false,
             (_, _) => true,
         }
@@ -148,13 +148,7 @@ impl<'a> Iterator for FileLines<'a> {
     type Item = Line;
 
     fn next(&mut self) -> Option<Line> {
-        let n = match self.lines.next() {
-            Some(t) => match t {
-                Ok(tt) => tt,
-                Err(_) => return None,
-            },
-            None => return None,
-        };
+        let n = self.lines.next()?.ok()?;
 
         // if this line is entirely whitespace,
         // emit a blank line
@@ -178,7 +172,7 @@ impl<'a> Iterator for FileLines<'a> {
         // not truly blank we will not allow mail headers on the
         // following line)
         if pmatch
-            && n[poffset + self.opts.prefix.len()..]
+            && n[poffset + self.opts.prefix.as_ref().map_or(0, |s| s.len())..]
                 .chars()
                 .all(char::is_whitespace)
         {
@@ -192,37 +186,46 @@ impl<'a> Iterator for FileLines<'a> {
         }
 
         // figure out the indent, prefix, and prefixindent ending points
-        let prefix_end = poffset + self.opts.prefix.len();
+        let prefix_end = poffset + self.opts.prefix.as_ref().map_or(0, |s| s.len());
         let (indent_end, prefix_len, indent_len) = self.compute_indent(&n[..], prefix_end);
 
         Some(Line::FormatLine(FileLine {
             line: n,
             indent_end,
-            pfxind_end: poffset,
+            prefix_indent_end: poffset,
             indent_len,
             prefix_len,
         }))
     }
 }
 
-// a paragraph : a collection of FileLines that are to be formatted
-// plus info about the paragraph's indentation
-// (but we only retain the String from the FileLine; the other info
-// is only there to help us in deciding how to merge lines into Paragraphs
+/// A paragraph : a collection of FileLines that are to be formatted
+/// plus info about the paragraph's indentation
+///
+/// We only retain the String from the FileLine; the other info
+/// is only there to help us in deciding how to merge lines into Paragraphs
 #[derive(Debug)]
 pub struct Paragraph {
-    lines: Vec<String>,     // the lines of the file
-    pub init_str: String,   // string representing the init, that is, the first line's indent
-    pub init_len: usize,    // printable length of the init string considering TABWIDTH
-    init_end: usize,        // byte location of end of init in first line String
-    pub indent_str: String, // string representing indent
-    pub indent_len: usize,  // length of above
-    indent_end: usize, // byte location of end of indent (in crown and tagged mode, only applies to 2nd line and onward)
-    pub mail_header: bool, // we need to know if this is a mail header because we do word splitting differently in that case
+    /// the lines of the file
+    lines: Vec<String>,
+    /// string representing the init, that is, the first line's indent
+    pub init_str: String,
+    /// printable length of the init string considering TABWIDTH
+    pub init_len: usize,
+    /// byte location of end of init in first line String
+    init_end: usize,
+    /// string representing indent
+    pub indent_str: String,
+    /// length of above
+    pub indent_len: usize,
+    /// byte location of end of indent (in crown and tagged mode, only applies to 2nd line and onward)
+    indent_end: usize,
+    /// we need to know if this is a mail header because we do word splitting differently in that case
+    pub mail_header: bool,
 }
 
-// an iterator producing a stream of paragraphs from a stream of lines
-// given a set of options.
+/// An iterator producing a stream of paragraphs from a stream of lines
+/// given a set of options.
 pub struct ParagraphStream<'a> {
     lines: Peekable<FileLines<'a>>,
     next_mail: bool,
@@ -240,7 +243,7 @@ impl<'a> ParagraphStream<'a> {
         }
     }
 
-    // detect RFC822 mail header
+    /// Detect RFC822 mail header
     fn is_mail_header(line: &FileLine) -> bool {
         // a mail header begins with either "From " (envelope sender line)
         // or with a sequence of printable ASCII chars (33 to 126, inclusive,
@@ -276,12 +279,9 @@ impl<'a> Iterator for ParagraphStream<'a> {
     #[allow(clippy::cognitive_complexity)]
     fn next(&mut self) -> Option<Result<Paragraph, String>> {
         // return a NoFormatLine in an Err; it should immediately be output
-        let noformat = match self.lines.peek() {
-            None => return None,
-            Some(l) => match *l {
-                Line::FormatLine(_) => false,
-                Line::NoFormatLine(_, _) => true,
-            },
+        let noformat = match self.lines.peek()? {
+            Line::FormatLine(_) => false,
+            Line::NoFormatLine(_, _) => true,
         };
 
         // found a NoFormatLine, immediately dump it out
@@ -299,101 +299,95 @@ impl<'a> Iterator for ParagraphStream<'a> {
         let mut indent_end = 0;
         let mut indent_len = 0;
         let mut prefix_len = 0;
-        let mut pfxind_end = 0;
+        let mut prefix_indent_end = 0;
         let mut p_lines = Vec::new();
 
         let mut in_mail = false;
         let mut second_done = false; // for when we use crown or tagged mode
         loop {
-            {
-                // peek ahead
-                // need to explicitly force fl out of scope before we can call self.lines.next()
-                let fl = match self.lines.peek() {
-                    None => break,
-                    Some(l) => match *l {
-                        Line::FormatLine(ref x) => x,
-                        Line::NoFormatLine(..) => break,
-                    },
-                };
+            // peek ahead
+            // need to explicitly force fl out of scope before we can call self.lines.next()
+            let Some(Line::FormatLine(fl)) = self.lines.peek() else {
+                break;
+            };
 
-                if p_lines.is_empty() {
-                    // first time through the loop, get things set up
-                    // detect mail header
-                    if self.opts.mail && self.next_mail && ParagraphStream::is_mail_header(fl) {
-                        in_mail = true;
-                        // there can't be any indent or pfxind because otherwise is_mail_header
-                        // would fail since there cannot be any whitespace before the colon in a
-                        // valid header field
-                        indent_str.push_str("  ");
-                        indent_len = 2;
+            if p_lines.is_empty() {
+                // first time through the loop, get things set up
+                // detect mail header
+                if self.opts.mail && self.next_mail && ParagraphStream::is_mail_header(fl) {
+                    in_mail = true;
+                    // there can't be any indent or prefixindent because otherwise is_mail_header
+                    // would fail since there cannot be any whitespace before the colon in a
+                    // valid header field
+                    indent_str.push_str("  ");
+                    indent_len = 2;
+                } else {
+                    if self.opts.crown || self.opts.tagged {
+                        init_str.push_str(&fl.line[..fl.indent_end]);
+                        init_len = fl.indent_len;
+                        init_end = fl.indent_end;
                     } else {
-                        if self.opts.crown || self.opts.tagged {
-                            init_str.push_str(&fl.line[..fl.indent_end]);
-                            init_len = fl.indent_len;
-                            init_end = fl.indent_end;
-                        } else {
-                            second_done = true;
-                        }
-
-                        // these will be overwritten in the 2nd line of crown or tagged mode, but
-                        // we are not guaranteed to get to the 2nd line, e.g., if the next line
-                        // is a NoFormatLine or None. Thus, we set sane defaults the 1st time around
-                        indent_str.push_str(&fl.line[..fl.indent_end]);
-                        indent_len = fl.indent_len;
-                        indent_end = fl.indent_end;
-
-                        // save these to check for matching lines
-                        prefix_len = fl.prefix_len;
-                        pfxind_end = fl.pfxind_end;
-
-                        // in tagged mode, add 4 spaces of additional indenting by default
-                        // (gnu fmt's behavior is different: it seems to find the closest column to
-                        // indent_end that is divisible by 3. But honestly that behavior seems
-                        // pretty arbitrary.
-                        // Perhaps a better default would be 1 TABWIDTH? But ugh that's so big.
-                        if self.opts.tagged {
-                            indent_str.push_str("    ");
-                            indent_len += 4;
-                        }
-                    }
-                } else if in_mail {
-                    // lines following mail headers must begin with spaces
-                    if fl.indent_end == 0 || (self.opts.use_prefix && fl.pfxind_end == 0) {
-                        break; // this line does not begin with spaces
-                    }
-                } else if !second_done {
-                    // now we have enough info to handle crown margin and tagged mode
-
-                    // in both crown and tagged modes we require that prefix_len is the same
-                    if prefix_len != fl.prefix_len || pfxind_end != fl.pfxind_end {
-                        break;
-                    }
-
-                    // in tagged mode, indent has to be *different* on following lines
-                    if self.opts.tagged
-                        && indent_len - 4 == fl.indent_len
-                        && indent_end == fl.indent_end
-                    {
-                        break;
+                        second_done = true;
                     }
 
-                    // this is part of the same paragraph, get the indent info from this line
-                    indent_str.clear();
+                    // these will be overwritten in the 2nd line of crown or tagged mode, but
+                    // we are not guaranteed to get to the 2nd line, e.g., if the next line
+                    // is a NoFormatLine or None. Thus, we set sane defaults the 1st time around
                     indent_str.push_str(&fl.line[..fl.indent_end]);
                     indent_len = fl.indent_len;
                     indent_end = fl.indent_end;
 
-                    second_done = true;
-                } else {
-                    // detect mismatch
-                    if indent_end != fl.indent_end
-                        || pfxind_end != fl.pfxind_end
-                        || indent_len != fl.indent_len
-                        || prefix_len != fl.prefix_len
-                    {
-                        break;
+                    // save these to check for matching lines
+                    prefix_len = fl.prefix_len;
+                    prefix_indent_end = fl.prefix_indent_end;
+
+                    // in tagged mode, add 4 spaces of additional indenting by default
+                    // (gnu fmt's behavior is different: it seems to find the closest column to
+                    // indent_end that is divisible by 3. But honestly that behavior seems
+                    // pretty arbitrary.
+                    // Perhaps a better default would be 1 TABWIDTH? But ugh that's so big.
+                    if self.opts.tagged {
+                        indent_str.push_str("    ");
+                        indent_len += 4;
                     }
                 }
+            } else if in_mail {
+                // lines following mail headers must begin with spaces
+                if fl.indent_end == 0 || (self.opts.prefix.is_some() && fl.prefix_indent_end == 0) {
+                    break; // this line does not begin with spaces
+                }
+            } else if !second_done {
+                // now we have enough info to handle crown margin and tagged mode
+
+                // in both crown and tagged modes we require that prefix_len is the same
+                if prefix_len != fl.prefix_len || prefix_indent_end != fl.prefix_indent_end {
+                    break;
+                }
+
+                // in tagged mode, indent has to be *different* on following lines
+                if self.opts.tagged
+                    && indent_len - 4 == fl.indent_len
+                    && indent_end == fl.indent_end
+                {
+                    break;
+                }
+
+                // this is part of the same paragraph, get the indent info from this line
+                indent_str.clear();
+                indent_str.push_str(&fl.line[..fl.indent_end]);
+                indent_len = fl.indent_len;
+                indent_end = fl.indent_end;
+
+                second_done = true;
+            } else {
+                // detect mismatch
+                if indent_end != fl.indent_end
+                    || prefix_indent_end != fl.prefix_indent_end
+                    || indent_len != fl.indent_len
+                    || prefix_len != fl.prefix_len
+                {
+                    break;
+                }
             }
 
             p_lines.push(self.lines.next().unwrap().get_formatline().line);
@@ -429,7 +423,7 @@ pub struct ParaWords<'a> {
 }
 
 impl<'a> ParaWords<'a> {
-    pub fn new<'b>(opts: &'b FmtOptions, para: &'b Paragraph) -> ParaWords<'b> {
+    pub fn new(opts: &'a FmtOptions, para: &'a Paragraph) -> Self {
         let mut pw = ParaWords {
             opts,
             para,
diff --git a/src/uu/fold/Cargo.toml b/src/uu/fold/Cargo.toml
index 1887f1bbd3a..02cf1115ec2 100644
--- a/src/uu/fold/Cargo.toml
+++ b/src/uu/fold/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_fold"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "fold ~ (uutils) wrap each line of input"
diff --git a/src/uu/groups/Cargo.toml b/src/uu/groups/Cargo.toml
index 9c513517500..dac52fc5864 100644
--- a/src/uu/groups/Cargo.toml
+++ b/src/uu/groups/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_groups"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "groups ~ (uutils) display group memberships for USERNAME"
diff --git a/src/uu/hashsum/Cargo.toml b/src/uu/hashsum/Cargo.toml
index 1ecb5f8403c..a20fe0d7826 100644
--- a/src/uu/hashsum/Cargo.toml
+++ b/src/uu/hashsum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_hashsum"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "hashsum ~ (uutils) display or check input digests"
diff --git a/src/uu/hashsum/src/hashsum.rs b/src/uu/hashsum/src/hashsum.rs
index d27b09b98ed..5e439853a58 100644
--- a/src/uu/hashsum/src/hashsum.rs
+++ b/src/uu/hashsum/src/hashsum.rs
@@ -20,12 +20,13 @@ use std::io::{self, stdin, BufRead, BufReader, Read};
 use std::iter;
 use std::num::ParseIntError;
 use std::path::Path;
+use uucore::error::USimpleError;
 use uucore::error::{FromIo, UError, UResult};
 use uucore::sum::{
     Blake2b, Blake3, Digest, DigestWriter, Md5, Sha1, Sha224, Sha256, Sha384, Sha3_224, Sha3_256,
     Sha3_384, Sha3_512, Sha512, Shake128, Shake256,
 };
-use uucore::{crash, display::Quotable, show_warning};
+use uucore::{display::Quotable, show_warning};
 use uucore::{format_usage, help_about, help_usage};
 
 const NAME: &str = "hashsum";
@@ -51,28 +52,32 @@ struct Options {
 ///
 /// # Returns
 ///
-/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
-///
-/// # Panics
-///
-/// Panics if the length is not a multiple of 8 or if it is greater than 512.
-fn create_blake2b(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits or an Err if the length is not a multiple of 8 or if it is
+/// greater than 512.
+fn create_blake2b(matches: &ArgMatches) -> UResult<(&'static str, Box<dyn Digest>, usize)> {
     match matches.get_one::<usize>("length") {
-        Some(0) | None => ("BLAKE2", Box::new(Blake2b::new()) as Box<dyn Digest>, 512),
+        Some(0) | None => Ok(("BLAKE2", Box::new(Blake2b::new()) as Box<dyn Digest>, 512)),
         Some(length_in_bits) => {
             if *length_in_bits > 512 {
-                crash!(1, "Invalid length (maximum digest length is 512 bits)")
+                return Err(USimpleError::new(
+                    1,
+                    "Invalid length (maximum digest length is 512 bits)",
+                ));
             }
 
             if length_in_bits % 8 == 0 {
                 let length_in_bytes = length_in_bits / 8;
-                (
+                Ok((
                     "BLAKE2",
                     Box::new(Blake2b::with_output_bytes(length_in_bytes)),
                     *length_in_bits,
-                )
+                ))
             } else {
-                crash!(1, "Invalid length (expected a multiple of 8)")
+                Err(USimpleError::new(
+                    1,
+                    "Invalid length (expected a multiple of 8)",
+                ))
             }
         }
     }
@@ -82,38 +87,36 @@ fn create_blake2b(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize
 ///
 /// # Returns
 ///
-/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
-///
-/// # Panics
-///
-/// Panics if an unsupported output size is provided, or if the `--bits` flag is missing.
-fn create_sha3(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits or an Err if an unsupported output size is provided, or if
+/// the `--bits` flag is missing.
+fn create_sha3(matches: &ArgMatches) -> UResult<(&'static str, Box<dyn Digest>, usize)> {
     match matches.get_one::<usize>("bits") {
-        Some(224) => (
+        Some(224) => Ok((
             "SHA3-224",
             Box::new(Sha3_224::new()) as Box<dyn Digest>,
             224,
-        ),
-        Some(256) => (
+        )),
+        Some(256) => Ok((
             "SHA3-256",
             Box::new(Sha3_256::new()) as Box<dyn Digest>,
             256,
-        ),
-        Some(384) => (
+        )),
+        Some(384) => Ok((
             "SHA3-384",
             Box::new(Sha3_384::new()) as Box<dyn Digest>,
             384,
-        ),
-        Some(512) => (
+        )),
+        Some(512) => Ok((
             "SHA3-512",
             Box::new(Sha3_512::new()) as Box<dyn Digest>,
             512,
-        ),
-        Some(_) => crash!(
+        )),
+        Some(_) => Err(USimpleError::new(
             1,
-            "Invalid output size for SHA3 (expected 224, 256, 384, or 512)"
-        ),
-        None => crash!(1, "--bits required for SHA3"),
+            "Invalid output size for SHA3 (expected 224, 256, 384, or 512)",
+        )),
+        None => Err(USimpleError::new(1, "--bits required for SHA3")),
     }
 }
 
@@ -121,19 +124,16 @@ fn create_sha3(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
 ///
 /// # Returns
 ///
-/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
-///
-/// # Panics
-///
-/// Panics if the `--bits` flag is missing.
-fn create_shake128(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits, or an Err if `--bits` flag is missing.
+fn create_shake128(matches: &ArgMatches) -> UResult<(&'static str, Box<dyn Digest>, usize)> {
     match matches.get_one::<usize>("bits") {
-        Some(bits) => (
+        Some(bits) => Ok((
             "SHAKE128",
             Box::new(Shake128::new()) as Box<dyn Digest>,
             *bits,
-        ),
-        None => crash!(1, "--bits required for SHAKE-128"),
+        )),
+        None => Err(USimpleError::new(1, "--bits required for SHAKE-128")),
     }
 }
 
@@ -141,19 +141,16 @@ fn create_shake128(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usiz
 ///
 /// # Returns
 ///
-/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
-///
-/// # Panics
-///
-/// Panics if the `--bits` flag is missing.
-fn create_shake256(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits, or an Err if the `--bits` flag is missing.
+fn create_shake256(matches: &ArgMatches) -> UResult<(&'static str, Box<dyn Digest>, usize)> {
     match matches.get_one::<usize>("bits") {
-        Some(bits) => (
+        Some(bits) => Ok((
             "SHAKE256",
             Box::new(Shake256::new()) as Box<dyn Digest>,
             *bits,
-        ),
-        None => crash!(1, "--bits required for SHAKE-256"),
+        )),
+        None => Err(USimpleError::new(1, "--bits required for SHAKE-256")),
     }
 }
 
@@ -166,46 +163,46 @@ fn create_shake256(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usiz
 ///
 /// # Returns
 ///
-/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits, or an Err if a matching algorithm is not found.
 fn detect_algo(
     program: &str,
     matches: &ArgMatches,
-) -> (&'static str, Box<dyn Digest + 'static>, usize) {
-    let (name, alg, output_bits) = match program {
-        "md5sum" => ("MD5", Box::new(Md5::new()) as Box<dyn Digest>, 128),
-        "sha1sum" => ("SHA1", Box::new(Sha1::new()) as Box<dyn Digest>, 160),
-        "sha224sum" => ("SHA224", Box::new(Sha224::new()) as Box<dyn Digest>, 224),
-        "sha256sum" => ("SHA256", Box::new(Sha256::new()) as Box<dyn Digest>, 256),
-        "sha384sum" => ("SHA384", Box::new(Sha384::new()) as Box<dyn Digest>, 384),
-        "sha512sum" => ("SHA512", Box::new(Sha512::new()) as Box<dyn Digest>, 512),
+) -> UResult<(&'static str, Box<dyn Digest + 'static>, usize)> {
+    match program {
+        "md5sum" => Ok(("MD5", Box::new(Md5::new()) as Box<dyn Digest>, 128)),
+        "sha1sum" => Ok(("SHA1", Box::new(Sha1::new()) as Box<dyn Digest>, 160)),
+        "sha224sum" => Ok(("SHA224", Box::new(Sha224::new()) as Box<dyn Digest>, 224)),
+        "sha256sum" => Ok(("SHA256", Box::new(Sha256::new()) as Box<dyn Digest>, 256)),
+        "sha384sum" => Ok(("SHA384", Box::new(Sha384::new()) as Box<dyn Digest>, 384)),
+        "sha512sum" => Ok(("SHA512", Box::new(Sha512::new()) as Box<dyn Digest>, 512)),
         "b2sum" => create_blake2b(matches),
-        "b3sum" => ("BLAKE3", Box::new(Blake3::new()) as Box<dyn Digest>, 256),
+        "b3sum" => Ok(("BLAKE3", Box::new(Blake3::new()) as Box<dyn Digest>, 256)),
         "sha3sum" => create_sha3(matches),
-        "sha3-224sum" => (
+        "sha3-224sum" => Ok((
             "SHA3-224",
             Box::new(Sha3_224::new()) as Box<dyn Digest>,
             224,
-        ),
-        "sha3-256sum" => (
+        )),
+        "sha3-256sum" => Ok((
             "SHA3-256",
             Box::new(Sha3_256::new()) as Box<dyn Digest>,
             256,
-        ),
-        "sha3-384sum" => (
+        )),
+        "sha3-384sum" => Ok((
             "SHA3-384",
             Box::new(Sha3_384::new()) as Box<dyn Digest>,
             384,
-        ),
-        "sha3-512sum" => (
+        )),
+        "sha3-512sum" => Ok((
             "SHA3-512",
             Box::new(Sha3_512::new()) as Box<dyn Digest>,
             512,
-        ),
+        )),
         "shake128sum" => create_shake128(matches),
         "shake256sum" => create_shake256(matches),
         _ => create_algorithm_from_flags(matches),
-    };
-    (name, alg, output_bits)
+    }
 }
 
 /// Creates a hasher instance based on the command-line flags.
@@ -216,80 +213,89 @@ fn detect_algo(
 ///
 /// # Returns
 ///
-/// Returns a tuple containing the algorithm name, the hasher instance, and the output length in bits.
-///
-/// # Panics
-///
-/// Panics if multiple hash algorithms are specified or if a required flag is missing.
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits or an Err if multiple hash algorithms are specified or if a
+/// required flag is missing.
 #[allow(clippy::cognitive_complexity)]
-fn create_algorithm_from_flags(matches: &ArgMatches) -> (&'static str, Box<dyn Digest>, usize) {
+fn create_algorithm_from_flags(
+    matches: &ArgMatches,
+) -> UResult<(&'static str, Box<dyn Digest>, usize)> {
     let mut alg: Option<Box<dyn Digest>> = None;
     let mut name: &'static str = "";
     let mut output_bits = 0;
-    let mut set_or_crash = |n, val, bits| {
+    let mut set_or_err = |n, val, bits| {
         if alg.is_some() {
-            crash!(1, "You cannot combine multiple hash algorithms!");
+            return Err(USimpleError::new(
+                1,
+                "You cannot combine multiple hash algorithms!",
+            ));
         };
         name = n;
         alg = Some(val);
         output_bits = bits;
+
+        Ok(())
     };
 
     if matches.get_flag("md5") {
-        set_or_crash("MD5", Box::new(Md5::new()), 128);
+        set_or_err("MD5", Box::new(Md5::new()), 128)?;
     }
     if matches.get_flag("sha1") {
-        set_or_crash("SHA1", Box::new(Sha1::new()), 160);
+        set_or_err("SHA1", Box::new(Sha1::new()), 160)?;
     }
     if matches.get_flag("sha224") {
-        set_or_crash("SHA224", Box::new(Sha224::new()), 224);
+        set_or_err("SHA224", Box::new(Sha224::new()), 224)?;
     }
     if matches.get_flag("sha256") {
-        set_or_crash("SHA256", Box::new(Sha256::new()), 256);
+        set_or_err("SHA256", Box::new(Sha256::new()), 256)?;
     }
     if matches.get_flag("sha384") {
-        set_or_crash("SHA384", Box::new(Sha384::new()), 384);
+        set_or_err("SHA384", Box::new(Sha384::new()), 384)?;
     }
     if matches.get_flag("sha512") {
-        set_or_crash("SHA512", Box::new(Sha512::new()), 512);
+        set_or_err("SHA512", Box::new(Sha512::new()), 512)?;
     }
     if matches.get_flag("b2sum") {
-        set_or_crash("BLAKE2", Box::new(Blake2b::new()), 512);
+        set_or_err("BLAKE2", Box::new(Blake2b::new()), 512)?;
     }
     if matches.get_flag("b3sum") {
-        set_or_crash("BLAKE3", Box::new(Blake3::new()), 256);
+        set_or_err("BLAKE3", Box::new(Blake3::new()), 256)?;
     }
     if matches.get_flag("sha3") {
-        let (n, val, bits) = create_sha3(matches);
-        set_or_crash(n, val, bits);
+        let (n, val, bits) = create_sha3(matches)?;
+        set_or_err(n, val, bits)?;
     }
     if matches.get_flag("sha3-224") {
-        set_or_crash("SHA3-224", Box::new(Sha3_224::new()), 224);
+        set_or_err("SHA3-224", Box::new(Sha3_224::new()), 224)?;
     }
     if matches.get_flag("sha3-256") {
-        set_or_crash("SHA3-256", Box::new(Sha3_256::new()), 256);
+        set_or_err("SHA3-256", Box::new(Sha3_256::new()), 256)?;
     }
     if matches.get_flag("sha3-384") {
-        set_or_crash("SHA3-384", Box::new(Sha3_384::new()), 384);
+        set_or_err("SHA3-384", Box::new(Sha3_384::new()), 384)?;
     }
     if matches.get_flag("sha3-512") {
-        set_or_crash("SHA3-512", Box::new(Sha3_512::new()), 512);
+        set_or_err("SHA3-512", Box::new(Sha3_512::new()), 512)?;
     }
     if matches.get_flag("shake128") {
         match matches.get_one::<usize>("bits") {
-            Some(bits) => set_or_crash("SHAKE128", Box::new(Shake128::new()), *bits),
-            None => crash!(1, "--bits required for SHAKE-128"),
-        }
+            Some(bits) => set_or_err("SHAKE128", Box::new(Shake128::new()), *bits)?,
+            None => return Err(USimpleError::new(1, "--bits required for SHAKE-128")),
+        };
     }
     if matches.get_flag("shake256") {
         match matches.get_one::<usize>("bits") {
-            Some(bits) => set_or_crash("SHAKE256", Box::new(Shake256::new()), *bits),
-            None => crash!(1, "--bits required for SHAKE-256"),
-        }
+            Some(bits) => set_or_err("SHAKE256", Box::new(Shake256::new()), *bits)?,
+            None => return Err(USimpleError::new(1, "--bits required for SHAKE-256")),
+        };
     }
 
-    let alg = alg.unwrap_or_else(|| crash!(1, "You must specify hash algorithm!"));
-    (name, alg, output_bits)
+    let alg = match alg {
+        Some(a) => a,
+        None => return Err(USimpleError::new(1, "You must specify hash algorithm!")),
+    };
+
+    Ok((name, alg, output_bits))
 }
 
 // TODO: return custom error type
@@ -319,7 +325,7 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
     //        least somewhat better from a user's perspective.
     let matches = command.try_get_matches_from(args)?;
 
-    let (name, algo, bits) = detect_algo(&binary_name, &matches);
+    let (name, algo, bits) = detect_algo(&binary_name, &matches)?;
 
     let binary = if matches.get_flag("binary") {
         true
@@ -750,7 +756,9 @@ where
             } else if options.zero {
                 print!("{} {}{}\0", sum, binary_marker, filename.display());
             } else {
-                println!("{} {}{}", sum, binary_marker, filename.display());
+                let (filename, has_prefix) = escape_filename(filename);
+                let prefix = if has_prefix { "\\" } else { "" };
+                println!("{}{} {}{}", prefix, sum, binary_marker, filename);
             }
         }
     }
@@ -775,6 +783,16 @@ where
     Ok(())
 }
 
+fn escape_filename(filename: &Path) -> (String, bool) {
+    let original = filename.as_os_str().to_string_lossy();
+    let escaped = original
+        .replace('\\', "\\\\")
+        .replace('\n', "\\n")
+        .replace('\r', "\\r");
+    let has_changed = escaped != original;
+    (escaped, has_changed)
+}
+
 fn digest_reader<T: Read>(
     digest: &mut Box<dyn Digest>,
     reader: &mut BufReader<T>,
diff --git a/src/uu/head/Cargo.toml b/src/uu/head/Cargo.toml
index 12872c80820..45e51b881b2 100644
--- a/src/uu/head/Cargo.toml
+++ b/src/uu/head/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_head"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "head ~ (uutils) display the first lines of input"
diff --git a/src/uu/head/src/head.rs b/src/uu/head/src/head.rs
index 5d0d3beddc9..3f6fd218507 100644
--- a/src/uu/head/src/head.rs
+++ b/src/uu/head/src/head.rs
@@ -7,9 +7,12 @@
 
 use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use std::ffi::OsString;
+use std::fs::Metadata;
 use std::io::{self, BufWriter, ErrorKind, Read, Seek, SeekFrom, Write};
+#[cfg(not(target_os = "windows"))]
+use std::os::unix::fs::MetadataExt;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::error::{FromIo, UResult, USimpleError};
 use uucore::line_ending::LineEnding;
 use uucore::lines::lines;
 use uucore::{format_usage, help_about, help_usage, show};
@@ -243,63 +246,74 @@ fn read_n_lines(input: &mut impl std::io::BufRead, n: u64, separator: u8) -> std
     Ok(())
 }
 
-fn read_but_last_n_bytes(input: &mut impl std::io::BufRead, n: usize) -> std::io::Result<()> {
+fn catch_too_large_numbers_in_backwards_bytes_or_lines(n: u64) -> Option<usize> {
+    match usize::try_from(n) {
+        Ok(value) => Some(value),
+        Err(e) => {
+            show!(USimpleError::new(
+                1,
+                format!("{e}: number of -bytes or -lines is too large")
+            ));
+            None
+        }
+    }
+}
+
+fn read_but_last_n_bytes(input: &mut impl std::io::BufRead, n: u64) -> std::io::Result<()> {
     if n == 0 {
         //prints everything
         return read_n_bytes(input, std::u64::MAX);
     }
 
-    let stdout = std::io::stdout();
-    let mut stdout = stdout.lock();
+    if let Some(n) = catch_too_large_numbers_in_backwards_bytes_or_lines(n) {
+        let stdout = std::io::stdout();
+        let mut stdout = stdout.lock();
 
-    let mut ring_buffer = vec![0u8; n];
+        let mut ring_buffer = Vec::new();
 
-    // first we fill the ring buffer
-    if let Err(e) = input.read_exact(&mut ring_buffer) {
-        if e.kind() == ErrorKind::UnexpectedEof {
-            return Ok(());
-        } else {
-            return Err(e);
-        }
-    }
-    let mut buffer = [0u8; BUF_SIZE];
-    loop {
-        let read = loop {
-            match input.read(&mut buffer) {
-                Ok(n) => break n,
+        let mut buffer = [0u8; BUF_SIZE];
+        let mut total_read = 0;
+
+        loop {
+            let read = match input.read(&mut buffer) {
+                Ok(0) => break,
+                Ok(read) => read,
                 Err(e) => match e.kind() {
-                    ErrorKind::Interrupted => {}
+                    ErrorKind::Interrupted => continue,
                     _ => return Err(e),
                 },
+            };
+
+            total_read += read;
+
+            if total_read <= n {
+                // Fill the ring buffer without exceeding n bytes
+                let overflow = total_read - n;
+                ring_buffer.extend_from_slice(&buffer[..read - overflow]);
+            } else {
+                // Write the ring buffer and the part of the buffer that exceeds n
+                stdout.write_all(&ring_buffer)?;
+                stdout.write_all(&buffer[..read - n + ring_buffer.len()])?;
+                ring_buffer.clear();
+                ring_buffer.extend_from_slice(&buffer[read - n + ring_buffer.len()..read]);
             }
-        };
-        if read == 0 {
-            return Ok(());
-        } else if read >= n {
-            stdout.write_all(&ring_buffer)?;
-            stdout.write_all(&buffer[..read - n])?;
-            for i in 0..n {
-                ring_buffer[i] = buffer[read - n + i];
-            }
-        } else {
-            stdout.write_all(&ring_buffer[..read])?;
-            for i in 0..n - read {
-                ring_buffer[i] = ring_buffer[read + i];
-            }
-            ring_buffer[n - read..].copy_from_slice(&buffer[..read]);
         }
     }
+
+    Ok(())
 }
 
 fn read_but_last_n_lines(
     input: impl std::io::BufRead,
-    n: usize,
+    n: u64,
     separator: u8,
 ) -> std::io::Result<()> {
-    let stdout = std::io::stdout();
-    let mut stdout = stdout.lock();
-    for bytes in take_all_but(lines(input, separator), n) {
-        stdout.write_all(&bytes?)?;
+    if let Some(n) = catch_too_large_numbers_in_backwards_bytes_or_lines(n) {
+        let stdout = std::io::stdout();
+        let mut stdout = stdout.lock();
+        for bytes in take_all_but(lines(input, separator), n) {
+            stdout.write_all(&bytes?)?;
+        }
     }
     Ok(())
 }
@@ -380,7 +394,63 @@ where
     }
 }
 
+fn is_seekable(input: &mut std::fs::File) -> bool {
+    let current_pos = input.stream_position();
+    current_pos.is_ok()
+        && input.seek(SeekFrom::End(0)).is_ok()
+        && input.seek(SeekFrom::Start(current_pos.unwrap())).is_ok()
+}
+
+fn sanity_limited_blksize(_st: &Metadata) -> u64 {
+    #[cfg(not(target_os = "windows"))]
+    {
+        const DEFAULT: u64 = 512;
+        const MAX: u64 = usize::MAX as u64 / 8 + 1;
+
+        let st_blksize: u64 = _st.blksize();
+        match st_blksize {
+            0 => DEFAULT,
+            1..=MAX => st_blksize,
+            _ => DEFAULT,
+        }
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        512
+    }
+}
+
 fn head_backwards_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Result<()> {
+    let st = input.metadata()?;
+    let seekable = is_seekable(input);
+    let blksize_limit = sanity_limited_blksize(&st);
+    if !seekable || st.len() <= blksize_limit {
+        return head_backwards_without_seek_file(input, options);
+    }
+
+    head_backwards_on_seekable_file(input, options)
+}
+
+fn head_backwards_without_seek_file(
+    input: &mut std::fs::File,
+    options: &HeadOptions,
+) -> std::io::Result<()> {
+    let reader = &mut std::io::BufReader::with_capacity(BUF_SIZE, &*input);
+
+    match options.mode {
+        Mode::AllButLastBytes(n) => read_but_last_n_bytes(reader, n)?,
+        Mode::AllButLastLines(n) => read_but_last_n_lines(reader, n, options.line_ending.into())?,
+        _ => unreachable!(),
+    }
+
+    Ok(())
+}
+
+fn head_backwards_on_seekable_file(
+    input: &mut std::fs::File,
+    options: &HeadOptions,
+) -> std::io::Result<()> {
     match options.mode {
         Mode::AllButLastBytes(n) => {
             let size = input.metadata()?.len();
@@ -434,32 +504,13 @@ fn uu_head(options: &HeadOptions) -> UResult<()> {
                 let stdin = std::io::stdin();
                 let mut stdin = stdin.lock();
 
-                // Outputting "all-but-last" requires us to use a ring buffer with size n, so n
-                // must be converted from u64 to usize to fit in memory. If such conversion fails,
-                // it means the platform doesn't have enough memory to hold the buffer, so we fail.
-                if let Mode::AllButLastLines(n) | Mode::AllButLastBytes(n) = options.mode {
-                    if let Err(e) = usize::try_from(n) {
-                        show!(USimpleError::new(
-                            1,
-                            format!("{e}: number of bytes is too large")
-                        ));
-                        continue;
-                    };
-                };
-
                 match options.mode {
                     Mode::FirstBytes(n) => read_n_bytes(&mut stdin, n),
-                    // unwrap is guaranteed to succeed because we checked the value of n above
-                    Mode::AllButLastBytes(n) => {
-                        read_but_last_n_bytes(&mut stdin, n.try_into().unwrap())
-                    }
+                    Mode::AllButLastBytes(n) => read_but_last_n_bytes(&mut stdin, n),
                     Mode::FirstLines(n) => read_n_lines(&mut stdin, n, options.line_ending.into()),
-                    // unwrap is guaranteed to succeed because we checked the value of n above
-                    Mode::AllButLastLines(n) => read_but_last_n_lines(
-                        &mut stdin,
-                        n.try_into().unwrap(),
-                        options.line_ending.into(),
-                    ),
+                    Mode::AllButLastLines(n) => {
+                        read_but_last_n_lines(&mut stdin, n, options.line_ending.into())
+                    }
                 }
             }
             (name, false) => {
diff --git a/src/uu/hostid/Cargo.toml b/src/uu/hostid/Cargo.toml
index 602e7ef3751..8e551befb4a 100644
--- a/src/uu/hostid/Cargo.toml
+++ b/src/uu/hostid/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_hostid"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "hostid ~ (uutils) display the numeric identifier of the current host"
diff --git a/src/uu/hostname/Cargo.toml b/src/uu/hostname/Cargo.toml
index a9b033d123b..7dd6eabe5ad 100644
--- a/src/uu/hostname/Cargo.toml
+++ b/src/uu/hostname/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_hostname"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "hostname ~ (uutils) display or set the host name of the current host"
@@ -16,7 +16,7 @@ path = "src/hostname.rs"
 
 [dependencies]
 clap = { workspace = true }
-hostname = { version = "0.3", features = ["set"] }
+hostname = { workspace = true, features = ["set"] }
 uucore = { workspace = true, features = ["wide"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
diff --git a/src/uu/id/Cargo.toml b/src/uu/id/Cargo.toml
index b62df1eebd2..6d332acfc3c 100644
--- a/src/uu/id/Cargo.toml
+++ b/src/uu/id/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_id"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "id ~ (uutils) display user and group information for USER"
diff --git a/src/uu/id/src/id.rs b/src/uu/id/src/id.rs
index 8b16ba8b733..b8fb51d79db 100644
--- a/src/uu/id/src/id.rs
+++ b/src/uu/id/src/id.rs
@@ -507,7 +507,7 @@ fn pline(possible_uid: Option<uid_t>) {
     );
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "openbsd"))]
 fn pline(possible_uid: Option<uid_t>) {
     let uid = possible_uid.unwrap_or_else(getuid);
     let pw = Passwd::locate(uid).unwrap();
@@ -524,10 +524,10 @@ fn pline(possible_uid: Option<uid_t>) {
     );
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "openbsd"))]
 fn auditid() {}
 
-#[cfg(not(any(target_os = "linux", target_os = "android")))]
+#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "openbsd")))]
 fn auditid() {
     use std::mem::MaybeUninit;
 
@@ -624,7 +624,7 @@ fn id_print(state: &State, groups: &[u32]) {
     }
 }
 
-#[cfg(not(any(target_os = "linux", target_os = "android")))]
+#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "openbsd")))]
 mod audit {
     use super::libc::{c_int, c_uint, dev_t, pid_t, uid_t};
 
diff --git a/src/uu/install/Cargo.toml b/src/uu/install/Cargo.toml
index 0110380068b..647e0958ee0 100644
--- a/src/uu/install/Cargo.toml
+++ b/src/uu/install/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_install"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["Ben Eills <ben@beneills.com>", "uutils developers"]
 license = "MIT"
 description = "install ~ (uutils) copy files from SOURCE to DESTINATION (with specified attributes)"
@@ -25,6 +25,7 @@ uucore = { workspace = true, features = [
   "mode",
   "perms",
   "entries",
+  "process",
 ] }
 
 [[bin]]
diff --git a/src/uu/install/src/install.rs b/src/uu/install/src/install.rs
index 43925a7f8e4..9955be7b292 100644
--- a/src/uu/install/src/install.rs
+++ b/src/uu/install/src/install.rs
@@ -10,16 +10,6 @@ mod mode;
 use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use file_diff::diff;
 use filetime::{set_file_times, FileTime};
-use uucore::backup_control::{self, BackupMode};
-use uucore::display::Quotable;
-use uucore::entries::{grp2gid, usr2uid};
-use uucore::error::{FromIo, UError, UIoError, UResult, UUsageError};
-use uucore::fs::dir_strip_dot_for_creation;
-use uucore::mode::get_umask;
-use uucore::perms::{wrap_chown, Verbosity, VerbosityLevel};
-use uucore::{format_usage, help_about, help_usage, show, show_error, show_if_err, uio_error};
-
-use libc::{getegid, geteuid};
 use std::error::Error;
 use std::fmt::{Debug, Display};
 use std::fs;
@@ -29,6 +19,15 @@ use std::os::unix::fs::MetadataExt;
 use std::os::unix::prelude::OsStrExt;
 use std::path::{Path, PathBuf, MAIN_SEPARATOR};
 use std::process;
+use uucore::backup_control::{self, BackupMode};
+use uucore::display::Quotable;
+use uucore::entries::{grp2gid, usr2uid};
+use uucore::error::{FromIo, UError, UIoError, UResult, UUsageError};
+use uucore::fs::dir_strip_dot_for_creation;
+use uucore::mode::get_umask;
+use uucore::perms::{wrap_chown, Verbosity, VerbosityLevel};
+use uucore::process::{getegid, geteuid};
+use uucore::{format_usage, help_about, help_usage, show, show_error, show_if_err, uio_error};
 
 const DEFAULT_MODE: u32 = 0o755;
 const DEFAULT_STRIP_PROGRAM: &str = "strip";
@@ -66,6 +65,7 @@ enum InstallError {
     InvalidUser(String),
     InvalidGroup(String),
     OmittingDirectory(PathBuf),
+    NotADirectory(PathBuf),
 }
 
 impl UError for InstallError {
@@ -120,6 +120,9 @@ impl Display for InstallError {
             Self::InvalidUser(user) => write!(f, "invalid user: {}", user.quote()),
             Self::InvalidGroup(group) => write!(f, "invalid group: {}", group.quote()),
             Self::OmittingDirectory(dir) => write!(f, "omitting directory {}", dir.quote()),
+            Self::NotADirectory(dir) => {
+                write!(f, "failed to access {}: Not a directory", dir.quote())
+            }
         }
     }
 }
@@ -565,6 +568,13 @@ fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
         };
 
         if let Some(to_create) = to_create {
+            // if the path ends in /, remove it
+            let to_create = if to_create.to_string_lossy().ends_with('/') {
+                Path::new(to_create.to_str().unwrap().trim_end_matches('/'))
+            } else {
+                to_create
+            };
+
             if !to_create.exists() {
                 if b.verbose {
                     let mut result = PathBuf::new();
@@ -583,6 +593,13 @@ fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
                 }
             }
         }
+        if b.target_dir.is_some() {
+            let p = to_create.unwrap();
+
+            if !p.exists() || !p.is_dir() {
+                return Err(InstallError::NotADirectory(p.to_path_buf()).into());
+            }
+        }
     }
 
     if sources.len() > 1 || is_potential_directory_path(&target) {
@@ -646,6 +663,7 @@ fn copy_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
 /// Handle incomplete user/group parings for chown.
 ///
 /// Returns a Result type with the Err variant containing the error message.
+/// If the user is root, revert the uid & gid
 ///
 /// # Parameters
 ///
@@ -657,23 +675,31 @@ fn copy_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
 /// return an empty error value.
 ///
 fn chown_optional_user_group(path: &Path, b: &Behavior) -> UResult<()> {
-    if b.owner_id.is_some() || b.group_id.is_some() {
-        let meta = match fs::metadata(path) {
-            Ok(meta) => meta,
-            Err(e) => return Err(InstallError::MetadataFailed(e).into()),
-        };
+    // GNU coreutils doesn't print chown operations during install with verbose flag.
+    let verbosity = Verbosity {
+        groups_only: b.owner_id.is_none(),
+        level: VerbosityLevel::Normal,
+    };
 
-        // GNU coreutils doesn't print chown operations during install with verbose flag.
-        let verbosity = Verbosity {
-            groups_only: b.owner_id.is_none(),
-            level: VerbosityLevel::Normal,
-        };
+    // Determine the owner and group IDs to be used for chown.
+    let (owner_id, group_id) = if b.owner_id.is_some() || b.group_id.is_some() {
+        (b.owner_id, b.group_id)
+    } else if geteuid() == 0 {
+        // Special case for root user.
+        (Some(0), Some(0))
+    } else {
+        // No chown operation needed.
+        return Ok(());
+    };
 
-        match wrap_chown(path, &meta, b.owner_id, b.group_id, false, verbosity) {
-            Ok(msg) if b.verbose && !msg.is_empty() => println!("chown: {msg}"),
-            Ok(_) => {}
-            Err(e) => return Err(InstallError::ChownFailed(path.to_path_buf(), e).into()),
-        }
+    let meta = match fs::metadata(path) {
+        Ok(meta) => meta,
+        Err(e) => return Err(InstallError::MetadataFailed(e).into()),
+    };
+    match wrap_chown(path, &meta, owner_id, group_id, false, verbosity) {
+        Ok(msg) if b.verbose && !msg.is_empty() => println!("chown: {msg}"),
+        Ok(_) => {}
+        Err(e) => return Err(InstallError::ChownFailed(path.to_path_buf(), e).into()),
     }
 
     Ok(())
@@ -749,14 +775,24 @@ fn copy_file(from: &Path, to: &Path) -> UResult<()> {
 /// Returns an empty Result or an error in case of failure.
 ///
 fn strip_file(to: &Path, b: &Behavior) -> UResult<()> {
-    match process::Command::new(&b.strip_program).arg(to).output() {
-        Ok(o) => {
-            if !o.status.success() {
+    // Check if the filename starts with a hyphen and adjust the path
+    let to_str = to.as_os_str().to_str().unwrap_or_default();
+    let to = if to_str.starts_with('-') {
+        let mut new_path = PathBuf::from(".");
+        new_path.push(to);
+        new_path
+    } else {
+        to.to_path_buf()
+    };
+    match process::Command::new(&b.strip_program).arg(&to).status() {
+        Ok(status) => {
+            if !status.success() {
                 // Follow GNU's behavior: if strip fails, removes the target
                 let _ = fs::remove_file(to);
-                return Err(InstallError::StripProgramFailed(
-                    String::from_utf8(o.stderr).unwrap_or_default(),
-                )
+                return Err(InstallError::StripProgramFailed(format!(
+                    "strip process terminated abnormally - exit code: {}",
+                    status.code().unwrap()
+                ))
                 .into());
             }
         }
@@ -883,57 +919,74 @@ fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
 /// Crashes the program if a nonexistent owner or group is specified in _b_.
 ///
 fn need_copy(from: &Path, to: &Path, b: &Behavior) -> UResult<bool> {
+    // Attempt to retrieve metadata for the source file.
+    // If this fails, assume the file needs to be copied.
     let from_meta = match fs::metadata(from) {
         Ok(meta) => meta,
         Err(_) => return Ok(true),
     };
+
+    // Attempt to retrieve metadata for the destination file.
+    // If this fails, assume the file needs to be copied.
     let to_meta = match fs::metadata(to) {
         Ok(meta) => meta,
         Err(_) => return Ok(true),
     };
 
-    // setuid || setgid || sticky
+    // Define special file mode bits (setuid, setgid, sticky).
     let extra_mode: u32 = 0o7000;
+    // Define all file mode bits (including permissions).
     // setuid || setgid || sticky || permissions
     let all_modes: u32 = 0o7777;
 
+    // Check if any special mode bits are set in the specified mode,
+    // source file mode, or destination file mode.
     if b.specified_mode.unwrap_or(0) & extra_mode != 0
         || from_meta.mode() & extra_mode != 0
         || to_meta.mode() & extra_mode != 0
     {
         return Ok(true);
     }
+
+    // Check if the mode of the destination file differs from the specified mode.
     if b.mode() != to_meta.mode() & all_modes {
         return Ok(true);
     }
 
+    // Check if either the source or destination is not a file.
     if !from_meta.is_file() || !to_meta.is_file() {
         return Ok(true);
     }
 
+    // Check if the file sizes differ.
     if from_meta.len() != to_meta.len() {
         return Ok(true);
     }
 
     // TODO: if -P (#1809) and from/to contexts mismatch, return true.
 
+    // Check if the owner ID is specified and differs from the destination file's owner.
     if let Some(owner_id) = b.owner_id {
         if owner_id != to_meta.uid() {
             return Ok(true);
         }
-    } else if let Some(group_id) = b.group_id {
+    }
+
+    // Check if the group ID is specified and differs from the destination file's group.
+    if let Some(group_id) = b.group_id {
         if group_id != to_meta.gid() {
             return Ok(true);
         }
     } else {
         #[cfg(not(target_os = "windows"))]
-        unsafe {
-            if to_meta.uid() != geteuid() || to_meta.gid() != getegid() {
-                return Ok(true);
-            }
+        // Check if the destination file's owner or group
+        // differs from the effective user/group ID of the process.
+        if to_meta.uid() != geteuid() || to_meta.gid() != getegid() {
+            return Ok(true);
         }
     }
 
+    // Check if the contents of the source and destination files differ.
     if !diff(from.to_str().unwrap(), to.to_str().unwrap()) {
         return Ok(true);
     }
diff --git a/src/uu/join/Cargo.toml b/src/uu/join/Cargo.toml
index 20853527d83..759b04af712 100644
--- a/src/uu/join/Cargo.toml
+++ b/src/uu/join/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_join"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "join ~ (uutils) merge lines from inputs with matching join fields"
diff --git a/src/uu/join/join.md b/src/uu/join/join.md
index ec91950b8bc..04275342a6e 100644
--- a/src/uu/join/join.md
+++ b/src/uu/join/join.md
@@ -1,7 +1,7 @@
 # join
 
 ```
-join [OPTIONS] <FILE1> <FILE2>
+join [OPTION]... FILE1 FILE2
 ```
 
 For each pair of input lines with identical join fields, write a line to
diff --git a/src/uu/join/src/join.rs b/src/uu/join/src/join.rs
index a48ba3657bd..423af983ec9 100644
--- a/src/uu/join/src/join.rs
+++ b/src/uu/join/src/join.rs
@@ -19,9 +19,9 @@ use std::num::IntErrorKind;
 #[cfg(unix)]
 use std::os::unix::ffi::OsStrExt;
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, UError, UResult, USimpleError};
+use uucore::error::{set_exit_code, FromIo, UError, UResult, USimpleError};
 use uucore::line_ending::LineEnding;
-use uucore::{crash, crash_if_err, format_usage, help_about, help_usage};
+use uucore::{crash_if_err, format_usage, help_about, help_usage};
 
 const ABOUT: &str = help_about!("join.md");
 const USAGE: &str = help_usage!("join.md");
@@ -334,37 +334,30 @@ impl<'a> State<'a> {
         key: usize,
         line_ending: LineEnding,
         print_unpaired: bool,
-    ) -> State<'a> {
-        let f = if name == "-" {
+    ) -> UResult<State<'a>> {
+        let file_buf = if name == "-" {
             Box::new(stdin.lock()) as Box<dyn BufRead>
         } else {
-            match File::open(name) {
-                Ok(file) => Box::new(BufReader::new(file)) as Box<dyn BufRead>,
-                Err(err) => crash!(1, "{}: {}", name.maybe_quote(), err),
-            }
+            let file = File::open(name).map_err_context(|| format!("{}", name.maybe_quote()))?;
+            Box::new(BufReader::new(file)) as Box<dyn BufRead>
         };
 
-        State {
+        Ok(State {
             key,
             file_name: name,
             file_num,
             print_unpaired,
-            lines: f.split(line_ending as u8),
+            lines: file_buf.split(line_ending as u8),
             max_len: 1,
             seq: Vec::new(),
             line_num: 0,
             has_failed: false,
             has_unpaired: false,
-        }
+        })
     }
 
     /// Skip the current unpaired line.
-    fn skip_line(
-        &mut self,
-        writer: &mut impl Write,
-        input: &Input,
-        repr: &Repr,
-    ) -> Result<(), JoinError> {
+    fn skip_line(&mut self, writer: &mut impl Write, input: &Input, repr: &Repr) -> UResult<()> {
         if self.print_unpaired {
             self.print_first_line(writer, repr)?;
         }
@@ -375,7 +368,7 @@ impl<'a> State<'a> {
 
     /// Keep reading line sequence until the key does not change, return
     /// the first line whose key differs.
-    fn extend(&mut self, input: &Input) -> Result<Option<Line>, JoinError> {
+    fn extend(&mut self, input: &Input) -> UResult<Option<Line>> {
         while let Some(line) = self.next_line(input)? {
             let diff = input.compare(self.get_current_key(), line.get_field(self.key));
 
@@ -484,12 +477,7 @@ impl<'a> State<'a> {
         0
     }
 
-    fn finalize(
-        &mut self,
-        writer: &mut impl Write,
-        input: &Input,
-        repr: &Repr,
-    ) -> Result<(), JoinError> {
+    fn finalize(&mut self, writer: &mut impl Write, input: &Input, repr: &Repr) -> UResult<()> {
         if self.has_line() {
             if self.print_unpaired {
                 self.print_first_line(writer, repr)?;
@@ -713,10 +701,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         return Err(USimpleError::new(1, "both files cannot be standard input"));
     }
 
-    match exec(file1, file2, settings) {
-        Ok(_) => Ok(()),
-        Err(e) => Err(USimpleError::new(1, format!("{e}"))),
-    }
+    exec(file1, file2, settings)
 }
 
 pub fn uu_app() -> Command {
@@ -837,7 +822,7 @@ FILENUM is 1 or 2, corresponding to FILE1 or FILE2",
         )
 }
 
-fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
+fn exec(file1: &str, file2: &str, settings: Settings) -> UResult<()> {
     let stdin = stdin();
 
     let mut state1 = State::new(
@@ -847,7 +832,7 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
         settings.key1,
         settings.line_ending,
         settings.print_unpaired1,
-    );
+    )?;
 
     let mut state2 = State::new(
         FileNum::File2,
@@ -856,7 +841,7 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
         settings.key2,
         settings.line_ending,
         settings.print_unpaired2,
-    );
+    )?;
 
     let input = Input::new(
         settings.separator,
diff --git a/src/uu/kill/Cargo.toml b/src/uu/kill/Cargo.toml
index 6cb8cee6e3d..e60faa1c455 100644
--- a/src/uu/kill/Cargo.toml
+++ b/src/uu/kill/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_kill"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "kill ~ (uutils) send a signal to a process"
diff --git a/src/uu/kill/src/kill.rs b/src/uu/kill/src/kill.rs
index b0e18a79820..87de0ff54d3 100644
--- a/src/uu/kill/src/kill.rs
+++ b/src/uu/kill/src/kill.rs
@@ -10,7 +10,7 @@ use nix::sys::signal::{self, Signal};
 use nix::unistd::Pid;
 use std::io::Error;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::error::{FromIo, UResult, USimpleError};
 use uucore::signals::{signal_by_name_or_value, ALL_SIGNALS};
 use uucore::{format_usage, help_about, help_usage, show};
 
@@ -71,7 +71,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             table();
             Ok(())
         }
-        Mode::List => list(pids_or_signals.get(0)),
+        Mode::List => list(pids_or_signals.first()),
     }
 }
 
diff --git a/src/uu/link/Cargo.toml b/src/uu/link/Cargo.toml
index cba12c95c3b..d3643c5dcf6 100644
--- a/src/uu/link/Cargo.toml
+++ b/src/uu/link/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_link"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "link ~ (uutils) create a hard (file system) link to FILE"
diff --git a/src/uu/ln/Cargo.toml b/src/uu/ln/Cargo.toml
index 4243075ea0a..ba97c84e365 100644
--- a/src/uu/ln/Cargo.toml
+++ b/src/uu/ln/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_ln"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "ln ~ (uutils) create a (file system) link to TARGET"
diff --git a/src/uu/ln/src/ln.rs b/src/uu/ln/src/ln.rs
index 8b76aa73c0b..a056ee256a1 100644
--- a/src/uu/ln/src/ln.rs
+++ b/src/uu/ln/src/ln.rs
@@ -12,6 +12,7 @@ use uucore::fs::{make_path_relative_to, paths_refer_to_same_file};
 use uucore::{format_usage, help_about, help_section, help_usage, prompt_yes, show_error};
 
 use std::borrow::Cow;
+use std::collections::HashSet;
 use std::error::Error;
 use std::ffi::OsString;
 use std::fmt::Display;
@@ -295,6 +296,8 @@ fn link_files_in_dir(files: &[PathBuf], target_dir: &Path, settings: &Settings)
     if !target_dir.is_dir() {
         return Err(LnError::TargetIsDirectory(target_dir.to_owned()).into());
     }
+    // remember the linked destinations for further usage
+    let mut linked_destinations: HashSet<PathBuf> = HashSet::with_capacity(files.len());
 
     let mut all_successful = true;
     for srcpath in files {
@@ -338,10 +341,20 @@ fn link_files_in_dir(files: &[PathBuf], target_dir: &Path, settings: &Settings)
                 }
             };
 
-        if let Err(e) = link(srcpath, &targetpath, settings) {
+        if linked_destinations.contains(&targetpath) {
+            // If the target file was already created in this ln call, do not overwrite
+            show_error!(
+                "will not overwrite just-created '{}' with '{}'",
+                targetpath.display(),
+                srcpath.display()
+            );
+            all_successful = false;
+        } else if let Err(e) = link(srcpath, &targetpath, settings) {
             show_error!("{}", e);
             all_successful = false;
         }
+
+        linked_destinations.insert(targetpath.clone());
     }
     if all_successful {
         Ok(())
diff --git a/src/uu/logname/Cargo.toml b/src/uu/logname/Cargo.toml
index 2e8553f12c4..d9870b1d99c 100644
--- a/src/uu/logname/Cargo.toml
+++ b/src/uu/logname/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_logname"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "logname ~ (uutils) display the login name of the current user"
diff --git a/src/uu/logname/src/logname.rs b/src/uu/logname/src/logname.rs
index 55d4fec75ee..02a78cf4c3c 100644
--- a/src/uu/logname/src/logname.rs
+++ b/src/uu/logname/src/logname.rs
@@ -30,8 +30,6 @@ const USAGE: &str = help_usage!("logname.md");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let _ = uu_app().try_get_matches_from(args)?;
 
     match get_userlogin() {
diff --git a/src/uu/ls/Cargo.toml b/src/uu/ls/Cargo.toml
index 96cf7df1a0d..49c64ba0937 100644
--- a/src/uu/ls/Cargo.toml
+++ b/src/uu/ls/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_ls"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "ls ~ (uutils) display directory contents"
@@ -24,13 +24,16 @@ terminal_size = { workspace = true }
 glob = { workspace = true }
 lscolors = { workspace = true }
 uucore = { workspace = true, features = [
+  "colors",
   "entries",
   "fs",
+  "fsxattr",
   "quoting-style",
   "version-cmp",
 ] }
 once_cell = { workspace = true }
 selinux = { workspace = true, optional = true }
+hostname = { workspace = true }
 
 [[bin]]
 name = "ls"
diff --git a/src/uu/ls/src/ls.rs b/src/uu/ls/src/ls.rs
index 88af56bb186..ed100477f42 100644
--- a/src/uu/ls/src/ls.rs
+++ b/src/uu/ls/src/ls.rs
@@ -3,14 +3,15 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) cpio svgz webm somegroup nlink rmvb xspf tabsize dired subdired dtype
+// spell-checker:ignore (ToDO) somegroup nlink tabsize dired subdired dtype colorterm
 
 use clap::{
     builder::{NonEmptyStringValueParser, ValueParser},
     crate_version, Arg, ArgAction, Command,
 };
 use glob::{MatchOptions, Pattern};
-use lscolors::LsColors;
+use lscolors::{LsColors, Style};
+
 use number_prefix::NumberPrefix;
 use std::{cell::OnceCell, num::IntErrorKind};
 use std::{collections::HashSet, io::IsTerminal};
@@ -20,7 +21,7 @@ use std::os::windows::fs::MetadataExt;
 use std::{
     cmp::Reverse,
     error::Error,
-    ffi::{OsStr, OsString},
+    ffi::OsString,
     fmt::{Display, Write as FmtWrite},
     fs::{self, DirEntry, FileType, Metadata, ReadDir},
     io::{stdout, BufWriter, ErrorKind, Stdout, Write},
@@ -35,6 +36,8 @@ use std::{
 };
 use term_grid::{Cell, Direction, Filling, Grid, GridOptions};
 use unicode_width::UnicodeWidthStr;
+#[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
+use uucore::fsxattr::has_acl;
 #[cfg(any(
     target_os = "linux",
     target_os = "macos",
@@ -155,12 +158,13 @@ pub mod options {
     pub static GROUP_DIRECTORIES_FIRST: &str = "group-directories-first";
     pub static ZERO: &str = "zero";
     pub static DIRED: &str = "dired";
+    pub static HYPERLINK: &str = "hyperlink";
 }
 
 const DEFAULT_TERM_WIDTH: u16 = 80;
 const POSIXLY_CORRECT_BLOCK_SIZE: u64 = 512;
-#[cfg(unix)]
 const DEFAULT_BLOCK_SIZE: u64 = 1024;
+const DEFAULT_FILE_SIZE_BLOCK_SIZE: u64 = 1;
 
 #[derive(Debug)]
 enum LsError {
@@ -181,7 +185,7 @@ impl UError for LsError {
             Self::IOError(_) => 1,
             Self::IOErrorContext(_, _, false) => 1,
             Self::IOErrorContext(_, _, true) => 2,
-            Self::BlockSizeParseError(_) => 1,
+            Self::BlockSizeParseError(_) => 2,
             Self::ConflictingArgumentDired => 1,
             Self::DiredAndZeroAreIncompatible => 2,
             Self::AlreadyListedError(_) => 2,
@@ -407,7 +411,9 @@ pub struct Config {
     color: Option<LsColors>,
     long: LongFormat,
     alloc_size: bool,
-    block_size: Option<u64>,
+    file_size_block_size: u64,
+    #[allow(dead_code)]
+    block_size: u64, // is never read on Windows
     width: u16,
     // Dir and vdir needs access to this field
     pub quoting_style: QuotingStyle,
@@ -418,6 +424,7 @@ pub struct Config {
     group_directories_first: bool,
     line_ending: LineEnding,
     dired: bool,
+    hyperlink: bool,
 }
 
 // Fields that can be removed or added to the long format
@@ -550,12 +557,43 @@ fn extract_time(options: &clap::ArgMatches) -> Time {
     }
 }
 
+// Some env variables can be passed
+// For now, we are only verifying if empty or not and known for TERM
+fn is_color_compatible_term() -> bool {
+    let is_term_set = std::env::var("TERM").is_ok();
+    let is_colorterm_set = std::env::var("COLORTERM").is_ok();
+
+    let term = std::env::var("TERM").unwrap_or_default();
+    let colorterm = std::env::var("COLORTERM").unwrap_or_default();
+
+    // Search function in the TERM struct to manage the wildcards
+    let term_matches = |term: &str| -> bool {
+        uucore::colors::TERMS.iter().any(|&pattern| {
+            term == pattern
+                || (pattern.ends_with('*') && term.starts_with(&pattern[..pattern.len() - 1]))
+        })
+    };
+
+    if is_term_set && term.is_empty() && is_colorterm_set && colorterm.is_empty() {
+        return false;
+    }
+
+    if !term.is_empty() && !term_matches(&term) {
+        return false;
+    }
+    true
+}
+
 /// Extracts the color option to use based on the options provided.
 ///
 /// # Returns
 ///
 /// A boolean representing whether or not to use color.
 fn extract_color(options: &clap::ArgMatches) -> bool {
+    if !is_color_compatible_term() {
+        return false;
+    }
+
     match options.get_one::<String>(options::COLOR) {
         None => options.contains_id(options::COLOR),
         Some(val) => match val.as_str() {
@@ -566,7 +604,71 @@ fn extract_color(options: &clap::ArgMatches) -> bool {
     }
 }
 
+/// Extracts the hyperlink option to use based on the options provided.
+///
+/// # Returns
+///
+/// A boolean representing whether to hyperlink files.
+fn extract_hyperlink(options: &clap::ArgMatches) -> bool {
+    let hyperlink = options
+        .get_one::<String>(options::HYPERLINK)
+        .unwrap()
+        .as_str();
+
+    match hyperlink {
+        "always" | "yes" | "force" => true,
+        "auto" | "tty" | "if-tty" => std::io::stdout().is_terminal(),
+        "never" | "no" | "none" => false,
+        _ => unreachable!("should be handled by clap"),
+    }
+}
+
+/// Match the argument given to --quoting-style or the QUOTING_STYLE env variable.
+///
+/// # Arguments
+///
+/// * `style`: the actual argument string
+/// * `show_control` - A boolean value representing whether or not to show control characters.
+///
+/// # Returns
+///
+/// * An option with None if the style string is invalid, or a `QuotingStyle` wrapped in `Some`.
+fn match_quoting_style_name(style: &str, show_control: bool) -> Option<QuotingStyle> {
+    match style {
+        "literal" => Some(QuotingStyle::Literal { show_control }),
+        "shell" => Some(QuotingStyle::Shell {
+            escape: false,
+            always_quote: false,
+            show_control,
+        }),
+        "shell-always" => Some(QuotingStyle::Shell {
+            escape: false,
+            always_quote: true,
+            show_control,
+        }),
+        "shell-escape" => Some(QuotingStyle::Shell {
+            escape: true,
+            always_quote: false,
+            show_control,
+        }),
+        "shell-escape-always" => Some(QuotingStyle::Shell {
+            escape: true,
+            always_quote: true,
+            show_control,
+        }),
+        "c" => Some(QuotingStyle::C {
+            quotes: quoting_style::Quotes::Double,
+        }),
+        "escape" => Some(QuotingStyle::C {
+            quotes: quoting_style::Quotes::None,
+        }),
+        _ => None,
+    }
+}
+
 /// Extracts the quoting style to use based on the options provided.
+/// If no options are given, it looks if a default quoting style is provided
+/// through the QUOTING_STYLE environment variable.
 ///
 /// # Arguments
 ///
@@ -577,38 +679,12 @@ fn extract_color(options: &clap::ArgMatches) -> bool {
 ///
 /// A QuotingStyle variant representing the quoting style to use.
 fn extract_quoting_style(options: &clap::ArgMatches, show_control: bool) -> QuotingStyle {
-    let opt_quoting_style = options.get_one::<String>(options::QUOTING_STYLE).cloned();
+    let opt_quoting_style = options.get_one::<String>(options::QUOTING_STYLE);
 
     if let Some(style) = opt_quoting_style {
-        match style.as_str() {
-            "literal" => QuotingStyle::Literal { show_control },
-            "shell" => QuotingStyle::Shell {
-                escape: false,
-                always_quote: false,
-                show_control,
-            },
-            "shell-always" => QuotingStyle::Shell {
-                escape: false,
-                always_quote: true,
-                show_control,
-            },
-            "shell-escape" => QuotingStyle::Shell {
-                escape: true,
-                always_quote: false,
-                show_control,
-            },
-            "shell-escape-always" => QuotingStyle::Shell {
-                escape: true,
-                always_quote: true,
-                show_control,
-            },
-            "c" => QuotingStyle::C {
-                quotes: quoting_style::Quotes::Double,
-            },
-            "escape" => QuotingStyle::C {
-                quotes: quoting_style::Quotes::None,
-            },
-            _ => unreachable!("Should have been caught by Clap"),
+        match match_quoting_style_name(style, show_control) {
+            Some(qs) => qs,
+            None => unreachable!("Should have been caught by Clap"),
         }
     } else if options.get_flag(options::quoting::LITERAL) {
         QuotingStyle::Literal { show_control }
@@ -623,11 +699,28 @@ fn extract_quoting_style(options: &clap::ArgMatches, show_control: bool) -> Quot
     } else if options.get_flag(options::DIRED) {
         QuotingStyle::Literal { show_control }
     } else {
-        // TODO: use environment variable if available
-        QuotingStyle::Shell {
-            escape: true,
-            always_quote: false,
-            show_control,
+        // If set, the QUOTING_STYLE environment variable specifies a default style.
+        if let Ok(style) = std::env::var("QUOTING_STYLE") {
+            match match_quoting_style_name(style.as_str(), show_control) {
+                Some(qs) => return qs,
+                None => eprintln!(
+                    "{}: Ignoring invalid value of environment variable QUOTING_STYLE: '{}'",
+                    std::env::args().next().unwrap_or("ls".to_string()),
+                    style
+                ),
+            }
+        }
+
+        // By default, `ls` uses Shell escape quoting style when writing to a terminal file
+        // descriptor and Literal otherwise.
+        if std::io::stdout().is_terminal() {
+            QuotingStyle::Shell {
+                escape: true,
+                always_quote: false,
+                show_control,
+            }
+        } else {
+            QuotingStyle::Literal { show_control }
         }
     }
 }
@@ -736,19 +829,18 @@ impl Config {
         }
 
         let sort = extract_sort(options);
-
         let time = extract_time(options);
-
         let mut needs_color = extract_color(options);
+        let hyperlink = extract_hyperlink(options);
 
-        let cmd_line_bs = options.get_one::<String>(options::size::BLOCK_SIZE);
-        let opt_si = cmd_line_bs.is_some()
+        let opt_block_size = options.get_one::<String>(options::size::BLOCK_SIZE);
+        let opt_si = opt_block_size.is_some()
             && options
                 .get_one::<String>(options::size::BLOCK_SIZE)
                 .unwrap()
                 .eq("si")
             || options.get_flag(options::size::SI);
-        let opt_hr = (cmd_line_bs.is_some()
+        let opt_hr = (opt_block_size.is_some()
             && options
                 .get_one::<String>(options::size::BLOCK_SIZE)
                 .unwrap()
@@ -756,10 +848,6 @@ impl Config {
             || options.get_flag(options::size::HUMAN_READABLE);
         let opt_kb = options.get_flag(options::size::KIBIBYTES);
 
-        let bs_env_var = std::env::var_os("BLOCK_SIZE");
-        let ls_bs_env_var = std::env::var_os("LS_BLOCK_SIZE");
-        let pc_env_var = std::env::var_os("POSIXLY_CORRECT");
-
         let size_format = if opt_si {
             SizeFormat::Decimal
         } else if opt_hr {
@@ -768,36 +856,66 @@ impl Config {
             SizeFormat::Bytes
         };
 
-        let raw_bs = if let Some(cmd_line_bs) = cmd_line_bs {
-            OsString::from(cmd_line_bs)
-        } else if !opt_kb {
-            if let Some(ls_bs_env_var) = ls_bs_env_var {
-                ls_bs_env_var
-            } else if let Some(bs_env_var) = bs_env_var {
-                bs_env_var
-            } else {
-                OsString::from("")
-            }
+        let env_var_blocksize = std::env::var_os("BLOCKSIZE");
+        let env_var_block_size = std::env::var_os("BLOCK_SIZE");
+        let env_var_ls_block_size = std::env::var_os("LS_BLOCK_SIZE");
+        let env_var_posixly_correct = std::env::var_os("POSIXLY_CORRECT");
+        let mut is_env_var_blocksize = false;
+
+        let raw_block_size = if let Some(opt_block_size) = opt_block_size {
+            OsString::from(opt_block_size)
+        } else if let Some(env_var_ls_block_size) = env_var_ls_block_size {
+            env_var_ls_block_size
+        } else if let Some(env_var_block_size) = env_var_block_size {
+            env_var_block_size
+        } else if let Some(env_var_blocksize) = env_var_blocksize {
+            is_env_var_blocksize = true;
+            env_var_blocksize
         } else {
             OsString::from("")
         };
 
-        let block_size: Option<u64> = if !opt_si && !opt_hr && !raw_bs.is_empty() {
-            match parse_size_u64(&raw_bs.to_string_lossy()) {
-                Ok(size) => Some(size),
+        let (file_size_block_size, block_size) = if !opt_si && !opt_hr && !raw_block_size.is_empty()
+        {
+            match parse_size_u64(&raw_block_size.to_string_lossy()) {
+                Ok(size) => match (is_env_var_blocksize, opt_kb) {
+                    (true, true) => (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE),
+                    (true, false) => (DEFAULT_FILE_SIZE_BLOCK_SIZE, size),
+                    (false, true) => {
+                        // --block-size overrides -k
+                        if opt_block_size.is_some() {
+                            (size, size)
+                        } else {
+                            (size, DEFAULT_BLOCK_SIZE)
+                        }
+                    }
+                    (false, false) => (size, size),
+                },
                 Err(_) => {
-                    show!(LsError::BlockSizeParseError(cmd_line_bs.unwrap().clone()));
-                    None
+                    // only fail if invalid block size was specified with --block-size,
+                    // ignore invalid block size from env vars
+                    if let Some(invalid_block_size) = opt_block_size {
+                        return Err(Box::new(LsError::BlockSizeParseError(
+                            invalid_block_size.clone(),
+                        )));
+                    }
+                    if is_env_var_blocksize {
+                        (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
+                    } else {
+                        (DEFAULT_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
+                    }
                 }
             }
-        } else if let Some(pc) = pc_env_var {
-            if pc.as_os_str() == OsStr::new("true") || pc == OsStr::new("1") {
-                Some(POSIXLY_CORRECT_BLOCK_SIZE)
+        } else if env_var_posixly_correct.is_some() {
+            if opt_kb {
+                (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
             } else {
-                None
+                (DEFAULT_FILE_SIZE_BLOCK_SIZE, POSIXLY_CORRECT_BLOCK_SIZE)
             }
+        } else if opt_si {
+            (DEFAULT_FILE_SIZE_BLOCK_SIZE, 1000)
         } else {
-            None
+            (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
         };
 
         let long = {
@@ -1003,6 +1121,7 @@ impl Config {
             inode: options.get_flag(options::INODE),
             long,
             alloc_size: options.get_flag(options::size::ALLOCATION_SIZE),
+            file_size_block_size,
             block_size,
             width,
             quoting_style,
@@ -1022,6 +1141,7 @@ impl Config {
             group_directories_first: options.get_flag(options::GROUP_DIRECTORIES_FIRST),
             line_ending: LineEnding::from_zero_flag(options.get_flag(options::ZERO)),
             dired,
+            hyperlink,
         })
     }
 }
@@ -1049,6 +1169,7 @@ pub fn uu_app() -> Command {
         .about(ABOUT)
         .infer_long_args(true)
         .disable_help_flag(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::HELP)
                 .long(options::HELP)
@@ -1156,6 +1277,19 @@ pub fn uu_app() -> Command {
                 .help("generate output designed for Emacs' dired (Directory Editor) mode")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::HYPERLINK)
+                .long(options::HYPERLINK)
+                .help("hyperlink file names WHEN")
+                .value_parser([
+                    "always", "yes", "force", "auto", "tty", "if-tty", "never", "no", "none",
+                ])
+                .require_equals(true)
+                .num_args(0..=1)
+                .default_missing_value("always")
+                .default_value("never")
+                .value_name("WHEN"),
+        )
         // The next four arguments do not override with the other format
         // options, see the comment in Config::from for the reason.
         // Ideally, they would use Arg::override_with, with their own name
@@ -1518,7 +1652,7 @@ pub fn uu_app() -> Command {
                 .short('h')
                 .long(options::size::HUMAN_READABLE)
                 .help("Print human readable file sizes (e.g. 1K 234M 56G).")
-                .overrides_with(options::size::SI)
+                .overrides_with_all([options::size::BLOCK_SIZE, options::size::SI])
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -1535,6 +1669,7 @@ pub fn uu_app() -> Command {
             Arg::new(options::size::SI)
                 .long(options::size::SI)
                 .help("Print human readable file sizes using powers of 1000 instead of 1024.")
+                .overrides_with_all([options::size::BLOCK_SIZE, options::size::HUMAN_READABLE])
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -1542,7 +1677,8 @@ pub fn uu_app() -> Command {
                 .long(options::size::BLOCK_SIZE)
                 .require_equals(true)
                 .value_name("BLOCK_SIZE")
-                .help("scale sizes by BLOCK_SIZE when printing them"),
+                .help("scale sizes by BLOCK_SIZE when printing them")
+                .overrides_with_all([options::size::SI, options::size::HUMAN_READABLE]),
         )
         .arg(
             Arg::new(options::INODE)
@@ -1718,6 +1854,8 @@ struct PathData {
     // Result<MetaData> got from symlink_metadata() or metadata() based on config
     md: OnceCell<Option<Metadata>>,
     ft: OnceCell<Option<FileType>>,
+    // can be used to avoid reading the metadata. Can be also called d_type:
+    // https://www.gnu.org/software/libc/manual/html_node/Directory-Entries.html
     de: Option<DirEntry>,
     // Name of the file - will be empty for . or ..
     display_name: OsString,
@@ -1813,10 +1951,11 @@ impl PathData {
         }
     }
 
-    fn md(&self, out: &mut BufWriter<Stdout>) -> Option<&Metadata> {
+    fn get_metadata(&self, out: &mut BufWriter<Stdout>) -> Option<&Metadata> {
         self.md
             .get_or_init(|| {
                 // check if we can use DirEntry metadata
+                // it will avoid a call to stat()
                 if !self.must_dereference {
                     if let Some(dir_entry) = &self.de {
                         return dir_entry.metadata().ok();
@@ -1824,7 +1963,7 @@ impl PathData {
                 }
 
                 // if not, check if we can use Path metadata
-                match get_metadata(self.p_buf.as_path(), self.must_dereference) {
+                match get_metadata_with_deref_opt(self.p_buf.as_path(), self.must_dereference) {
                     Err(err) => {
                         // FIXME: A bit tricky to propagate the result here
                         out.flush().unwrap();
@@ -1853,13 +1992,19 @@ impl PathData {
 
     fn file_type(&self, out: &mut BufWriter<Stdout>) -> Option<&FileType> {
         self.ft
-            .get_or_init(|| self.md(out).map(|md| md.file_type()))
+            .get_or_init(|| self.get_metadata(out).map(|md| md.file_type()))
             .as_ref()
     }
 }
 
-fn show_dir_name(dir: &Path, out: &mut BufWriter<Stdout>) {
-    write!(out, "{}:", dir.display()).unwrap();
+fn show_dir_name(path_data: &PathData, out: &mut BufWriter<Stdout>, config: &Config) {
+    if config.hyperlink {
+        let name = escape_name(&path_data.display_name, &config.quoting_style);
+        let hyperlink = create_hyperlink(&name, path_data);
+        write!(out, "{}:", hyperlink).unwrap();
+    } else {
+        write!(out, "{}:", path_data.p_buf.display()).unwrap();
+    }
 }
 
 #[allow(clippy::cognitive_complexity)]
@@ -1868,6 +2013,7 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
     let mut dirs = Vec::<PathData>::new();
     let mut out = BufWriter::new(stdout());
     let mut dired = DiredOutput::default();
+    let mut style_manager = StyleManager::new();
     let initial_locs_len = locs.len();
 
     for loc in locs {
@@ -1879,7 +2025,7 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
         // Proper GNU handling is don't show if dereferenced symlink DNE
         // but only for the base dir, for a child dir show, and print ?s
         // in long format
-        if path_data.md(&mut out).is_none() {
+        if path_data.get_metadata(&mut out).is_none() {
             continue;
         }
 
@@ -1901,7 +2047,7 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
     sort_entries(&mut files, config, &mut out);
     sort_entries(&mut dirs, config, &mut out);
 
-    display_items(&files, config, &mut out, &mut dired)?;
+    display_items(&files, config, &mut out, &mut dired, &mut style_manager)?;
 
     for (pos, path_data) in dirs.iter().enumerate() {
         // Do read_dir call here to match GNU semantics by printing
@@ -1926,7 +2072,8 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
                 if config.dired {
                     dired::indent(&mut out)?;
                 }
-                writeln!(out, "{}:", path_data.p_buf.display())?;
+                show_dir_name(path_data, &mut out, config);
+                writeln!(out)?;
                 if config.dired {
                     // First directory displayed
                     let dir_len = path_data.display_name.len();
@@ -1937,7 +2084,7 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
                 }
             } else {
                 writeln!(out)?;
-                show_dir_name(&path_data.p_buf, &mut out);
+                show_dir_name(path_data, &mut out, config);
                 writeln!(out)?;
             }
         }
@@ -1953,6 +2100,7 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
             &mut out,
             &mut listed_ancestors,
             &mut dired,
+            &mut style_manager,
         )?;
     }
     if config.dired {
@@ -1965,12 +2113,14 @@ fn sort_entries(entries: &mut [PathData], config: &Config, out: &mut BufWriter<S
     match config.sort {
         Sort::Time => entries.sort_by_key(|k| {
             Reverse(
-                k.md(out)
+                k.get_metadata(out)
                     .and_then(|md| get_system_time(md, config))
                     .unwrap_or(UNIX_EPOCH),
             )
         }),
-        Sort::Size => entries.sort_by_key(|k| Reverse(k.md(out).map(|md| md.len()).unwrap_or(0))),
+        Sort::Size => {
+            entries.sort_by_key(|k| Reverse(k.get_metadata(out).map(|md| md.len()).unwrap_or(0)));
+        }
         // The default sort in GNU ls is case insensitive
         Sort::Name => entries.sort_by(|a, b| a.display_name.cmp(&b.display_name)),
         Sort::Version => entries.sort_by(|a, b| {
@@ -2011,7 +2161,8 @@ fn sort_entries(entries: &mut [PathData], config: &Config, out: &mut BufWriter<S
             !match md {
                 None | Some(None) => {
                     // If it metadata cannot be determined, treat as a file.
-                    get_metadata(p.p_buf.as_path(), true).map_or_else(|_| false, |m| m.is_dir())
+                    get_metadata_with_deref_opt(p.p_buf.as_path(), true)
+                        .map_or_else(|_| false, |m| m.is_dir())
                 }
                 Some(Some(m)) => m.is_dir(),
             }
@@ -2069,6 +2220,7 @@ fn enter_directory(
     out: &mut BufWriter<Stdout>,
     listed_ancestors: &mut HashSet<FileInformation>,
     dired: &mut DiredOutput,
+    style_manager: &mut StyleManager,
 ) -> UResult<()> {
     // Create vec of entries with initial dot files
     let mut entries: Vec<PathData> = if config.files == Files::All {
@@ -2121,7 +2273,7 @@ fn enter_directory(
         }
     }
 
-    display_items(&entries, config, out, dired)?;
+    display_items(&entries, config, out, dired, style_manager)?;
 
     if config.recursive {
         for e in entries
@@ -2160,9 +2312,17 @@ fn enter_directory(
                             dired::add_dir_name(dired, dir_name_size);
                         }
 
-                        show_dir_name(&e.p_buf, out);
+                        show_dir_name(e, out, config);
                         writeln!(out)?;
-                        enter_directory(e, rd, config, out, listed_ancestors, dired)?;
+                        enter_directory(
+                            e,
+                            rd,
+                            config,
+                            out,
+                            listed_ancestors,
+                            dired,
+                            style_manager,
+                        )?;
                         listed_ancestors
                             .remove(&FileInformation::from_path(&e.p_buf, e.must_dereference)?);
                     } else {
@@ -2177,7 +2337,7 @@ fn enter_directory(
     Ok(())
 }
 
-fn get_metadata(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
+fn get_metadata_with_deref_opt(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
     if dereference {
         p_buf.metadata()
     } else {
@@ -2191,7 +2351,7 @@ fn display_dir_entry_size(
     out: &mut BufWriter<std::io::Stdout>,
 ) -> (usize, usize, usize, usize, usize, usize) {
     // TODO: Cache/memorize the display_* results so we don't have to recalculate them.
-    if let Some(md) = entry.md(out) {
+    if let Some(md) = entry.get_metadata(out) {
         let (size_len, major_len, minor_len) = match display_len_or_rdev(md, config) {
             SizeOrDeviceId::Device(major, minor) => (
                 (major.len() + minor.len() + 2usize),
@@ -2229,7 +2389,7 @@ fn return_total(
     let mut total_size = 0;
     for item in items {
         total_size += item
-            .md(out)
+            .get_metadata(out)
             .as_ref()
             .map_or(0, |md| get_block_size(md, config));
     }
@@ -2253,7 +2413,7 @@ fn display_additional_leading_info(
     #[cfg(unix)]
     {
         if config.inode {
-            let i = if let Some(md) = item.md(out) {
+            let i = if let Some(md) = item.get_metadata(out) {
                 get_inode(md)
             } else {
                 "?".to_owned()
@@ -2263,7 +2423,7 @@ fn display_additional_leading_info(
     }
 
     if config.alloc_size {
-        let s = if let Some(md) = item.md(out) {
+        let s = if let Some(md) = item.get_metadata(out) {
             display_size(get_block_size(md, config), config)
         } else {
             "?".to_owned()
@@ -2284,11 +2444,17 @@ fn display_items(
     config: &Config,
     out: &mut BufWriter<Stdout>,
     dired: &mut DiredOutput,
+    style_manager: &mut StyleManager,
 ) -> UResult<()> {
     // `-Z`, `--context`:
     // Display the SELinux security context or '?' if none is found. When used with the `-l`
     // option, print the security context to the left of the size column.
 
+    let quoted = items.iter().any(|item| {
+        let name = escape_name(&item.display_name, &config.quoting_style);
+        name.starts_with('\'')
+    });
+
     if config.format == Format::Long {
         let padding_collection = calculate_padding_collection(items, config, out);
 
@@ -2306,7 +2472,15 @@ fn display_items(
                     display_additional_leading_info(item, &padding_collection, config, out)?;
                 write!(out, "{more_info}")?;
             }
-            display_item_long(item, &padding_collection, config, out, dired)?;
+            display_item_long(
+                item,
+                &padding_collection,
+                config,
+                out,
+                dired,
+                style_manager,
+                quoted,
+            )?;
         }
     } else {
         let mut longest_context_len = 1;
@@ -2323,18 +2497,21 @@ fn display_items(
         let padding = calculate_padding_collection(items, config, out);
 
         let mut names_vec = Vec::new();
-
         for i in items {
             let more_info = display_additional_leading_info(i, &padding, config, out)?;
-            let cell = display_file_name(i, config, prefix_context, more_info, out);
+            let cell = display_item_name(i, config, prefix_context, more_info, out, style_manager);
             names_vec.push(cell);
         }
 
         let names = names_vec.into_iter();
 
         match config.format {
-            Format::Columns => display_grid(names, config.width, Direction::TopToBottom, out)?,
-            Format::Across => display_grid(names, config.width, Direction::LeftToRight, out)?,
+            Format::Columns => {
+                display_grid(names, config.width, Direction::TopToBottom, out, quoted)?;
+            }
+            Format::Across => {
+                display_grid(names, config.width, Direction::LeftToRight, out, quoted)?;
+            }
             Format::Commas => {
                 let mut current_col = 0;
                 let mut names = names;
@@ -2384,17 +2561,7 @@ fn get_block_size(md: &Metadata, config: &Config) -> u64 {
         };
         match config.size_format {
             SizeFormat::Binary | SizeFormat::Decimal => raw_blocks,
-            SizeFormat::Bytes => {
-                if cfg!(unix) {
-                    if let Some(user_block_size) = config.block_size {
-                        raw_blocks / user_block_size
-                    } else {
-                        raw_blocks / DEFAULT_BLOCK_SIZE
-                    }
-                } else {
-                    raw_blocks
-                }
-            }
+            SizeFormat::Bytes => raw_blocks / config.block_size,
         }
     }
     #[cfg(not(unix))]
@@ -2409,6 +2576,7 @@ fn display_grid(
     width: u16,
     direction: Direction,
     out: &mut BufWriter<Stdout>,
+    quoted: bool,
 ) -> UResult<()> {
     if width == 0 {
         // If the width is 0 we print one single line
@@ -2430,7 +2598,15 @@ fn display_grid(
         let mut grid = Grid::new(GridOptions { filling, direction });
 
         for name in names {
-            grid.add(name);
+            let formatted_name = Cell {
+                contents: if quoted && !name.contents.starts_with('\'') {
+                    format!(" {}", name.contents)
+                } else {
+                    name.contents
+                },
+                width: name.width,
+            };
+            grid.add(formatted_name);
         }
 
         match grid.fit_into_width(width as usize) {
@@ -2457,11 +2633,11 @@ fn display_grid(
 /// * `author` ([`display_uname`], config-optional)
 /// * `size / rdev` ([`display_len_or_rdev`])
 /// * `system_time` ([`get_system_time`])
-/// * `file_name` ([`display_file_name`])
+/// * `item_name` ([`display_item_name`])
 ///
 /// This function needs to display information in columns:
 /// * permissions and system_time are already guaranteed to be pre-formatted in fixed length.
-/// * file_name is the last column and is left-aligned.
+/// * item_name is the last column and is left-aligned.
 /// * Everything else needs to be padded using [`pad_left`].
 ///
 /// That's why we have the parameters:
@@ -2481,15 +2657,22 @@ fn display_item_long(
     config: &Config,
     out: &mut BufWriter<Stdout>,
     dired: &mut DiredOutput,
+    style_manager: &mut StyleManager,
+    quoted: bool,
 ) -> UResult<()> {
     let mut output_display: String = String::new();
     if config.dired {
         output_display += "  ";
     }
-    if let Some(md) = item.md(out) {
+    if let Some(md) = item.get_metadata(out) {
+        #[cfg(any(not(unix), target_os = "android", target_os = "macos"))]
+        // TODO: See how Mac should work here
+        let is_acl_set = false;
+        #[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
+        let is_acl_set = has_acl(item.display_name.as_os_str());
         write!(
             output_display,
-            "{}{} {}",
+            "{}{}{} {}",
             display_permissions(md, true),
             if item.security_context.len() > 1 {
                 // GNU `ls` uses a "." character to indicate a file with a security context,
@@ -2498,6 +2681,12 @@ fn display_item_long(
             } else {
                 ""
             },
+            if is_acl_set {
+                // if acl has been set, we display a "+" at the end of the file permissions
+                "+"
+            } else {
+                ""
+            },
             pad_left(&display_symlink_count(md), padding.link_count)
         )
         .unwrap();
@@ -2573,16 +2762,24 @@ fn display_item_long(
 
         write!(output_display, " {} ", display_date(md, config)).unwrap();
 
-        let displayed_file = display_file_name(item, config, None, String::new(), out).contents;
+        let item_name =
+            display_item_name(item, config, None, String::new(), out, style_manager).contents;
+
+        let displayed_item = if quoted && !item_name.starts_with('\'') {
+            format!(" {}", item_name)
+        } else {
+            item_name
+        };
+
         if config.dired {
             let (start, end) = dired::calculate_dired(
                 &dired.dired_positions,
                 output_display.len(),
-                displayed_file.len(),
+                displayed_item.len(),
             );
             dired::update_positions(dired, start, end);
         }
-        write!(output_display, "{}{}", displayed_file, config.line_ending).unwrap();
+        write!(output_display, "{}{}", displayed_item, config.line_ending).unwrap();
     } else {
         #[cfg(unix)]
         let leading_char = {
@@ -2655,7 +2852,8 @@ fn display_item_long(
             write!(output_display, " {}", pad_right("?", padding.uname)).unwrap();
         }
 
-        let displayed_file = display_file_name(item, config, None, String::new(), out).contents;
+        let displayed_item =
+            display_item_name(item, config, None, String::new(), out, style_manager).contents;
         let date_len = 12;
 
         write!(
@@ -2670,10 +2868,10 @@ fn display_item_long(
             dired::calculate_and_update_positions(
                 dired,
                 output_display.len(),
-                displayed_file.trim().len(),
+                displayed_item.trim().len(),
             );
         }
-        write!(output_display, "{}{}", displayed_file, config.line_ending).unwrap();
+        write!(output_display, "{}{}", displayed_item, config.line_ending).unwrap();
     }
     write!(out, "{}", output_display)?;
 
@@ -2861,26 +3059,16 @@ fn display_len_or_rdev(metadata: &Metadata, config: &Config) -> SizeOrDeviceId {
             return SizeOrDeviceId::Device(major.to_string(), minor.to_string());
         }
     }
-    // Reported file len only adjusted for block_size when block_size is set
-    if let Some(user_block_size) = config.block_size {
-        // ordinary division of unsigned integers rounds down,
-        // this is similar to the Rust API for division that rounds up,
-        // currently in nightly only, however once
-        // https://github.com/rust-lang/rust/pull/88582 : "div_ceil"
-        // is stable we should use that instead
-        let len_adjusted = {
-            let d = metadata.len() / user_block_size;
-            let r = metadata.len() % user_block_size;
-            if r == 0 {
-                d
-            } else {
-                d + 1
-            }
-        };
-        SizeOrDeviceId::Size(display_size(len_adjusted, config))
-    } else {
-        SizeOrDeviceId::Size(display_size(metadata.len(), config))
-    }
+    let len_adjusted = {
+        let d = metadata.len() / config.file_size_block_size;
+        let r = metadata.len() % config.file_size_block_size;
+        if r == 0 {
+            d
+        } else {
+            d + 1
+        }
+    };
+    SizeOrDeviceId::Size(display_size(len_adjusted, config))
 }
 
 fn display_size(size: u64, config: &Config) -> String {
@@ -2921,7 +3109,7 @@ fn classify_file(path: &PathData, out: &mut BufWriter<Stdout>) -> Option<char> {
             } else if file_type.is_file()
                 // Safe unwrapping if the file was removed between listing and display
                 // See https://github.com/uutils/coreutils/issues/5371
-                && path.md(out).map(file_is_executable).unwrap_or_default()
+                && path.get_metadata(out).map(file_is_executable).unwrap_or_default()
             {
                 Some('*')
             } else {
@@ -2943,17 +3131,18 @@ fn classify_file(path: &PathData, out: &mut BufWriter<Stdout>) -> Option<char> {
 /// * `config.format` to display symlink targets if `Format::Long`. This function is also
 ///   responsible for coloring symlink target names if `config.color` is specified.
 /// * `config.context` to prepend security context to `name` if compiled with `feat_selinux`.
+/// * `config.hyperlink` decides whether to hyperlink the item
 ///
 /// Note that non-unicode sequences in symlink targets are dealt with using
 /// [`std::path::Path::to_string_lossy`].
-#[allow(unused_variables)]
 #[allow(clippy::cognitive_complexity)]
-fn display_file_name(
+fn display_item_name(
     path: &PathData,
     config: &Config,
     prefix_context: Option<usize>,
     more_info: String,
     out: &mut BufWriter<Stdout>,
+    style_manager: &mut StyleManager,
 ) -> Cell {
     // This is our return value. We start by `&path.display_name` and modify it along the way.
     let mut name = escape_name(&path.display_name, &config.quoting_style);
@@ -2962,18 +3151,12 @@ fn display_file_name(
     // infer it because the color codes mess up term_grid's width calculation.
     let mut width = name.width();
 
+    if config.hyperlink {
+        name = create_hyperlink(&name, path);
+    }
+
     if let Some(ls_colors) = &config.color {
-        let md = path.md(out);
-        name = if md.is_some() {
-            color_name(name, &path.p_buf, md, ls_colors)
-        } else {
-            color_name(
-                name,
-                &path.p_buf,
-                path.p_buf.symlink_metadata().ok().as_ref(),
-                ls_colors,
-            )
-        };
+        name = color_name(name, path, ls_colors, style_manager, out, None);
     }
 
     if config.format != Format::Long && !more_info.is_empty() {
@@ -3039,27 +3222,22 @@ fn display_file_name(
                     // Because we use an absolute path, we can assume this is guaranteed to exist.
                     // Otherwise, we use path.md(), which will guarantee we color to the same
                     // color of non-existent symlinks according to style_for_path_with_metadata.
-                    if path.md(out).is_none()
-                        && get_metadata(target_data.p_buf.as_path(), target_data.must_dereference)
-                            .is_err()
+                    if path.get_metadata(out).is_none()
+                        && get_metadata_with_deref_opt(
+                            target_data.p_buf.as_path(),
+                            target_data.must_dereference,
+                        )
+                        .is_err()
                     {
                         name.push_str(&path.p_buf.read_link().unwrap().to_string_lossy());
                     } else {
-                        // Use fn get_metadata instead of md() here and above because ls
-                        // should not exit with an err, if we are unable to obtain the target_metadata
-                        let target_metadata = match get_metadata(
-                            target_data.p_buf.as_path(),
-                            target_data.must_dereference,
-                        ) {
-                            Ok(md) => md,
-                            Err(_) => path.md(out).unwrap().clone(),
-                        };
-
                         name.push_str(&color_name(
                             escape_name(target.as_os_str(), &config.quoting_style),
-                            &target_data.p_buf,
-                            Some(&target_metadata),
+                            path,
                             ls_colors,
+                            style_manager,
+                            out,
+                            Some(&target_data),
                         ));
                     }
                 } else {
@@ -3094,12 +3272,118 @@ fn display_file_name(
     }
 }
 
-fn color_name(name: String, path: &Path, md: Option<&Metadata>, ls_colors: &LsColors) -> String {
-    match ls_colors.style_for_path_with_metadata(path, md) {
-        Some(style) => {
-            return style.to_nu_ansi_term_style().paint(name).to_string();
+fn create_hyperlink(name: &str, path: &PathData) -> String {
+    let hostname = hostname::get().unwrap_or(OsString::from(""));
+    let hostname = hostname.to_string_lossy();
+
+    let absolute_path = fs::canonicalize(&path.p_buf).unwrap_or_default();
+    let absolute_path = absolute_path.to_string_lossy();
+
+    #[cfg(not(target_os = "windows"))]
+    let unencoded_chars = "_-.:~/";
+    #[cfg(target_os = "windows")]
+    let unencoded_chars = "_-.:~/\\";
+
+    // percentage encoding of path
+    let absolute_path: String = absolute_path
+        .chars()
+        .map(|c| {
+            if c.is_alphanumeric() || unencoded_chars.contains(c) {
+                c.to_string()
+            } else {
+                format!("%{:02x}", c as u8)
+            }
+        })
+        .collect();
+
+    // \x1b = ESC, \x07 = BEL
+    format!("\x1b]8;;file://{hostname}{absolute_path}\x07{name}\x1b]8;;\x07")
+}
+
+/// We need this struct to be able to store the previous style.
+/// This because we need to check the previous value in case we don't need
+/// the reset
+struct StyleManager {
+    current_style: Option<Style>,
+}
+
+impl StyleManager {
+    fn new() -> Self {
+        Self {
+            current_style: None,
+        }
+    }
+
+    fn apply_style(&mut self, new_style: &Style, name: &str) -> String {
+        if let Some(current) = &self.current_style {
+            if *current == *new_style {
+                // Current style is the same as new style, apply without reset.
+                let mut style = new_style.to_nu_ansi_term_style();
+                style.prefix_with_reset = false;
+                return style.paint(name).to_string();
+            }
+        }
+
+        // We are getting a new style, we need to reset it
+        self.current_style = Some(new_style.clone());
+        new_style
+            .to_nu_ansi_term_style()
+            .reset_before_style()
+            .paint(name)
+            .to_string()
+    }
+}
+
+fn apply_style_based_on_metadata(
+    path: &PathData,
+    md_option: Option<&Metadata>,
+    ls_colors: &LsColors,
+    style_manager: &mut StyleManager,
+    name: &str,
+) -> String {
+    match ls_colors.style_for_path_with_metadata(&path.p_buf, md_option) {
+        Some(style) => style_manager.apply_style(style, name),
+        None => name.to_owned(),
+    }
+}
+
+/// Colors the provided name based on the style determined for the given path
+/// This function is quite long because it tries to leverage DirEntry to avoid
+/// unnecessary calls to stat()
+/// and manages the symlink errors
+fn color_name(
+    name: String,
+    path: &PathData,
+    ls_colors: &LsColors,
+    style_manager: &mut StyleManager,
+    out: &mut BufWriter<Stdout>,
+    target_symlink: Option<&PathData>,
+) -> String {
+    if !path.must_dereference {
+        // If we need to dereference (follow) a symlink, we will need to get the metadata
+        if let Some(de) = &path.de {
+            // There is a DirEntry, we don't need to get the metadata for the color
+            return match ls_colors.style_for(de) {
+                Some(style) => style_manager.apply_style(style, &name),
+                None => name,
+            };
         }
-        None => name,
+    }
+
+    if let Some(target) = target_symlink {
+        // use the optional target_symlink
+        // Use fn get_metadata_with_deref_opt instead of get_metadata() here because ls
+        // should not exit with an err, if we are unable to obtain the target_metadata
+        let md = get_metadata_with_deref_opt(target.p_buf.as_path(), path.must_dereference)
+            .unwrap_or_else(|_| target.get_metadata(out).unwrap().clone());
+
+        apply_style_based_on_metadata(path, Some(&md), ls_colors, style_manager, &name)
+    } else {
+        let md_option = path.get_metadata(out);
+        let symlink_metadata = path.p_buf.symlink_metadata().ok();
+        let md = md_option.or(symlink_metadata.as_ref());
+
+        apply_style_based_on_metadata(path, md, ls_colors, style_manager, &name)
     }
 }
 
@@ -3129,7 +3413,7 @@ fn get_security_context(config: &Config, p_buf: &Path, must_dereference: bool) -
     // does not support SELinux.
     // Conforms to the GNU coreutils where a dangling symlink results in exit code 1.
     if must_dereference {
-        match get_metadata(p_buf, must_dereference) {
+        match get_metadata_with_deref_opt(p_buf, must_dereference) {
             Err(err) => {
                 // The Path couldn't be dereferenced, so return early and set exit code 1
                 // to indicate a minor error
@@ -3194,7 +3478,7 @@ fn calculate_padding_collection(
     for item in items {
         #[cfg(unix)]
         if config.inode {
-            let inode_len = if let Some(md) = item.md(out) {
+            let inode_len = if let Some(md) = item.get_metadata(out) {
                 display_inode(md).len()
             } else {
                 continue;
@@ -3203,7 +3487,7 @@ fn calculate_padding_collection(
         }
 
         if config.alloc_size {
-            if let Some(md) = item.md(out) {
+            if let Some(md) = item.get_metadata(out) {
                 let block_size_len = display_size(get_block_size(md, config), config).len();
                 padding_collections.block_size = block_size_len.max(padding_collections.block_size);
             }
@@ -3228,7 +3512,7 @@ fn calculate_padding_collection(
                 padding_collections.minor = minor_len.max(padding_collections.minor);
                 padding_collections.size = size_len
                     .max(padding_collections.size)
-                    .max(padding_collections.major + padding_collections.minor + 2usize);
+                    .max(padding_collections.major);
             }
         }
     }
@@ -3253,7 +3537,7 @@ fn calculate_padding_collection(
 
     for item in items {
         if config.alloc_size {
-            if let Some(md) = item.md(out) {
+            if let Some(md) = item.get_metadata(out) {
                 let block_size_len = display_size(get_block_size(md, config), config).len();
                 padding_collections.block_size = block_size_len.max(padding_collections.block_size);
             }
diff --git a/src/uu/mkdir/Cargo.toml b/src/uu/mkdir/Cargo.toml
index 4f6ddb3cc02..a0ba24b42e8 100644
--- a/src/uu/mkdir/Cargo.toml
+++ b/src/uu/mkdir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mkdir"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mkdir ~ (uutils) create DIRECTORY"
diff --git a/src/uu/mkdir/mkdir.md b/src/uu/mkdir/mkdir.md
index 1698842cd9c..eea3d2eb063 100644
--- a/src/uu/mkdir/mkdir.md
+++ b/src/uu/mkdir/mkdir.md
@@ -3,7 +3,7 @@
 <!-- spell-checker:ignore ugoa -->
 
 ```
-mkdir [OPTION]... [USER]
+mkdir [OPTION]... DIRECTORY...
 ```
 
 Create the given DIRECTORY(ies) if they do not exist
diff --git a/src/uu/mkdir/src/mkdir.rs b/src/uu/mkdir/src/mkdir.rs
index 4121278b69a..c29905ef4a7 100644
--- a/src/uu/mkdir/src/mkdir.rs
+++ b/src/uu/mkdir/src/mkdir.rs
@@ -16,7 +16,7 @@ use uucore::error::{UResult, USimpleError};
 #[cfg(not(windows))]
 use uucore::mode;
 use uucore::{display::Quotable, fs::dir_strip_dot_for_creation};
-use uucore::{format_usage, help_about, help_section, help_usage, show, show_if_err};
+use uucore::{format_usage, help_about, help_section, help_usage, show_if_err};
 
 static DEFAULT_PERM: u32 = 0o777;
 
diff --git a/src/uu/mkfifo/Cargo.toml b/src/uu/mkfifo/Cargo.toml
index d7f787511a8..10ff3661686 100644
--- a/src/uu/mkfifo/Cargo.toml
+++ b/src/uu/mkfifo/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mkfifo"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mkfifo ~ (uutils) create FIFOs (named pipes)"
diff --git a/src/uu/mkfifo/src/mkfifo.rs b/src/uu/mkfifo/src/mkfifo.rs
index 39d1127394e..9320f76ed04 100644
--- a/src/uu/mkfifo/src/mkfifo.rs
+++ b/src/uu/mkfifo/src/mkfifo.rs
@@ -22,8 +22,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     if matches.contains_id(options::CONTEXT) {
diff --git a/src/uu/mknod/Cargo.toml b/src/uu/mknod/Cargo.toml
index 58caa5d9dc4..000fe4d01a5 100644
--- a/src/uu/mknod/Cargo.toml
+++ b/src/uu/mknod/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mknod"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mknod ~ (uutils) create special file NAME of TYPE"
diff --git a/src/uu/mknod/src/mknod.rs b/src/uu/mknod/src/mknod.rs
index ceafd235b01..15a0fdacdb8 100644
--- a/src/uu/mknod/src/mknod.rs
+++ b/src/uu/mknod/src/mknod.rs
@@ -68,7 +68,6 @@ fn _mknod(file_name: &str, mode: mode_t, dev: dev_t) -> i32 {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
     // Linux-specific options, not implemented
     // opts.optflag("Z", "", "set the SELinux security context to default type");
     // opts.optopt("", "context", "like -Z, or if CTX is specified then set the SELinux or SMACK security context to CTX");
diff --git a/src/uu/mknod/src/parsemode.rs b/src/uu/mknod/src/parsemode.rs
deleted file mode 100644
index c38800bcb0d..00000000000
--- a/src/uu/mknod/src/parsemode.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (path) osrelease
-
-use libc::{mode_t, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR};
-
-use uucore::mode;
-
-pub const MODE_RW_UGO: mode_t = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
-
-pub fn parse_mode(mode: &str) -> Result<mode_t, String> {
-    let result = if mode.chars().any(|c| c.is_ascii_digit()) {
-        mode::parse_numeric(MODE_RW_UGO as u32, mode)
-    } else {
-        mode::parse_symbolic(MODE_RW_UGO as u32, mode, true)
-    };
-    result.map(|mode| mode as mode_t)
-}
-
-#[cfg(test)]
-mod test {
-    /// Test if the program is running under WSL
-    // ref: <https://github.com/microsoft/WSL/issues/4555> @@ <https://archive.is/dP0bz>
-    // ToDO: test on WSL2 which likely doesn't need special handling; plan change to `is_wsl_1()` if WSL2 is less needy
-    pub fn is_wsl() -> bool {
-        #[cfg(target_os = "linux")]
-        {
-            if let Ok(b) = std::fs::read("/proc/sys/kernel/osrelease") {
-                if let Ok(s) = std::str::from_utf8(&b) {
-                    let a = s.to_ascii_lowercase();
-                    return a.contains("microsoft") || a.contains("wsl");
-                }
-            }
-        }
-        false
-    }
-
-    #[test]
-    fn symbolic_modes() {
-        assert_eq!(super::parse_mode("u+x").unwrap(), 0o766);
-        assert_eq!(
-            super::parse_mode("+x").unwrap(),
-            if is_wsl() { 0o776 } else { 0o777 }
-        );
-        assert_eq!(super::parse_mode("a-w").unwrap(), 0o444);
-        assert_eq!(super::parse_mode("g-r").unwrap(), 0o626);
-    }
-
-    #[test]
-    fn numeric_modes() {
-        assert_eq!(super::parse_mode("644").unwrap(), 0o644);
-        assert_eq!(super::parse_mode("+100").unwrap(), 0o766);
-        assert_eq!(super::parse_mode("-4").unwrap(), 0o662);
-    }
-}
diff --git a/src/uu/mktemp/Cargo.toml b/src/uu/mktemp/Cargo.toml
index 2913e4b6e02..504c46350d7 100644
--- a/src/uu/mktemp/Cargo.toml
+++ b/src/uu/mktemp/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mktemp"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mktemp ~ (uutils) create and display a temporary file or directory from TEMPLATE"
diff --git a/src/uu/mktemp/src/mktemp.rs b/src/uu/mktemp/src/mktemp.rs
index d52351a8948..ae44225c9a6 100644
--- a/src/uu/mktemp/src/mktemp.rs
+++ b/src/uu/mktemp/src/mktemp.rs
@@ -12,6 +12,7 @@ use uucore::{format_usage, help_about, help_usage};
 
 use std::env;
 use std::error::Error;
+use std::ffi::OsStr;
 use std::fmt::Display;
 use std::io::ErrorKind;
 use std::iter;
@@ -308,8 +309,7 @@ impl Params {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
+    let args: Vec<_> = args.collect();
     let matches = match uu_app().try_get_matches_from(&args) {
         Ok(m) => m,
         Err(e) => {
@@ -333,7 +333,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         // If POSIXLY_CORRECT was set, template MUST be the last argument.
         if matches.contains_id(ARG_TEMPLATE) {
             // Template argument was provided, check if was the last one.
-            if args.last().unwrap() != &options.template {
+            if args.last().unwrap() != OsStr::new(&options.template) {
                 return Err(Box::new(MkTempError::TooManyTemplates));
             }
         }
diff --git a/src/uu/more/Cargo.toml b/src/uu/more/Cargo.toml
index 9f0bc9d3d65..58957a08c74 100644
--- a/src/uu/more/Cargo.toml
+++ b/src/uu/more/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_more"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "more ~ (uutils) input perusal filter"
diff --git a/src/uu/more/more.md b/src/uu/more/more.md
index cb626060ec5..e63ca1a87fb 100644
--- a/src/uu/more/more.md
+++ b/src/uu/more/more.md
@@ -1,7 +1,7 @@
 # more
 
 ```
-more [OPTIONS] <FILE>...
+more [OPTIONS] FILE...
 ```
 
 Display the contents of a text file
diff --git a/src/uu/more/src/more.rs b/src/uu/more/src/more.rs
index 02ed0feea20..f651a033b54 100644
--- a/src/uu/more/src/more.rs
+++ b/src/uu/more/src/more.rs
@@ -87,8 +87,7 @@ impl Options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-    let matches = match uu_app().try_get_matches_from(&args) {
+    let matches = match uu_app().try_get_matches_from(args) {
         Ok(m) => m,
         Err(e) => return Err(e.into()),
     };
diff --git a/src/uu/mv/Cargo.toml b/src/uu/mv/Cargo.toml
index 83a10ef6b7a..4193f9595cb 100644
--- a/src/uu/mv/Cargo.toml
+++ b/src/uu/mv/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_mv"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mv ~ (uutils) move (rename) SOURCE to DESTINATION"
@@ -21,6 +21,7 @@ indicatif = { workspace = true }
 uucore = { workspace = true, features = [
   "backup-control",
   "fs",
+  "fsxattr",
   "update-control",
 ] }
 
diff --git a/src/uu/mv/src/mv.rs b/src/uu/mv/src/mv.rs
index 036024f9907..9f24cf77092 100644
--- a/src/uu/mv/src/mv.rs
+++ b/src/uu/mv/src/mv.rs
@@ -10,6 +10,7 @@ mod error;
 use clap::builder::ValueParser;
 use clap::{crate_version, error::ErrorKind, Arg, ArgAction, ArgMatches, Command};
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use std::collections::HashSet;
 use std::env;
 use std::ffi::OsString;
 use std::fs;
@@ -21,9 +22,15 @@ use std::os::windows;
 use std::path::{Path, PathBuf};
 use uucore::backup_control::{self, source_is_target_backup};
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, FromIo, UError, UResult, USimpleError, UUsageError};
-use uucore::fs::{are_hardlinks_or_one_way_symlink_to_same_file, are_hardlinks_to_same_file};
+use uucore::error::{set_exit_code, FromIo, UResult, USimpleError, UUsageError};
+use uucore::fs::{
+    are_hardlinks_or_one_way_symlink_to_same_file, are_hardlinks_to_same_file,
+    path_ends_with_terminator,
+};
+#[cfg(all(unix, not(target_os = "macos")))]
+use uucore::fsxattr;
 use uucore::update_control;
+
 // These are exposed for projects (e.g. nushell) that want to create an `Options` value, which
 // requires these enums
 pub use uucore::{backup_control::BackupMode, update_control::UpdateMode};
@@ -103,37 +110,18 @@ static OPT_VERBOSE: &str = "verbose";
 static OPT_PROGRESS: &str = "progress";
 static ARG_FILES: &str = "files";
 
-/// Returns true if the passed `path` ends with a path terminator.
-#[cfg(unix)]
-fn path_ends_with_terminator(path: &Path) -> bool {
-    use std::os::unix::prelude::OsStrExt;
-    path.as_os_str()
-        .as_bytes()
-        .last()
-        .map_or(false, |&byte| byte == b'/' || byte == b'\\')
-}
-
-#[cfg(windows)]
-fn path_ends_with_terminator(path: &Path) -> bool {
-    use std::os::windows::prelude::OsStrExt;
-    path.as_os_str()
-        .encode_wide()
-        .last()
-        .map_or(false, |wide| wide == b'/'.into() || wide == b'\\'.into())
-}
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let mut app = uu_app();
     let matches = app.try_get_matches_from_mut(args)?;
 
-    if !matches.contains_id(OPT_TARGET_DIRECTORY)
-        && matches
-            .get_many::<OsString>(ARG_FILES)
-            .map(|f| f.len())
-            .unwrap_or(0)
-            == 1
-    {
+    let files: Vec<OsString> = matches
+        .get_many::<OsString>(ARG_FILES)
+        .unwrap_or_default()
+        .cloned()
+        .collect();
+
+    if files.len() == 1 && !matches.contains_id(OPT_TARGET_DIRECTORY) {
         app.error(
             ErrorKind::TooFewValues,
             format!(
@@ -143,12 +131,6 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .exit();
     }
 
-    let files: Vec<OsString> = matches
-        .get_many::<OsString>(ARG_FILES)
-        .unwrap_or_default()
-        .cloned()
-        .collect();
-
     let overwrite_mode = determine_overwrite_mode(&matches);
     let backup_mode = backup_control::determine_backup_mode(&matches)?;
     let update_mode = update_control::determine_update_mode(&matches);
@@ -340,8 +322,13 @@ fn handle_two_paths(source: &Path, target: &Path, opts: &Options) -> UResult<()>
     }
 
     let target_is_dir = target.is_dir();
+    let source_is_dir = source.is_dir();
 
-    if path_ends_with_terminator(target) && !target_is_dir {
+    if path_ends_with_terminator(target)
+        && (!target_is_dir && !source_is_dir)
+        && !opts.no_target_dir
+        && opts.update != UpdateMode::ReplaceIfOlder
+    {
         return Err(MvError::FailedToAccessNotADirectory(target.quote().to_string()).into());
     }
 
@@ -354,29 +341,15 @@ fn handle_two_paths(source: &Path, target: &Path, opts: &Options) -> UResult<()>
             } else {
                 Err(MvError::DirectoryToNonDirectory(target.quote().to_string()).into())
             }
+        // Check that source & target do not contain same subdir/dir when both exist
+        // mkdir dir1/dir2; mv dir1 dir1/dir2
+        } else if target.starts_with(source) {
+            Err(MvError::SelfTargetSubdirectory(
+                source.display().to_string(),
+                target.display().to_string(),
+            )
+            .into())
         } else {
-            // Check that source & target  do not contain same subdir/dir when both exist
-            // mkdir dir1/dir2; mv dir1 dir1/dir2
-            let target_contains_itself = target
-                .as_os_str()
-                .to_str()
-                .ok_or("not a valid unicode string")
-                .and_then(|t| {
-                    source
-                        .as_os_str()
-                        .to_str()
-                        .ok_or("not a valid unicode string")
-                        .map(|s| t.contains(s))
-                })
-                .unwrap();
-
-            if target_contains_itself {
-                return Err(MvError::SelfTargetSubdirectory(
-                    source.display().to_string(),
-                    target.display().to_string(),
-                )
-                .into());
-            }
             move_files_into_dir(&[source.to_path_buf()], target, opts)
         }
     } else if target.exists() && source.is_dir() {
@@ -429,7 +402,10 @@ pub fn mv(files: &[OsString], opts: &Options) -> UResult<()> {
 }
 
 #[allow(clippy::cognitive_complexity)]
-fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, opts: &Options) -> UResult<()> {
+fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, options: &Options) -> UResult<()> {
+    // remember the moved destinations for further usage
+    let mut moved_destinations: HashSet<PathBuf> = HashSet::with_capacity(files.len());
+
     if !target_dir.is_dir() {
         return Err(MvError::NotADirectory(target_dir.quote().to_string()).into());
     }
@@ -438,7 +414,7 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, opts: &Options) ->
         .canonicalize()
         .unwrap_or_else(|_| target_dir.to_path_buf());
 
-    let multi_progress = opts.progress_bar.then(MultiProgress::new);
+    let multi_progress = options.progress_bar.then(MultiProgress::new);
 
     let count_progress = if let Some(ref multi_progress) = multi_progress {
         if files.len() > 1 {
@@ -467,6 +443,20 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, opts: &Options) ->
             }
         };
 
+        if moved_destinations.contains(&targetpath) && options.backup != BackupMode::NumberedBackup
+        {
+            // If the target file was already created in this mv call, do not overwrite
+            show!(USimpleError::new(
+                1,
+                format!(
+                    "will not overwrite just-created '{}' with '{}'",
+                    targetpath.display(),
+                    sourcepath.display()
+                ),
+            ));
+            continue;
+        }
+
         // Check if we have mv dir1 dir2 dir2
         // And generate an error if this is the case
         if let Ok(canonicalized_source) = sourcepath.canonicalize() {
@@ -489,7 +479,7 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, opts: &Options) ->
             }
         }
 
-        match rename(sourcepath, &targetpath, opts, multi_progress.as_ref()) {
+        match rename(sourcepath, &targetpath, options, multi_progress.as_ref()) {
             Err(e) if e.to_string().is_empty() => set_exit_code(1),
             Err(e) => {
                 let e = e.map_err_context(|| {
@@ -509,6 +499,7 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, opts: &Options) ->
         if let Some(ref pb) = count_progress {
             pb.inc(1);
         }
+        moved_destinations.insert(targetpath.clone());
     }
     Ok(())
 }
@@ -643,6 +634,10 @@ fn rename_with_fallback(
                     None
                 };
 
+            #[cfg(all(unix, not(target_os = "macos")))]
+            let xattrs =
+                fsxattr::retrieve_xattrs(from).unwrap_or_else(|_| std::collections::HashMap::new());
+
             let result = if let Some(ref pb) = progress_bar {
                 move_dir_with_progress(from, to, &options, |process_info: TransitProcess| {
                     pb.set_position(process_info.copied_bytes);
@@ -653,6 +648,9 @@ fn rename_with_fallback(
                 move_dir(from, to, &options)
             };
 
+            #[cfg(all(unix, not(target_os = "macos")))]
+            fsxattr::apply_xattrs(to, xattrs).unwrap();
+
             if let Err(err) = result {
                 return match err.kind {
                     fs_extra::error::ErrorKind::PermissionDenied => Err(io::Error::new(
@@ -663,6 +661,11 @@ fn rename_with_fallback(
                 };
             }
         } else {
+            #[cfg(all(unix, not(target_os = "macos")))]
+            fs::copy(from, to)
+                .and_then(|_| fsxattr::copy_xattrs(&from, &to))
+                .and_then(|_| fs::remove_file(from))?;
+            #[cfg(any(target_os = "macos", not(unix)))]
             fs::copy(from, to).and_then(|_| fs::remove_file(from))?;
         }
     }
diff --git a/src/uu/nice/Cargo.toml b/src/uu/nice/Cargo.toml
index 6fab5cefc24..7285318ef63 100644
--- a/src/uu/nice/Cargo.toml
+++ b/src/uu/nice/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_nice"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nice ~ (uutils) run PROGRAM with modified scheduling priority"
diff --git a/src/uu/nl/Cargo.toml b/src/uu/nl/Cargo.toml
index 56cb8d8e94e..35b0f3d848b 100644
--- a/src/uu/nl/Cargo.toml
+++ b/src/uu/nl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_nl"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nl ~ (uutils) display input with added line numbers"
diff --git a/src/uu/nl/src/nl.rs b/src/uu/nl/src/nl.rs
index eaf27f3b6f4..c7e72f6e2e2 100644
--- a/src/uu/nl/src/nl.rs
+++ b/src/uu/nl/src/nl.rs
@@ -7,8 +7,8 @@ use clap::{crate_version, Arg, ArgAction, Command};
 use std::fs::File;
 use std::io::{stdin, BufRead, BufReader, Read};
 use std::path::Path;
-use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::{format_usage, help_about, help_section, help_usage};
+use uucore::error::{set_exit_code, FromIo, UResult, USimpleError};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 
 mod helper;
 
@@ -178,8 +178,6 @@ pub mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let mut settings = Settings::default();
@@ -207,9 +205,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             nl(&mut buffer, &mut stats, &settings)?;
         } else {
             let path = Path::new(file);
-            let reader = File::open(path).map_err_context(|| file.to_string())?;
-            let mut buffer = BufReader::new(reader);
-            nl(&mut buffer, &mut stats, &settings)?;
+
+            if path.is_dir() {
+                show_error!("{}: Is a directory", path.display());
+                set_exit_code(1);
+            } else {
+                let reader = File::open(path).map_err_context(|| file.to_string())?;
+                let mut buffer = BufReader::new(reader);
+                nl(&mut buffer, &mut stats, &settings)?;
+            }
         }
     }
 
diff --git a/src/uu/nohup/Cargo.toml b/src/uu/nohup/Cargo.toml
index 24d8f659c7e..8e8bd50cb4d 100644
--- a/src/uu/nohup/Cargo.toml
+++ b/src/uu/nohup/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_nohup"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nohup ~ (uutils) run COMMAND, ignoring hangup signals"
diff --git a/src/uu/nohup/nohup.md b/src/uu/nohup/nohup.md
index cc35ef9f46c..65ffaec873d 100644
--- a/src/uu/nohup/nohup.md
+++ b/src/uu/nohup/nohup.md
@@ -2,7 +2,7 @@
 
 ```
 nohup COMMAND [ARG]...
-nohup FLAG
+nohup OPTION
 ```
 
 Run COMMAND ignoring hangup signals.
diff --git a/src/uu/nohup/src/nohup.rs b/src/uu/nohup/src/nohup.rs
index c64f7bf71ba..74dfa71c5f8 100644
--- a/src/uu/nohup/src/nohup.rs
+++ b/src/uu/nohup/src/nohup.rs
@@ -74,8 +74,6 @@ impl Display for NohupError {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
 
     replace_fds()?;
@@ -200,7 +198,12 @@ extern "C" {
     fn _vprocmgr_detach_from_console(flags: u32) -> *const libc::c_int;
 }
 
-#[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "openbsd"
+))]
 unsafe fn _vprocmgr_detach_from_console(_: u32) -> *const libc::c_int {
     std::ptr::null()
 }
diff --git a/src/uu/nproc/Cargo.toml b/src/uu/nproc/Cargo.toml
index 54bb1d83c09..9e6efc559c1 100644
--- a/src/uu/nproc/Cargo.toml
+++ b/src/uu/nproc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_nproc"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nproc ~ (uutils) display the number of processing units available"
diff --git a/src/uu/numfmt/Cargo.toml b/src/uu/numfmt/Cargo.toml
index 79e6d5401aa..71505d4b7db 100644
--- a/src/uu/numfmt/Cargo.toml
+++ b/src/uu/numfmt/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_numfmt"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "numfmt ~ (uutils) reformat NUMBER"
diff --git a/src/uu/numfmt/src/numfmt.rs b/src/uu/numfmt/src/numfmt.rs
index d1785209d06..d158072fbb4 100644
--- a/src/uu/numfmt/src/numfmt.rs
+++ b/src/uu/numfmt/src/numfmt.rs
@@ -13,7 +13,7 @@ use std::str::FromStr;
 
 use units::{IEC_BASES, SI_BASES};
 use uucore::display::Quotable;
-use uucore::error::{UError, UResult};
+use uucore::error::UResult;
 use uucore::ranges::Range;
 use uucore::{format_usage, help_about, help_section, help_usage, show, show_error};
 
diff --git a/src/uu/od/Cargo.toml b/src/uu/od/Cargo.toml
index 84c89ee8611..e2c0a236b93 100644
--- a/src/uu/od/Cargo.toml
+++ b/src/uu/od/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_od"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "od ~ (uutils) display formatted representation of input"
diff --git a/src/uu/paste/Cargo.toml b/src/uu/paste/Cargo.toml
index 68255c82ddd..0ab1015b9df 100644
--- a/src/uu/paste/Cargo.toml
+++ b/src/uu/paste/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_paste"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "paste ~ (uutils) merge lines from inputs"
diff --git a/src/uu/pathchk/Cargo.toml b/src/uu/pathchk/Cargo.toml
index dee85deae55..eeb667ac349 100644
--- a/src/uu/pathchk/Cargo.toml
+++ b/src/uu/pathchk/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_pathchk"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pathchk ~ (uutils) diagnose invalid or non-portable PATHNAME"
diff --git a/src/uu/pathchk/src/pathchk.rs b/src/uu/pathchk/src/pathchk.rs
index 81c35208864..ffb214e2ebf 100644
--- a/src/uu/pathchk/src/pathchk.rs
+++ b/src/uu/pathchk/src/pathchk.rs
@@ -36,8 +36,6 @@ const POSIX_NAME_MAX: usize = 14;
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     // set working mode
diff --git a/src/uu/pinky/Cargo.toml b/src/uu/pinky/Cargo.toml
index f64cb758510..ba1dbc09688 100644
--- a/src/uu/pinky/Cargo.toml
+++ b/src/uu/pinky/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_pinky"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pinky ~ (uutils) display user information"
diff --git a/src/uu/pinky/src/pinky.rs b/src/uu/pinky/src/pinky.rs
index 8ac8f6c8446..6b393b905d6 100644
--- a/src/uu/pinky/src/pinky.rs
+++ b/src/uu/pinky/src/pinky.rs
@@ -5,21 +5,11 @@
 
 // spell-checker:ignore (ToDO) BUFSIZE gecos fullname, mesg iobuf
 
-use uucore::entries::{Locate, Passwd};
-use uucore::error::{FromIo, UResult};
-use uucore::libc::S_IWGRP;
-use uucore::utmpx::{self, time, Utmpx};
-
-use std::io::prelude::*;
-use std::io::BufReader;
-
-use std::fs::File;
-use std::os::unix::fs::MetadataExt;
-
 use clap::{crate_version, Arg, ArgAction, Command};
-use std::path::PathBuf;
 use uucore::{format_usage, help_about, help_usage};
 
+mod platform;
+
 const ABOUT: &str = help_about!("pinky.md");
 const USAGE: &str = help_usage!("pinky.md");
 
@@ -37,88 +27,8 @@ mod options {
     pub const HELP: &str = "help";
 }
 
-fn get_long_usage() -> String {
-    format!(
-        "A lightweight 'finger' program;  print user information.\n\
-         The utmp file will be {}.",
-        utmpx::DEFAULT_FILE
-    )
-}
-
 #[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
-    let matches = uu_app()
-        .after_help(get_long_usage())
-        .try_get_matches_from(args)?;
-
-    let users: Vec<String> = matches
-        .get_many::<String>(options::USER)
-        .map(|v| v.map(ToString::to_string).collect())
-        .unwrap_or_default();
-
-    // If true, display the hours:minutes since each user has touched
-    // the keyboard, or blank if within the last minute, or days followed
-    // by a 'd' if not within the last day.
-    let mut include_idle = true;
-
-    // If true, display a line at the top describing each field.
-    let include_heading = !matches.get_flag(options::OMIT_HEADINGS);
-
-    // if true, display the user's full name from pw_gecos.
-    let mut include_fullname = true;
-
-    // if true, display the user's ~/.project file when doing long format.
-    let include_project = !matches.get_flag(options::OMIT_PROJECT_FILE);
-
-    // if true, display the user's ~/.plan file when doing long format.
-    let include_plan = !matches.get_flag(options::OMIT_PLAN_FILE);
-
-    // if true, display the user's home directory and shell
-    // when doing long format.
-    let include_home_and_shell = !matches.get_flag(options::OMIT_HOME_DIR);
-
-    // if true, use the "short" output format.
-    let do_short_format = !matches.get_flag(options::LONG_FORMAT);
-
-    /* if true, display the ut_host field. */
-    let mut include_where = true;
-
-    if matches.get_flag(options::OMIT_NAME) {
-        include_fullname = false;
-    }
-    if matches.get_flag(options::OMIT_NAME_HOST) {
-        include_fullname = false;
-        include_where = false;
-    }
-    if matches.get_flag(options::OMIT_NAME_HOST_TIME) {
-        include_fullname = false;
-        include_idle = false;
-        include_where = false;
-    }
-
-    let pk = Pinky {
-        include_idle,
-        include_heading,
-        include_fullname,
-        include_project,
-        include_plan,
-        include_home_and_shell,
-        include_where,
-        names: users,
-    };
-
-    if do_short_format {
-        match pk.short_pinky() {
-            Ok(_) => Ok(()),
-            Err(e) => Err(e.map_err_context(String::new)),
-        }
-    } else {
-        pk.long_pinky();
-        Ok(())
-    }
-}
+use platform::uumain;
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
@@ -197,17 +107,6 @@ pub fn uu_app() -> Command {
         )
 }
 
-struct Pinky {
-    include_idle: bool,
-    include_heading: bool,
-    include_fullname: bool,
-    include_project: bool,
-    include_plan: bool,
-    include_where: bool,
-    include_home_and_shell: bool,
-    names: Vec<String>,
-}
-
 pub trait Capitalize {
     fn capitalize(&self) -> String;
 }
@@ -225,180 +124,3 @@ impl Capitalize for str {
             })
     }
 }
-
-fn idle_string(when: i64) -> String {
-    thread_local! {
-        static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
-    }
-    NOW.with(|n| {
-        let duration = n.unix_timestamp() - when;
-        if duration < 60 {
-            // less than 1min
-            "     ".to_owned()
-        } else if duration < 24 * 3600 {
-            // less than 1day
-            let hours = duration / (60 * 60);
-            let minutes = (duration % (60 * 60)) / 60;
-            format!("{hours:02}:{minutes:02}")
-        } else {
-            // more than 1day
-            let days = duration / (24 * 3600);
-            format!("{days}d")
-        }
-    })
-}
-
-fn time_string(ut: &Utmpx) -> String {
-    // "%b %e %H:%M"
-    let time_format: Vec<time::format_description::FormatItem> =
-        time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
-            .unwrap();
-    ut.login_time().format(&time_format).unwrap() // LC_ALL=C
-}
-
-fn gecos_to_fullname(pw: &Passwd) -> Option<String> {
-    let mut gecos = if let Some(gecos) = &pw.user_info {
-        gecos.clone()
-    } else {
-        return None;
-    };
-    if let Some(n) = gecos.find(',') {
-        gecos.truncate(n);
-    }
-    Some(gecos.replace('&', &pw.name.capitalize()))
-}
-
-impl Pinky {
-    fn print_entry(&self, ut: &Utmpx) -> std::io::Result<()> {
-        let mut pts_path = PathBuf::from("/dev");
-        pts_path.push(ut.tty_device().as_str());
-
-        let mesg;
-        let last_change;
-
-        match pts_path.metadata() {
-            #[allow(clippy::unnecessary_cast)]
-            Ok(meta) => {
-                mesg = if meta.mode() & S_IWGRP as u32 == 0 {
-                    '*'
-                } else {
-                    ' '
-                };
-                last_change = meta.atime();
-            }
-            _ => {
-                mesg = '?';
-                last_change = 0;
-            }
-        }
-
-        print!("{1:<8.0$}", utmpx::UT_NAMESIZE, ut.user());
-
-        if self.include_fullname {
-            let fullname = if let Ok(pw) = Passwd::locate(ut.user().as_ref()) {
-                gecos_to_fullname(&pw)
-            } else {
-                None
-            };
-            if let Some(fullname) = fullname {
-                print!(" {fullname:<19.19}");
-            } else {
-                print!(" {:19}", "        ???");
-            }
-        }
-
-        print!(" {}{:<8.*}", mesg, utmpx::UT_LINESIZE, ut.tty_device());
-
-        if self.include_idle {
-            if last_change == 0 {
-                print!(" {:<6}", "?????");
-            } else {
-                print!(" {:<6}", idle_string(last_change));
-            }
-        }
-
-        print!(" {}", time_string(ut));
-
-        let mut s = ut.host();
-        if self.include_where && !s.is_empty() {
-            s = ut.canon_host()?;
-            print!(" {s}");
-        }
-
-        println!();
-        Ok(())
-    }
-
-    fn print_heading(&self) {
-        print!("{:<8}", "Login");
-        if self.include_fullname {
-            print!(" {:<19}", "Name");
-        }
-        print!(" {:<9}", " TTY");
-        if self.include_idle {
-            print!(" {:<6}", "Idle");
-        }
-        print!(" {:<16}", "When");
-        if self.include_where {
-            print!(" Where");
-        }
-        println!();
-    }
-
-    fn short_pinky(&self) -> std::io::Result<()> {
-        if self.include_heading {
-            self.print_heading();
-        }
-        for ut in Utmpx::iter_all_records() {
-            if ut.is_user_process()
-                && (self.names.is_empty() || self.names.iter().any(|n| n.as_str() == ut.user()))
-            {
-                self.print_entry(&ut)?;
-            }
-        }
-        Ok(())
-    }
-
-    fn long_pinky(&self) {
-        for u in &self.names {
-            print!("Login name: {u:<28}In real life: ");
-            if let Ok(pw) = Passwd::locate(u.as_str()) {
-                let fullname = gecos_to_fullname(&pw).unwrap_or_default();
-                let user_dir = pw.user_dir.unwrap_or_default();
-                let user_shell = pw.user_shell.unwrap_or_default();
-                println!(" {fullname}");
-                if self.include_home_and_shell {
-                    print!("Directory: {user_dir:<29}");
-                    println!("Shell:  {user_shell}");
-                }
-                if self.include_project {
-                    let mut p = PathBuf::from(&user_dir);
-                    p.push(".project");
-                    if let Ok(f) = File::open(p) {
-                        print!("Project: ");
-                        read_to_console(f);
-                    }
-                }
-                if self.include_plan {
-                    let mut p = PathBuf::from(&user_dir);
-                    p.push(".plan");
-                    if let Ok(f) = File::open(p) {
-                        println!("Plan:");
-                        read_to_console(f);
-                    }
-                }
-                println!();
-            } else {
-                println!(" ???");
-            }
-        }
-    }
-}
-
-fn read_to_console<F: Read>(f: F) {
-    let mut reader = BufReader::new(f);
-    let mut iobuf = Vec::new();
-    if reader.read_to_end(&mut iobuf).is_ok() {
-        print!("{}", String::from_utf8_lossy(&iobuf));
-    }
-}
diff --git a/src/uu/pinky/src/platform/mod.rs b/src/uu/pinky/src/platform/mod.rs
new file mode 100644
index 00000000000..e0e87dca1bf
--- /dev/null
+++ b/src/uu/pinky/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/pinky/src/platform/openbsd.rs b/src/uu/pinky/src/platform/openbsd.rs
new file mode 100644
index 00000000000..7e6970c1f09
--- /dev/null
+++ b/src/uu/pinky/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let _matches = uu_app().try_get_matches_from(args)?;
+
+    println!("unsupported command on OpenBSD");
+    Ok(())
+}
diff --git a/src/uu/pinky/src/platform/unix.rs b/src/uu/pinky/src/platform/unix.rs
new file mode 100644
index 00000000000..ecea2b9f29e
--- /dev/null
+++ b/src/uu/pinky/src/platform/unix.rs
@@ -0,0 +1,291 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (ToDO) BUFSIZE gecos fullname, mesg iobuf
+
+use crate::options;
+use crate::uu_app;
+use crate::Capitalize;
+
+use uucore::entries::{Locate, Passwd};
+use uucore::error::{FromIo, UResult};
+use uucore::libc::S_IWGRP;
+use uucore::utmpx::{self, time, Utmpx};
+
+use std::io::prelude::*;
+use std::io::BufReader;
+
+use std::fs::File;
+use std::os::unix::fs::MetadataExt;
+
+use std::path::PathBuf;
+
+fn get_long_usage() -> String {
+    format!(
+        "A lightweight 'finger' program;  print user information.\n\
+         The utmp file will be {}.",
+        utmpx::DEFAULT_FILE
+    )
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app()
+        .after_help(get_long_usage())
+        .try_get_matches_from(args)?;
+
+    let users: Vec<String> = matches
+        .get_many::<String>(options::USER)
+        .map(|v| v.map(ToString::to_string).collect())
+        .unwrap_or_default();
+
+    // If true, display the hours:minutes since each user has touched
+    // the keyboard, or blank if within the last minute, or days followed
+    // by a 'd' if not within the last day.
+    let mut include_idle = true;
+
+    // If true, display a line at the top describing each field.
+    let include_heading = !matches.get_flag(options::OMIT_HEADINGS);
+
+    // if true, display the user's full name from pw_gecos.
+    let mut include_fullname = true;
+
+    // if true, display the user's ~/.project file when doing long format.
+    let include_project = !matches.get_flag(options::OMIT_PROJECT_FILE);
+
+    // if true, display the user's ~/.plan file when doing long format.
+    let include_plan = !matches.get_flag(options::OMIT_PLAN_FILE);
+
+    // if true, display the user's home directory and shell
+    // when doing long format.
+    let include_home_and_shell = !matches.get_flag(options::OMIT_HOME_DIR);
+
+    // if true, use the "short" output format.
+    let do_short_format = !matches.get_flag(options::LONG_FORMAT);
+
+    /* if true, display the ut_host field. */
+    let mut include_where = true;
+
+    if matches.get_flag(options::OMIT_NAME) {
+        include_fullname = false;
+    }
+    if matches.get_flag(options::OMIT_NAME_HOST) {
+        include_fullname = false;
+        include_where = false;
+    }
+    if matches.get_flag(options::OMIT_NAME_HOST_TIME) {
+        include_fullname = false;
+        include_idle = false;
+        include_where = false;
+    }
+
+    let pk = Pinky {
+        include_idle,
+        include_heading,
+        include_fullname,
+        include_project,
+        include_plan,
+        include_home_and_shell,
+        include_where,
+        names: users,
+    };
+
+    if do_short_format {
+        match pk.short_pinky() {
+            Ok(_) => Ok(()),
+            Err(e) => Err(e.map_err_context(String::new)),
+        }
+    } else {
+        pk.long_pinky();
+        Ok(())
+    }
+}
+
+struct Pinky {
+    include_idle: bool,
+    include_heading: bool,
+    include_fullname: bool,
+    include_project: bool,
+    include_plan: bool,
+    include_where: bool,
+    include_home_and_shell: bool,
+    names: Vec<String>,
+}
+
+fn idle_string(when: i64) -> String {
+    thread_local! {
+        static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
+    }
+    NOW.with(|n| {
+        let duration = n.unix_timestamp() - when;
+        if duration < 60 {
+            // less than 1min
+            "     ".to_owned()
+        } else if duration < 24 * 3600 {
+            // less than 1day
+            let hours = duration / (60 * 60);
+            let minutes = (duration % (60 * 60)) / 60;
+            format!("{hours:02}:{minutes:02}")
+        } else {
+            // more than 1day
+            let days = duration / (24 * 3600);
+            format!("{days}d")
+        }
+    })
+}
+
+fn time_string(ut: &Utmpx) -> String {
+    // "%b %e %H:%M"
+    let time_format: Vec<time::format_description::FormatItem> =
+        time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
+            .unwrap();
+    ut.login_time().format(&time_format).unwrap() // LC_ALL=C
+}
+
+fn gecos_to_fullname(pw: &Passwd) -> Option<String> {
+    let mut gecos = if let Some(gecos) = &pw.user_info {
+        gecos.clone()
+    } else {
+        return None;
+    };
+    if let Some(n) = gecos.find(',') {
+        gecos.truncate(n);
+    }
+    Some(gecos.replace('&', &pw.name.capitalize()))
+}
+
+impl Pinky {
+    fn print_entry(&self, ut: &Utmpx) -> std::io::Result<()> {
+        let mut pts_path = PathBuf::from("/dev");
+        pts_path.push(ut.tty_device().as_str());
+
+        let mesg;
+        let last_change;
+
+        match pts_path.metadata() {
+            #[allow(clippy::unnecessary_cast)]
+            Ok(meta) => {
+                mesg = if meta.mode() & S_IWGRP as u32 == 0 {
+                    '*'
+                } else {
+                    ' '
+                };
+                last_change = meta.atime();
+            }
+            _ => {
+                mesg = '?';
+                last_change = 0;
+            }
+        }
+
+        print!("{1:<8.0$}", utmpx::UT_NAMESIZE, ut.user());
+
+        if self.include_fullname {
+            let fullname = if let Ok(pw) = Passwd::locate(ut.user().as_ref()) {
+                gecos_to_fullname(&pw)
+            } else {
+                None
+            };
+            if let Some(fullname) = fullname {
+                print!(" {fullname:<19.19}");
+            } else {
+                print!(" {:19}", "        ???");
+            }
+        }
+
+        print!(" {}{:<8.*}", mesg, utmpx::UT_LINESIZE, ut.tty_device());
+
+        if self.include_idle {
+            if last_change == 0 {
+                print!(" {:<6}", "?????");
+            } else {
+                print!(" {:<6}", idle_string(last_change));
+            }
+        }
+
+        print!(" {}", time_string(ut));
+
+        let mut s = ut.host();
+        if self.include_where && !s.is_empty() {
+            s = ut.canon_host()?;
+            print!(" {s}");
+        }
+
+        println!();
+        Ok(())
+    }
+
+    fn print_heading(&self) {
+        print!("{:<8}", "Login");
+        if self.include_fullname {
+            print!(" {:<19}", "Name");
+        }
+        print!(" {:<9}", " TTY");
+        if self.include_idle {
+            print!(" {:<6}", "Idle");
+        }
+        print!(" {:<16}", "When");
+        if self.include_where {
+            print!(" Where");
+        }
+        println!();
+    }
+
+    fn short_pinky(&self) -> std::io::Result<()> {
+        if self.include_heading {
+            self.print_heading();
+        }
+        for ut in Utmpx::iter_all_records() {
+            if ut.is_user_process()
+                && (self.names.is_empty() || self.names.iter().any(|n| n.as_str() == ut.user()))
+            {
+                self.print_entry(&ut)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn long_pinky(&self) {
+        for u in &self.names {
+            print!("Login name: {u:<28}In real life: ");
+            if let Ok(pw) = Passwd::locate(u.as_str()) {
+                let fullname = gecos_to_fullname(&pw).unwrap_or_default();
+                let user_dir = pw.user_dir.unwrap_or_default();
+                let user_shell = pw.user_shell.unwrap_or_default();
+                println!(" {fullname}");
+                if self.include_home_and_shell {
+                    print!("Directory: {user_dir:<29}");
+                    println!("Shell:  {user_shell}");
+                }
+                if self.include_project {
+                    let mut p = PathBuf::from(&user_dir);
+                    p.push(".project");
+                    if let Ok(f) = File::open(p) {
+                        print!("Project: ");
+                        read_to_console(f);
+                    }
+                }
+                if self.include_plan {
+                    let mut p = PathBuf::from(&user_dir);
+                    p.push(".plan");
+                    if let Ok(f) = File::open(p) {
+                        println!("Plan:");
+                        read_to_console(f);
+                    }
+                }
+                println!();
+            } else {
+                println!(" ???");
+            }
+        }
+    }
+}
+
+fn read_to_console<F: Read>(f: F) {
+    let mut reader = BufReader::new(f);
+    let mut iobuf = Vec::new();
+    if reader.read_to_end(&mut iobuf).is_ok() {
+        print!("{}", String::from_utf8_lossy(&iobuf));
+    }
+}
diff --git a/src/uu/pr/Cargo.toml b/src/uu/pr/Cargo.toml
index ab54593837f..4d09ad7afc8 100644
--- a/src/uu/pr/Cargo.toml
+++ b/src/uu/pr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_pr"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pr ~ (uutils) convert text files for printing"
diff --git a/src/uu/pr/pr.md b/src/uu/pr/pr.md
index 2c246b25f1c..cd2f552f3de 100644
--- a/src/uu/pr/pr.md
+++ b/src/uu/pr/pr.md
@@ -1,7 +1,7 @@
 # pr
 
 ```
-pr [OPTIONS] [files]...
+pr [OPTION]... [FILE]...
 ```
 
 Write content of given file or standard input to standard output with pagination filter
diff --git a/src/uu/printenv/Cargo.toml b/src/uu/printenv/Cargo.toml
index a6d7c91d046..32765a1f1e9 100644
--- a/src/uu/printenv/Cargo.toml
+++ b/src/uu/printenv/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_printenv"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "printenv ~ (uutils) display value of environment VAR"
diff --git a/src/uu/printenv/printenv.md b/src/uu/printenv/printenv.md
index 929da7947b5..f67d46a23dd 100644
--- a/src/uu/printenv/printenv.md
+++ b/src/uu/printenv/printenv.md
@@ -1,7 +1,7 @@
 # printenv
 
 ```
-printenv [VARIABLE]... [OPTION]...
+printenv [OPTION]... [VARIABLE]...
 ```
 
 Display the values of the specified environment VARIABLE(s), or (with no VARIABLE) display name and value pairs for them all.
diff --git a/src/uu/printf/Cargo.toml b/src/uu/printf/Cargo.toml
index 1cb05ec09b0..0033c31494b 100644
--- a/src/uu/printf/Cargo.toml
+++ b/src/uu/printf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_printf"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["Nathan Ross", "uutils developers"]
 license = "MIT"
 description = "printf ~ (uutils) FORMAT and display ARGUMENTS"
@@ -16,7 +16,7 @@ path = "src/printf.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["memo"] }
+uucore = { workspace = true, features = ["format", "quoting-style"] }
 
 [[bin]]
 name = "printf"
diff --git a/src/uu/printf/printf.md b/src/uu/printf/printf.md
index 9ce2957701e..fad5d01e30b 100644
--- a/src/uu/printf/printf.md
+++ b/src/uu/printf/printf.md
@@ -4,6 +4,8 @@
 
 ```
 printf FORMATSTRING [ARGUMENT]...
+printf FORMAT [ARGUMENT]...
+printf OPTION
 ```
 
 Print output based off of the format string and proceeding arguments.
diff --git a/src/uu/printf/src/printf.rs b/src/uu/printf/src/printf.rs
index a6205f7cb39..c98bb59a1e4 100644
--- a/src/uu/printf/src/printf.rs
+++ b/src/uu/printf/src/printf.rs
@@ -6,9 +6,12 @@
 // spell-checker:ignore (change!) each's
 // spell-checker:ignore (ToDO) LONGHELP FORMATSTRING templating parameterizing formatstr
 
+use std::io::stdout;
+use std::ops::ControlFlow;
+
 use clap::{crate_version, Arg, ArgAction, Command};
 use uucore::error::{UResult, UUsageError};
-use uucore::memo::printf;
+use uucore::format::{parse_spec_and_escape, FormatArgument, FormatItem};
 use uucore::{format_usage, help_about, help_section, help_usage};
 
 const VERSION: &str = "version";
@@ -24,18 +27,43 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
     let matches = uu_app().get_matches_from(args);
 
     let format_string = matches
         .get_one::<String>(options::FORMATSTRING)
         .ok_or_else(|| UUsageError::new(1, "missing operand"))?;
-    let values: Vec<String> = match matches.get_many::<String>(options::ARGUMENT) {
-        Some(s) => s.map(|s| s.to_string()).collect(),
+
+    let values: Vec<_> = match matches.get_many::<String>(options::ARGUMENT) {
+        Some(s) => s.map(|s| FormatArgument::Unparsed(s.to_string())).collect(),
         None => vec![],
     };
 
-    printf(format_string, &values[..])?;
+    let mut format_seen = false;
+    let mut args = values.iter().peekable();
+    for item in parse_spec_and_escape(format_string.as_ref()) {
+        if let Ok(FormatItem::Spec(_)) = item {
+            format_seen = true;
+        }
+        match item?.write(stdout(), &mut args)? {
+            ControlFlow::Continue(()) => {}
+            ControlFlow::Break(()) => return Ok(()),
+        };
+    }
+
+    // Without format specs in the string, the iter would not consume any args,
+    // leading to an infinite loop. Thus, we exit early.
+    if !format_seen {
+        return Ok(());
+    }
+
+    while args.peek().is_some() {
+        for item in parse_spec_and_escape(format_string.as_ref()) {
+            match item?.write(stdout(), &mut args)? {
+                ControlFlow::Continue(()) => {}
+                ControlFlow::Break(()) => return Ok(()),
+            };
+        }
+    }
     Ok(())
 }
 
diff --git a/src/uu/ptx/Cargo.toml b/src/uu/ptx/Cargo.toml
index 4ea395dc5cc..30bee8642b1 100644
--- a/src/uu/ptx/Cargo.toml
+++ b/src/uu/ptx/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_ptx"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "ptx ~ (uutils) display a permuted index of input"
diff --git a/src/uu/ptx/src/ptx.rs b/src/uu/ptx/src/ptx.rs
index 6dd2b2992e0..7caa8f4a5d4 100644
--- a/src/uu/ptx/src/ptx.rs
+++ b/src/uu/ptx/src/ptx.rs
@@ -715,8 +715,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let mut input_files: Vec<String> = match &matches.get_many::<String>(options::FILE) {
diff --git a/src/uu/pwd/Cargo.toml b/src/uu/pwd/Cargo.toml
index 8bd0ccece58..82cd4cf8ee1 100644
--- a/src/uu/pwd/Cargo.toml
+++ b/src/uu/pwd/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_pwd"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pwd ~ (uutils) display current working directory"
diff --git a/src/uu/readlink/Cargo.toml b/src/uu/readlink/Cargo.toml
index 4d1574c50be..cb17296129f 100644
--- a/src/uu/readlink/Cargo.toml
+++ b/src/uu/readlink/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_readlink"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "readlink ~ (uutils) display resolved path of PATHNAME"
diff --git a/src/uu/realpath/Cargo.toml b/src/uu/realpath/Cargo.toml
index 8b21d6c7f8d..942f9601640 100644
--- a/src/uu/realpath/Cargo.toml
+++ b/src/uu/realpath/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_realpath"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "realpath ~ (uutils) display resolved absolute path of PATHNAME"
diff --git a/src/uu/realpath/src/realpath.rs b/src/uu/realpath/src/realpath.rs
index 64806fbabf6..b099a5f377c 100644
--- a/src/uu/realpath/src/realpath.rs
+++ b/src/uu/realpath/src/realpath.rs
@@ -15,13 +15,13 @@ use std::{
 use uucore::fs::make_path_relative_to;
 use uucore::{
     display::{print_verbatim, Quotable},
-    error::{FromIo, UResult},
+    error::{FromIo, UClapError, UResult},
     format_usage,
     fs::{canonicalize, MissingHandling, ResolveMode},
     help_about, help_usage,
     line_ending::LineEnding,
+    show_if_err,
 };
-use uucore::{error::UClapError, show, show_if_err};
 
 static ABOUT: &str = help_about!("realpath.md");
 const USAGE: &str = help_usage!("realpath.md");
diff --git a/src/uu/rm/Cargo.toml b/src/uu/rm/Cargo.toml
index 34ada60e865..a36251838d5 100644
--- a/src/uu/rm/Cargo.toml
+++ b/src/uu/rm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_rm"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "rm ~ (uutils) remove PATHNAME"
diff --git a/src/uu/rm/src/rm.rs b/src/uu/rm/src/rm.rs
index 4fc37a1300f..a89ba6db67f 100644
--- a/src/uu/rm/src/rm.rs
+++ b/src/uu/rm/src/rm.rs
@@ -334,7 +334,7 @@ fn handle_dir(path: &Path, options: &Options) -> bool {
                 // remove_dir_all failed. maybe it is because of the permissions
                 // but if the directory is empty, remove_dir might work.
                 // So, let's try that before failing for real
-                if let Err(_e) = fs::remove_dir(path) {
+                if fs::remove_dir(path).is_err() {
                     had_err = true;
                     if e.kind() == std::io::ErrorKind::PermissionDenied {
                         // GNU compatibility (rm/fail-eacces.sh)
diff --git a/src/uu/rmdir/Cargo.toml b/src/uu/rmdir/Cargo.toml
index f17db50b0ee..e567b98b69d 100644
--- a/src/uu/rmdir/Cargo.toml
+++ b/src/uu/rmdir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_rmdir"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "rmdir ~ (uutils) remove empty DIRECTORY"
diff --git a/src/uu/runcon/Cargo.toml b/src/uu/runcon/Cargo.toml
index 72237ece95a..e22f2e9d1ca 100644
--- a/src/uu/runcon/Cargo.toml
+++ b/src/uu/runcon/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_runcon"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "runcon ~ (uutils) run command with specified security context"
diff --git a/src/uu/runcon/runcon.md b/src/uu/runcon/runcon.md
index 1911c50447c..155ea7dc0f7 100644
--- a/src/uu/runcon/runcon.md
+++ b/src/uu/runcon/runcon.md
@@ -2,7 +2,7 @@
 
 ```
 runcon [CONTEXT COMMAND [ARG...]]
-runcon [-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [ARG...]";
+runcon [-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [ARG...]
 ```
 
 Run command with specified security context under SELinux enabled systems.
diff --git a/src/uu/runcon/src/errors.rs b/src/uu/runcon/src/errors.rs
index 382ab3bed36..b2bfcad9598 100644
--- a/src/uu/runcon/src/errors.rs
+++ b/src/uu/runcon/src/errors.rs
@@ -87,7 +87,6 @@ where
         err = source;
         write!(writer, ": {err}")?;
     }
-    write!(writer, ".")?;
     Ok(())
 }
 
diff --git a/src/uu/seq/Cargo.toml b/src/uu/seq/Cargo.toml
index 95f761696c2..dca08f5d064 100644
--- a/src/uu/seq/Cargo.toml
+++ b/src/uu/seq/Cargo.toml
@@ -1,7 +1,7 @@
 # spell-checker:ignore bigdecimal
 [package]
 name = "uu_seq"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "seq ~ (uutils) display a sequence of numbers"
@@ -20,7 +20,7 @@ bigdecimal = { workspace = true }
 clap = { workspace = true }
 num-bigint = { workspace = true }
 num-traits = { workspace = true }
-uucore = { workspace = true, features = ["memo"] }
+uucore = { workspace = true, features = ["format", "quoting-style"] }
 
 [[bin]]
 name = "seq"
diff --git a/src/uu/seq/src/extendedbigdecimal.rs b/src/uu/seq/src/extendedbigdecimal.rs
index 388046ba368..4f9a0415218 100644
--- a/src/uu/seq/src/extendedbigdecimal.rs
+++ b/src/uu/seq/src/extendedbigdecimal.rs
@@ -25,13 +25,8 @@ use std::fmt::Display;
 use std::ops::Add;
 
 use bigdecimal::BigDecimal;
-use num_bigint::BigInt;
-use num_bigint::ToBigInt;
-use num_traits::One;
 use num_traits::Zero;
 
-use crate::extendedbigint::ExtendedBigInt;
-
 #[derive(Debug, Clone)]
 pub enum ExtendedBigDecimal {
     /// Arbitrary precision floating point number.
@@ -72,53 +67,14 @@ pub enum ExtendedBigDecimal {
     Nan,
 }
 
-/// The smallest integer greater than or equal to this number.
-fn ceil(x: BigDecimal) -> BigInt {
-    if x.is_integer() {
-        // Unwrapping the Option because it always returns Some
-        x.to_bigint().unwrap()
-    } else {
-        (x + BigDecimal::one().half()).round(0).to_bigint().unwrap()
-    }
-}
-
-/// The largest integer less than or equal to this number.
-fn floor(x: BigDecimal) -> BigInt {
-    if x.is_integer() {
-        // Unwrapping the Option because it always returns Some
-        x.to_bigint().unwrap()
-    } else {
-        (x - BigDecimal::one().half()).round(0).to_bigint().unwrap()
-    }
-}
-
 impl ExtendedBigDecimal {
-    /// The smallest integer greater than or equal to this number.
-    pub fn ceil(self) -> ExtendedBigInt {
-        match self {
-            Self::BigDecimal(x) => ExtendedBigInt::BigInt(ceil(x)),
-            other => From::from(other),
-        }
+    #[cfg(test)]
+    pub fn zero() -> Self {
+        Self::BigDecimal(0.into())
     }
 
-    /// The largest integer less than or equal to this number.
-    pub fn floor(self) -> ExtendedBigInt {
-        match self {
-            Self::BigDecimal(x) => ExtendedBigInt::BigInt(floor(x)),
-            other => From::from(other),
-        }
-    }
-}
-
-impl From<ExtendedBigInt> for ExtendedBigDecimal {
-    fn from(big_int: ExtendedBigInt) -> Self {
-        match big_int {
-            ExtendedBigInt::BigInt(n) => Self::BigDecimal(BigDecimal::from(n)),
-            ExtendedBigInt::Infinity => Self::Infinity,
-            ExtendedBigInt::MinusInfinity => Self::MinusInfinity,
-            ExtendedBigInt::MinusZero => Self::MinusZero,
-            ExtendedBigInt::Nan => Self::Nan,
-        }
+    pub fn one() -> Self {
+        Self::BigDecimal(1.into())
     }
 }
 
diff --git a/src/uu/seq/src/extendedbigint.rs b/src/uu/seq/src/extendedbigint.rs
deleted file mode 100644
index 6828fba2df2..00000000000
--- a/src/uu/seq/src/extendedbigint.rs
+++ /dev/null
@@ -1,214 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore bigint extendedbigint extendedbigdecimal
-//! An arbitrary precision integer that can also represent infinity, NaN, etc.
-//!
-//! Usually infinity, NaN, and negative zero are only represented for
-//! floating point numbers. The [`ExtendedBigInt`] enumeration provides
-//! a representation of those things with the set of integers. The
-//! finite values are stored as [`BigInt`] instances.
-//!
-//! # Examples
-//!
-//! Addition works for [`ExtendedBigInt`] as it does for floats. For
-//! example, adding infinity to any finite value results in infinity:
-//!
-//! ```rust,ignore
-//! let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
-//! let summand2 = ExtendedBigInt::Infinity;
-//! assert_eq!(summand1 + summand2, ExtendedBigInt::Infinity);
-//! ```
-use std::cmp::Ordering;
-use std::fmt::Display;
-use std::ops::Add;
-
-use num_bigint::BigInt;
-use num_bigint::ToBigInt;
-use num_traits::One;
-use num_traits::Zero;
-
-use crate::extendedbigdecimal::ExtendedBigDecimal;
-
-#[derive(Debug, Clone)]
-pub enum ExtendedBigInt {
-    BigInt(BigInt),
-    Infinity,
-    MinusInfinity,
-    MinusZero,
-    Nan,
-}
-
-impl ExtendedBigInt {
-    /// The integer number one.
-    pub fn one() -> Self {
-        // We would like to implement `num_traits::One`, but it requires
-        // a multiplication implementation, and we don't want to
-        // implement that here.
-        Self::BigInt(BigInt::one())
-    }
-}
-
-impl From<ExtendedBigDecimal> for ExtendedBigInt {
-    fn from(big_decimal: ExtendedBigDecimal) -> Self {
-        match big_decimal {
-            // TODO When can this fail?
-            ExtendedBigDecimal::BigDecimal(x) => Self::BigInt(x.to_bigint().unwrap()),
-            ExtendedBigDecimal::Infinity => Self::Infinity,
-            ExtendedBigDecimal::MinusInfinity => Self::MinusInfinity,
-            ExtendedBigDecimal::MinusZero => Self::MinusZero,
-            ExtendedBigDecimal::Nan => Self::Nan,
-        }
-    }
-}
-
-impl Display for ExtendedBigInt {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::BigInt(n) => n.fmt(f),
-            Self::Infinity => f32::INFINITY.fmt(f),
-            Self::MinusInfinity => f32::NEG_INFINITY.fmt(f),
-            Self::MinusZero => "-0".fmt(f),
-            Self::Nan => "nan".fmt(f),
-        }
-    }
-}
-
-impl Zero for ExtendedBigInt {
-    fn zero() -> Self {
-        Self::BigInt(BigInt::zero())
-    }
-    fn is_zero(&self) -> bool {
-        match self {
-            Self::BigInt(n) => n.is_zero(),
-            Self::MinusZero => true,
-            _ => false,
-        }
-    }
-}
-
-impl Add for ExtendedBigInt {
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self {
-        match (self, other) {
-            (Self::BigInt(m), Self::BigInt(n)) => Self::BigInt(m.add(n)),
-            (Self::BigInt(_), Self::MinusInfinity) => Self::MinusInfinity,
-            (Self::BigInt(_), Self::Infinity) => Self::Infinity,
-            (Self::BigInt(_), Self::Nan) => Self::Nan,
-            (Self::BigInt(m), Self::MinusZero) => Self::BigInt(m),
-            (Self::Infinity, Self::BigInt(_)) => Self::Infinity,
-            (Self::Infinity, Self::Infinity) => Self::Infinity,
-            (Self::Infinity, Self::MinusZero) => Self::Infinity,
-            (Self::Infinity, Self::MinusInfinity) => Self::Nan,
-            (Self::Infinity, Self::Nan) => Self::Nan,
-            (Self::MinusInfinity, Self::BigInt(_)) => Self::MinusInfinity,
-            (Self::MinusInfinity, Self::MinusInfinity) => Self::MinusInfinity,
-            (Self::MinusInfinity, Self::MinusZero) => Self::MinusInfinity,
-            (Self::MinusInfinity, Self::Infinity) => Self::Nan,
-            (Self::MinusInfinity, Self::Nan) => Self::Nan,
-            (Self::Nan, _) => Self::Nan,
-            (Self::MinusZero, other) => other,
-        }
-    }
-}
-
-impl PartialEq for ExtendedBigInt {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::BigInt(m), Self::BigInt(n)) => m.eq(n),
-            (Self::BigInt(_), Self::MinusInfinity) => false,
-            (Self::BigInt(_), Self::Infinity) => false,
-            (Self::BigInt(_), Self::Nan) => false,
-            (Self::BigInt(_), Self::MinusZero) => false,
-            (Self::Infinity, Self::BigInt(_)) => false,
-            (Self::Infinity, Self::Infinity) => true,
-            (Self::Infinity, Self::MinusZero) => false,
-            (Self::Infinity, Self::MinusInfinity) => false,
-            (Self::Infinity, Self::Nan) => false,
-            (Self::MinusInfinity, Self::BigInt(_)) => false,
-            (Self::MinusInfinity, Self::Infinity) => false,
-            (Self::MinusInfinity, Self::MinusZero) => false,
-            (Self::MinusInfinity, Self::MinusInfinity) => true,
-            (Self::MinusInfinity, Self::Nan) => false,
-            (Self::Nan, _) => false,
-            (Self::MinusZero, Self::BigInt(_)) => false,
-            (Self::MinusZero, Self::Infinity) => false,
-            (Self::MinusZero, Self::MinusZero) => true,
-            (Self::MinusZero, Self::MinusInfinity) => false,
-            (Self::MinusZero, Self::Nan) => false,
-        }
-    }
-}
-
-impl PartialOrd for ExtendedBigInt {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        match (self, other) {
-            (Self::BigInt(m), Self::BigInt(n)) => m.partial_cmp(n),
-            (Self::BigInt(_), Self::MinusInfinity) => Some(Ordering::Greater),
-            (Self::BigInt(_), Self::Infinity) => Some(Ordering::Less),
-            (Self::BigInt(_), Self::Nan) => None,
-            (Self::BigInt(m), Self::MinusZero) => m.partial_cmp(&BigInt::zero()),
-            (Self::Infinity, Self::BigInt(_)) => Some(Ordering::Greater),
-            (Self::Infinity, Self::Infinity) => Some(Ordering::Equal),
-            (Self::Infinity, Self::MinusZero) => Some(Ordering::Greater),
-            (Self::Infinity, Self::MinusInfinity) => Some(Ordering::Greater),
-            (Self::Infinity, Self::Nan) => None,
-            (Self::MinusInfinity, Self::BigInt(_)) => Some(Ordering::Less),
-            (Self::MinusInfinity, Self::Infinity) => Some(Ordering::Less),
-            (Self::MinusInfinity, Self::MinusZero) => Some(Ordering::Less),
-            (Self::MinusInfinity, Self::MinusInfinity) => Some(Ordering::Equal),
-            (Self::MinusInfinity, Self::Nan) => None,
-            (Self::Nan, _) => None,
-            (Self::MinusZero, Self::BigInt(n)) => BigInt::zero().partial_cmp(n),
-            (Self::MinusZero, Self::Infinity) => Some(Ordering::Less),
-            (Self::MinusZero, Self::MinusZero) => Some(Ordering::Equal),
-            (Self::MinusZero, Self::MinusInfinity) => Some(Ordering::Greater),
-            (Self::MinusZero, Self::Nan) => None,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use num_bigint::BigInt;
-    use num_traits::Zero;
-
-    use crate::extendedbigint::ExtendedBigInt;
-
-    #[test]
-    fn test_addition_infinity() {
-        let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
-        let summand2 = ExtendedBigInt::Infinity;
-        assert_eq!(summand1 + summand2, ExtendedBigInt::Infinity);
-    }
-
-    #[test]
-    fn test_addition_minus_infinity() {
-        let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
-        let summand2 = ExtendedBigInt::MinusInfinity;
-        assert_eq!(summand1 + summand2, ExtendedBigInt::MinusInfinity);
-    }
-
-    #[test]
-    fn test_addition_nan() {
-        let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
-        let summand2 = ExtendedBigInt::Nan;
-        let sum = summand1 + summand2;
-        match sum {
-            ExtendedBigInt::Nan => (),
-            _ => unreachable!(),
-        }
-    }
-
-    #[test]
-    fn test_display() {
-        assert_eq!(format!("{}", ExtendedBigInt::BigInt(BigInt::zero())), "0");
-        assert_eq!(format!("{}", ExtendedBigInt::MinusZero), "-0");
-        assert_eq!(format!("{}", ExtendedBigInt::Infinity), "inf");
-        assert_eq!(format!("{}", ExtendedBigInt::MinusInfinity), "-inf");
-        assert_eq!(format!("{}", ExtendedBigInt::Nan), "nan");
-    }
-}
diff --git a/src/uu/seq/src/number.rs b/src/uu/seq/src/number.rs
index 85bc327ff46..314c842ba15 100644
--- a/src/uu/seq/src/number.rs
+++ b/src/uu/seq/src/number.rs
@@ -2,80 +2,10 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore extendedbigdecimal extendedbigint
-//! A type to represent the possible start, increment, and end values for seq.
-//!
-//! The [`Number`] enumeration represents the possible values for the
-//! start, increment, and end values for `seq`. These may be integers,
-//! floating point numbers, negative zero, etc. A [`Number`] can be
-//! parsed from a string by calling [`str::parse`].
+// spell-checker:ignore extendedbigdecimal
 use num_traits::Zero;
 
 use crate::extendedbigdecimal::ExtendedBigDecimal;
-use crate::extendedbigint::ExtendedBigInt;
-
-/// An integral or floating point number.
-#[derive(Debug, PartialEq)]
-pub enum Number {
-    Int(ExtendedBigInt),
-    Float(ExtendedBigDecimal),
-}
-
-impl Number {
-    /// Decide whether this number is zero (either positive or negative).
-    pub fn is_zero(&self) -> bool {
-        // We would like to implement `num_traits::Zero`, but it
-        // requires an addition implementation, and we don't want to
-        // implement that here.
-        match self {
-            Self::Int(n) => n.is_zero(),
-            Self::Float(x) => x.is_zero(),
-        }
-    }
-
-    /// Convert this number into an `ExtendedBigDecimal`.
-    pub fn into_extended_big_decimal(self) -> ExtendedBigDecimal {
-        match self {
-            Self::Int(n) => ExtendedBigDecimal::from(n),
-            Self::Float(x) => x,
-        }
-    }
-
-    /// The integer number one.
-    pub fn one() -> Self {
-        // We would like to implement `num_traits::One`, but it requires
-        // a multiplication implementation, and we don't want to
-        // implement that here.
-        Self::Int(ExtendedBigInt::one())
-    }
-
-    /// Round this number towards the given other number.
-    ///
-    /// If `other` is greater, then round up. If `other` is smaller,
-    /// then round down.
-    pub fn round_towards(self, other: &ExtendedBigInt) -> ExtendedBigInt {
-        match self {
-            // If this number is already an integer, it is already
-            // rounded to the nearest integer in the direction of
-            // `other`.
-            Self::Int(num) => num,
-            // Otherwise, if this number is a float, we need to decide
-            // whether `other` is larger or smaller than it, and thus
-            // whether to round up or round down, respectively.
-            Self::Float(num) => {
-                let other: ExtendedBigDecimal = From::from(other.clone());
-                if other > num {
-                    num.ceil()
-                } else {
-                    // If they are equal, then `self` is already an
-                    // integer, so calling `floor()` does no harm and
-                    // will just return that integer anyway.
-                    num.floor()
-                }
-            }
-        }
-    }
-}
 
 /// A number with a specified number of integer and fractional digits.
 ///
@@ -87,13 +17,17 @@ impl Number {
 /// You can get an instance of this struct by calling [`str::parse`].
 #[derive(Debug)]
 pub struct PreciseNumber {
-    pub number: Number,
+    pub number: ExtendedBigDecimal,
     pub num_integral_digits: usize,
     pub num_fractional_digits: usize,
 }
 
 impl PreciseNumber {
-    pub fn new(number: Number, num_integral_digits: usize, num_fractional_digits: usize) -> Self {
+    pub fn new(
+        number: ExtendedBigDecimal,
+        num_integral_digits: usize,
+        num_fractional_digits: usize,
+    ) -> Self {
         Self {
             number,
             num_integral_digits,
@@ -106,7 +40,7 @@ impl PreciseNumber {
         // We would like to implement `num_traits::One`, but it requires
         // a multiplication implementation, and we don't want to
         // implement that here.
-        Self::new(Number::one(), 1, 0)
+        Self::new(ExtendedBigDecimal::one(), 1, 0)
     }
 
     /// Decide whether this number is zero (either positive or negative).
diff --git a/src/uu/seq/src/numberparse.rs b/src/uu/seq/src/numberparse.rs
index 3f4b213955f..df7c1f7d1dd 100644
--- a/src/uu/seq/src/numberparse.rs
+++ b/src/uu/seq/src/numberparse.rs
@@ -2,7 +2,7 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore extendedbigdecimal extendedbigint bigdecimal numberparse
+// spell-checker:ignore extendedbigdecimal bigdecimal numberparse
 //! Parsing numbers for use in `seq`.
 //!
 //! This module provides an implementation of [`FromStr`] for the
@@ -16,8 +16,6 @@ use num_traits::Num;
 use num_traits::Zero;
 
 use crate::extendedbigdecimal::ExtendedBigDecimal;
-use crate::extendedbigint::ExtendedBigInt;
-use crate::number::Number;
 use crate::number::PreciseNumber;
 
 /// An error returned when parsing a number fails.
@@ -29,8 +27,8 @@ pub enum ParseNumberError {
 }
 
 /// Decide whether a given string and its parsed `BigInt` is negative zero.
-fn is_minus_zero_int(s: &str, n: &BigInt) -> bool {
-    s.starts_with('-') && n == &BigInt::zero()
+fn is_minus_zero_int(s: &str, n: &BigDecimal) -> bool {
+    s.starts_with('-') && n == &BigDecimal::zero()
 }
 
 /// Decide whether a given string and its parsed `BigDecimal` is negative zero.
@@ -53,19 +51,19 @@ fn is_minus_zero_float(s: &str, x: &BigDecimal) -> bool {
 /// assert_eq!(actual, expected);
 /// ```
 fn parse_no_decimal_no_exponent(s: &str) -> Result<PreciseNumber, ParseNumberError> {
-    match s.parse::<BigInt>() {
+    match s.parse::<BigDecimal>() {
         Ok(n) => {
             // If `s` is '-0', then `parse()` returns `BigInt::zero()`,
             // but we need to return `Number::MinusZeroInt` instead.
             if is_minus_zero_int(s, &n) {
                 Ok(PreciseNumber::new(
-                    Number::Int(ExtendedBigInt::MinusZero),
+                    ExtendedBigDecimal::MinusZero,
                     s.len(),
                     0,
                 ))
             } else {
                 Ok(PreciseNumber::new(
-                    Number::Int(ExtendedBigInt::BigInt(n)),
+                    ExtendedBigDecimal::BigDecimal(n),
                     s.len(),
                     0,
                 ))
@@ -79,7 +77,7 @@ fn parse_no_decimal_no_exponent(s: &str) -> Result<PreciseNumber, ParseNumberErr
                 "nan" | "-nan" => return Err(ParseNumberError::Nan),
                 _ => return Err(ParseNumberError::Float),
             };
-            Ok(PreciseNumber::new(Number::Float(float_val), 0, 0))
+            Ok(PreciseNumber::new(float_val, 0, 0))
         }
     }
 }
@@ -125,13 +123,13 @@ fn parse_exponent_no_decimal(s: &str, j: usize) -> Result<PreciseNumber, ParseNu
     if exponent < 0 {
         if is_minus_zero_float(s, &x) {
             Ok(PreciseNumber::new(
-                Number::Float(ExtendedBigDecimal::MinusZero),
+                ExtendedBigDecimal::MinusZero,
                 num_integral_digits,
                 num_fractional_digits,
             ))
         } else {
             Ok(PreciseNumber::new(
-                Number::Float(ExtendedBigDecimal::BigDecimal(x)),
+                ExtendedBigDecimal::BigDecimal(x),
                 num_integral_digits,
                 num_fractional_digits,
             ))
@@ -169,13 +167,13 @@ fn parse_decimal_no_exponent(s: &str, i: usize) -> Result<PreciseNumber, ParseNu
     let num_fractional_digits = s.len() - (i + 1);
     if is_minus_zero_float(s, &x) {
         Ok(PreciseNumber::new(
-            Number::Float(ExtendedBigDecimal::MinusZero),
+            ExtendedBigDecimal::MinusZero,
             num_integral_digits,
             num_fractional_digits,
         ))
     } else {
         Ok(PreciseNumber::new(
-            Number::Float(ExtendedBigDecimal::BigDecimal(x)),
+            ExtendedBigDecimal::BigDecimal(x),
             num_integral_digits,
             num_fractional_digits,
         ))
@@ -239,7 +237,7 @@ fn parse_decimal_and_exponent(
     if num_digits_between_decimal_point_and_e <= exponent {
         if is_minus_zero_float(s, &val) {
             Ok(PreciseNumber::new(
-                Number::Int(ExtendedBigInt::MinusZero),
+                ExtendedBigDecimal::MinusZero,
                 num_integral_digits,
                 num_fractional_digits,
             ))
@@ -251,23 +249,23 @@ fn parse_decimal_and_exponent(
             );
             let expanded = [&s[0..i], &s[i + 1..j], &zeros].concat();
             let n = expanded
-                .parse::<BigInt>()
+                .parse::<BigDecimal>()
                 .map_err(|_| ParseNumberError::Float)?;
             Ok(PreciseNumber::new(
-                Number::Int(ExtendedBigInt::BigInt(n)),
+                ExtendedBigDecimal::BigDecimal(n),
                 num_integral_digits,
                 num_fractional_digits,
             ))
         }
     } else if is_minus_zero_float(s, &val) {
         Ok(PreciseNumber::new(
-            Number::Float(ExtendedBigDecimal::MinusZero),
+            ExtendedBigDecimal::MinusZero,
             num_integral_digits,
             num_fractional_digits,
         ))
     } else {
         Ok(PreciseNumber::new(
-            Number::Float(ExtendedBigDecimal::BigDecimal(val)),
+            ExtendedBigDecimal::BigDecimal(val),
             num_integral_digits,
             num_fractional_digits,
         ))
@@ -303,20 +301,17 @@ fn parse_hexadecimal(s: &str) -> Result<PreciseNumber, ParseNumberError> {
     }
 
     let num = BigInt::from_str_radix(s, 16).map_err(|_| ParseNumberError::Hex)?;
+    let num = BigDecimal::from(num);
 
-    match (is_neg, num == BigInt::zero()) {
-        (true, true) => Ok(PreciseNumber::new(
-            Number::Int(ExtendedBigInt::MinusZero),
-            2,
-            0,
-        )),
+    match (is_neg, num == BigDecimal::zero()) {
+        (true, true) => Ok(PreciseNumber::new(ExtendedBigDecimal::MinusZero, 2, 0)),
         (true, false) => Ok(PreciseNumber::new(
-            Number::Int(ExtendedBigInt::BigInt(-num)),
+            ExtendedBigDecimal::BigDecimal(-num),
             0,
             0,
         )),
         (false, _) => Ok(PreciseNumber::new(
-            Number::Int(ExtendedBigInt::BigInt(num)),
+            ExtendedBigDecimal::BigDecimal(num),
             0,
             0,
         )),
@@ -364,19 +359,14 @@ impl FromStr for PreciseNumber {
 
 #[cfg(test)]
 mod tests {
-
     use bigdecimal::BigDecimal;
-    use num_bigint::BigInt;
-    use num_traits::Zero;
 
     use crate::extendedbigdecimal::ExtendedBigDecimal;
-    use crate::extendedbigint::ExtendedBigInt;
-    use crate::number::Number;
     use crate::number::PreciseNumber;
     use crate::numberparse::ParseNumberError;
 
     /// Convenience function for parsing a [`Number`] and unwrapping.
-    fn parse(s: &str) -> Number {
+    fn parse(s: &str) -> ExtendedBigDecimal {
         s.parse::<PreciseNumber>().unwrap().number
     }
 
@@ -392,40 +382,37 @@ mod tests {
 
     #[test]
     fn test_parse_minus_zero_int() {
-        assert_eq!(parse("-0e0"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0e-0"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0e1"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0e+1"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0.0e1"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0x0"), Number::Int(ExtendedBigInt::MinusZero));
+        assert_eq!(parse("-0e0"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0e-0"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0e1"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0e+1"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0.0e1"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0x0"), ExtendedBigDecimal::MinusZero);
     }
 
     #[test]
     fn test_parse_minus_zero_float() {
-        assert_eq!(parse("-0.0"), Number::Float(ExtendedBigDecimal::MinusZero));
-        assert_eq!(parse("-0e-1"), Number::Float(ExtendedBigDecimal::MinusZero));
-        assert_eq!(
-            parse("-0.0e-1"),
-            Number::Float(ExtendedBigDecimal::MinusZero)
-        );
+        assert_eq!(parse("-0.0"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0e-1"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0.0e-1"), ExtendedBigDecimal::MinusZero);
     }
 
     #[test]
     fn test_parse_big_int() {
-        assert_eq!(parse("0"), Number::Int(ExtendedBigInt::zero()));
-        assert_eq!(parse("0.1e1"), Number::Int(ExtendedBigInt::one()));
+        assert_eq!(parse("0"), ExtendedBigDecimal::zero());
+        assert_eq!(parse("0.1e1"), ExtendedBigDecimal::one());
         assert_eq!(
             parse("1.0e1"),
-            Number::Int(ExtendedBigInt::BigInt("10".parse::<BigInt>().unwrap()))
+            ExtendedBigDecimal::BigDecimal("10".parse::<BigDecimal>().unwrap())
         );
     }
 
     #[test]
     fn test_parse_hexadecimal_big_int() {
-        assert_eq!(parse("0x0"), Number::Int(ExtendedBigInt::zero()));
+        assert_eq!(parse("0x0"), ExtendedBigDecimal::zero());
         assert_eq!(
             parse("0x10"),
-            Number::Int(ExtendedBigInt::BigInt("16".parse::<BigInt>().unwrap()))
+            ExtendedBigDecimal::BigDecimal("16".parse::<BigDecimal>().unwrap())
         );
     }
 
@@ -433,56 +420,34 @@ mod tests {
     fn test_parse_big_decimal() {
         assert_eq!(
             parse("0.0"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "0.0".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("0.0".parse::<BigDecimal>().unwrap())
         );
         assert_eq!(
             parse(".0"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "0.0".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("0.0".parse::<BigDecimal>().unwrap())
         );
         assert_eq!(
             parse("1.0"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "1.0".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("1.0".parse::<BigDecimal>().unwrap())
         );
         assert_eq!(
             parse("10e-1"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "1.0".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("1.0".parse::<BigDecimal>().unwrap())
         );
         assert_eq!(
             parse("-1e-3"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "-0.001".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("-0.001".parse::<BigDecimal>().unwrap())
         );
     }
 
     #[test]
     fn test_parse_inf() {
-        assert_eq!(parse("inf"), Number::Float(ExtendedBigDecimal::Infinity));
-        assert_eq!(
-            parse("infinity"),
-            Number::Float(ExtendedBigDecimal::Infinity)
-        );
-        assert_eq!(parse("+inf"), Number::Float(ExtendedBigDecimal::Infinity));
-        assert_eq!(
-            parse("+infinity"),
-            Number::Float(ExtendedBigDecimal::Infinity)
-        );
-        assert_eq!(
-            parse("-inf"),
-            Number::Float(ExtendedBigDecimal::MinusInfinity)
-        );
-        assert_eq!(
-            parse("-infinity"),
-            Number::Float(ExtendedBigDecimal::MinusInfinity)
-        );
+        assert_eq!(parse("inf"), ExtendedBigDecimal::Infinity);
+        assert_eq!(parse("infinity"), ExtendedBigDecimal::Infinity);
+        assert_eq!(parse("+inf"), ExtendedBigDecimal::Infinity);
+        assert_eq!(parse("+infinity"), ExtendedBigDecimal::Infinity);
+        assert_eq!(parse("-inf"), ExtendedBigDecimal::MinusInfinity);
+        assert_eq!(parse("-infinity"), ExtendedBigDecimal::MinusInfinity);
     }
 
     #[test]
diff --git a/src/uu/seq/src/seq.rs b/src/uu/seq/src/seq.rs
index 4f04b377eae..33b7636edbc 100644
--- a/src/uu/seq/src/seq.rs
+++ b/src/uu/seq/src/seq.rs
@@ -2,28 +2,22 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (ToDO) istr chiter argptr ilen extendedbigdecimal extendedbigint numberparse
+// spell-checker:ignore (ToDO) extendedbigdecimal numberparse
 use std::io::{stdout, ErrorKind, Write};
-use std::process::exit;
 
 use clap::{crate_version, Arg, ArgAction, Command};
-use num_traits::Zero;
+use num_traits::{ToPrimitive, Zero};
 
-use uucore::error::FromIo;
-use uucore::error::UResult;
-use uucore::memo::printf;
-use uucore::show;
+use uucore::error::{FromIo, UResult};
+use uucore::format::{num_format, Format};
 use uucore::{format_usage, help_about, help_usage};
 
 mod error;
 mod extendedbigdecimal;
-mod extendedbigint;
 mod number;
 mod numberparse;
 use crate::error::SeqError;
 use crate::extendedbigdecimal::ExtendedBigDecimal;
-use crate::extendedbigint::ExtendedBigInt;
-use crate::number::Number;
 use crate::number::PreciseNumber;
 
 const ABOUT: &str = help_about!("seq.md");
@@ -44,11 +38,6 @@ struct SeqOptions<'a> {
     format: Option<&'a str>,
 }
 
-/// A range of integers.
-///
-/// The elements are (first, increment, last).
-type RangeInt = (ExtendedBigInt, ExtendedBigInt, ExtendedBigInt);
-
 /// A range of floats.
 ///
 /// The elements are (first, increment, last).
@@ -119,32 +108,22 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .num_fractional_digits
         .max(increment.num_fractional_digits);
 
-    let result = match (first.number, increment.number, last.number) {
-        (Number::Int(first), Number::Int(increment), last) => {
-            let last = last.round_towards(&first);
-            print_seq_integers(
-                (first, increment, last),
-                &options.separator,
-                &options.terminator,
-                options.equal_width,
-                padding,
-                options.format,
-            )
+    let format = match options.format {
+        Some(f) => {
+            let f = Format::<num_format::Float>::parse(f)?;
+            Some(f)
         }
-        (first, increment, last) => print_seq(
-            (
-                first.into_extended_big_decimal(),
-                increment.into_extended_big_decimal(),
-                last.into_extended_big_decimal(),
-            ),
-            largest_dec,
-            &options.separator,
-            &options.terminator,
-            options.equal_width,
-            padding,
-            options.format,
-        ),
+        None => None,
     };
+    let result = print_seq(
+        (first.number, increment.number, last.number),
+        largest_dec,
+        &options.separator,
+        &options.terminator,
+        options.equal_width,
+        padding,
+        &format,
+    );
     match result {
         Ok(_) => Ok(()),
         Err(err) if err.kind() == ErrorKind::BrokenPipe => Ok(()),
@@ -216,28 +195,6 @@ fn write_value_float(
     write!(writer, "{value_as_str}")
 }
 
-/// Write a big int formatted according to the given parameters.
-fn write_value_int(
-    writer: &mut impl Write,
-    value: &ExtendedBigInt,
-    width: usize,
-    pad: bool,
-) -> std::io::Result<()> {
-    let value_as_str = if pad {
-        if *value == ExtendedBigInt::MinusZero {
-            format!("{value:0<width$}")
-        } else {
-            format!("{value:>0width$}")
-        }
-    } else {
-        format!("{value}")
-    };
-    write!(writer, "{value_as_str}")
-}
-
-// TODO `print_seq()` and `print_seq_integers()` are nearly identical,
-// they could be refactored into a single more general function.
-
 /// Floating point based code path
 fn print_seq(
     range: RangeFloat,
@@ -246,13 +203,17 @@ fn print_seq(
     terminator: &str,
     pad: bool,
     padding: usize,
-    format: Option<&str>,
+    format: &Option<Format<num_format::Float>>,
 ) -> std::io::Result<()> {
     let stdout = stdout();
     let mut stdout = stdout.lock();
     let (first, increment, last) = range;
     let mut value = first;
-    let padding = if pad { padding + 1 + largest_dec } else { 0 };
+    let padding = if pad {
+        padding + if largest_dec > 0 { largest_dec + 1 } else { 0 }
+    } else {
+        0
+    };
     let mut is_first_iteration = true;
     while !done_printing(&value, &increment, &last) {
         if !is_first_iteration {
@@ -270,13 +231,16 @@ fn print_seq(
         // it as a string and ultimately writing to `stdout`. We
         // shouldn't have to do so much converting back and forth via
         // strings.
-        match format {
+        match &format {
             Some(f) => {
-                let s = format!("{value}");
-                if let Err(x) = printf(f, &[s]) {
-                    show!(x);
-                    exit(1);
-                }
+                let float = match &value {
+                    ExtendedBigDecimal::BigDecimal(bd) => bd.to_f64().unwrap(),
+                    ExtendedBigDecimal::Infinity => f64::INFINITY,
+                    ExtendedBigDecimal::MinusInfinity => f64::NEG_INFINITY,
+                    ExtendedBigDecimal::MinusZero => -0.0,
+                    ExtendedBigDecimal::Nan => f64::NAN,
+                };
+                f.fmt(&mut stdout, float)?;
             }
             None => write_value_float(&mut stdout, &value, padding, largest_dec)?,
         }
@@ -290,62 +254,3 @@ fn print_seq(
     stdout.flush()?;
     Ok(())
 }
-
-/// Print an integer sequence.
-///
-/// This function prints a sequence of integers defined by `range`,
-/// which defines the first integer, last integer, and increment of the
-/// range. The `separator` is inserted between each integer and
-/// `terminator` is inserted at the end.
-///
-/// The `pad` parameter indicates whether to pad numbers to the width
-/// given in `padding`.
-///
-/// If `is_first_minus_zero` is `true`, then the `first` parameter is
-/// printed as if it were negative zero, even though no such number
-/// exists as an integer (negative zero only exists for floating point
-/// numbers). Only set this to `true` if `first` is actually zero.
-fn print_seq_integers(
-    range: RangeInt,
-    separator: &str,
-    terminator: &str,
-    pad: bool,
-    padding: usize,
-    format: Option<&str>,
-) -> std::io::Result<()> {
-    let stdout = stdout();
-    let mut stdout = stdout.lock();
-    let (first, increment, last) = range;
-    let mut value = first;
-    let mut is_first_iteration = true;
-    while !done_printing(&value, &increment, &last) {
-        if !is_first_iteration {
-            write!(stdout, "{separator}")?;
-        }
-        // If there was an argument `-f FORMAT`, then use that format
-        // template instead of the default formatting strategy.
-        //
-        // The `printf()` function takes in the template and
-        // the current value and writes the result to `stdout`.
-        //
-        // TODO See similar comment about formatting in `print_seq()`.
-        match format {
-            Some(f) => {
-                let s = format!("{value}");
-                if let Err(x) = printf(f, &[s]) {
-                    show!(x);
-                    exit(1);
-                }
-            }
-            None => write_value_int(&mut stdout, &value, padding, pad)?,
-        }
-        // TODO Implement augmenting addition.
-        value = value + increment.clone();
-        is_first_iteration = false;
-    }
-
-    if !is_first_iteration {
-        write!(stdout, "{terminator}")?;
-    }
-    Ok(())
-}
diff --git a/src/uu/shred/Cargo.toml b/src/uu/shred/Cargo.toml
index 8721cd624f0..97fab64e1f6 100644
--- a/src/uu/shred/Cargo.toml
+++ b/src/uu/shred/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_shred"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shred ~ (uutils) hide former FILE contents with repeated overwrites"
diff --git a/src/uu/shred/src/shred.rs b/src/uu/shred/src/shred.rs
index eb63f0e5f2e..b142e2e94e0 100644
--- a/src/uu/shred/src/shred.rs
+++ b/src/uu/shred/src/shred.rs
@@ -17,7 +17,7 @@ use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
 use uucore::parse_size::parse_size_u64;
-use uucore::{format_usage, help_about, help_section, help_usage, show, show_error, show_if_err};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error, show_if_err};
 
 const ABOUT: &str = help_about!("shred.md");
 const USAGE: &str = help_usage!("shred.md");
@@ -28,10 +28,17 @@ pub mod options {
     pub const FILE: &str = "file";
     pub const ITERATIONS: &str = "iterations";
     pub const SIZE: &str = "size";
+    pub const WIPESYNC: &str = "u";
     pub const REMOVE: &str = "remove";
     pub const VERBOSE: &str = "verbose";
     pub const EXACT: &str = "exact";
     pub const ZERO: &str = "zero";
+
+    pub mod remove {
+        pub const UNLINK: &str = "unlink";
+        pub const WIPE: &str = "wipe";
+        pub const WIPESYNC: &str = "wipesync";
+    }
 }
 
 // This block size seems to match GNU (2^16 = 65536)
@@ -81,6 +88,14 @@ enum PassType {
     Random,
 }
 
+#[derive(PartialEq, Clone, Copy)]
+enum RemoveMethod {
+    None,     // Default method. Only obfuscate the file data
+    Unlink,   // The same as 'None' + unlink the file
+    Wipe,     // The same as 'Unlink' + obfuscate the file name before unlink
+    WipeSync, // The same as 'Wipe' sync the file name changes
+}
+
 /// Iterates over all possible filenames of a certain length using NAME_CHARSET as an alphabet
 struct FilenameIter {
     // Store the indices of the letters of our filename in NAME_CHARSET
@@ -200,8 +215,6 @@ impl BytesWriter {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     if !matches.contains_id(options::FILE) {
@@ -221,17 +234,25 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         None => unreachable!(),
     };
 
-    // TODO: implement --remove HOW
-    //       The optional HOW parameter indicates how to remove a directory entry:
-    //         - 'unlink' => use a standard unlink call.
-    //         - 'wipe' => also first obfuscate bytes in the name.
-    //         - 'wipesync' => also sync each obfuscated byte to disk.
-    //       The default mode is 'wipesync', but note it can be expensive.
-
     // TODO: implement --random-source
 
+    let remove_method = if matches.get_flag(options::WIPESYNC) {
+        RemoveMethod::WipeSync
+    } else if matches.contains_id(options::REMOVE) {
+        match matches
+            .get_one::<String>(options::REMOVE)
+            .map(AsRef::as_ref)
+        {
+            Some(options::remove::UNLINK) => RemoveMethod::Unlink,
+            Some(options::remove::WIPE) => RemoveMethod::Wipe,
+            Some(options::remove::WIPESYNC) => RemoveMethod::WipeSync,
+            _ => unreachable!("should be caught by clap"),
+        }
+    } else {
+        RemoveMethod::None
+    };
+
     let force = matches.get_flag(options::FORCE);
-    let remove = matches.get_flag(options::REMOVE);
     let size_arg = matches
         .get_one::<String>(options::SIZE)
         .map(|s| s.to_string());
@@ -242,7 +263,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     for path_str in matches.get_many::<String>(options::FILE).unwrap() {
         show_if_err!(wipe_file(
-            path_str, iterations, remove, size, exact, zero, verbose, force,
+            path_str,
+            iterations,
+            remove_method,
+            size,
+            exact,
+            zero,
+            verbose,
+            force,
         ));
     }
     Ok(())
@@ -278,12 +306,26 @@ pub fn uu_app() -> Command {
                 .help("shred this many bytes (suffixes like K, M, G accepted)"),
         )
         .arg(
-            Arg::new(options::REMOVE)
+            Arg::new(options::WIPESYNC)
                 .short('u')
-                .long(options::REMOVE)
-                .help("truncate and remove file after overwriting;  See below")
+                .help("deallocate and remove file after overwriting")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::REMOVE)
+                .long(options::REMOVE)
+                .value_name("HOW")
+                .value_parser([
+                    options::remove::UNLINK,
+                    options::remove::WIPE,
+                    options::remove::WIPESYNC,
+                ])
+                .num_args(0..=1)
+                .require_equals(true)
+                .default_missing_value(options::remove::WIPESYNC)
+                .help("like -u but give control on HOW to delete;  See below")
+                .action(ArgAction::Set),
+        )
         .arg(
             Arg::new(options::VERBOSE)
                 .long(options::VERBOSE)
@@ -342,7 +384,7 @@ fn pass_name(pass_type: &PassType) -> String {
 fn wipe_file(
     path_str: &str,
     n_passes: usize,
-    remove: bool,
+    remove_method: RemoveMethod,
     size: Option<u64>,
     exact: bool,
     zero: bool,
@@ -369,12 +411,12 @@ fn wipe_file(
         let metadata = fs::metadata(path).map_err_context(String::new)?;
         let mut perms = metadata.permissions();
         #[cfg(unix)]
-        #[allow(clippy::useless_conversion)]
+        #[allow(clippy::useless_conversion, clippy::unnecessary_cast)]
         {
             // NOTE: set_readonly(false) makes the file world-writable on Unix.
-            // NOTE: S_IWUSR type is u16 on macOS.
-            if (perms.mode() & u32::from(S_IWUSR)) == 0 {
-                perms.set_mode(u32::from(S_IWUSR));
+            // NOTE: S_IWUSR type is u16 on macOS, i32 on Redox.
+            if (perms.mode() & (S_IWUSR as u32)) == 0 {
+                perms.set_mode(S_IWUSR as u32);
             }
         }
         #[cfg(not(unix))]
@@ -437,7 +479,7 @@ fn wipe_file(
             let pass_name = pass_name(&pass_type);
             if total_passes < 10 {
                 show_error!(
-                    "{}: pass {}/{} ({})... ",
+                    "{}: pass {}/{} ({})...",
                     path.maybe_quote(),
                     i + 1,
                     total_passes,
@@ -445,7 +487,7 @@ fn wipe_file(
                 );
             } else {
                 show_error!(
-                    "{}: pass {:2.0}/{:2.0} ({})... ",
+                    "{}: pass {:2.0}/{:2.0} ({})...",
                     path.maybe_quote(),
                     i + 1,
                     total_passes,
@@ -459,8 +501,8 @@ fn wipe_file(
             .map_err_context(|| format!("{}: File write pass failed", path.maybe_quote())));
     }
 
-    if remove {
-        do_remove(path, path_str, verbose)
+    if remove_method != RemoveMethod::None {
+        do_remove(path, path_str, verbose, remove_method)
             .map_err_context(|| format!("{}: failed to remove file", path.maybe_quote()))?;
     }
     Ok(())
@@ -503,7 +545,7 @@ fn get_file_size(path: &Path) -> Result<u64, io::Error> {
 
 // Repeatedly renames the file with strings of decreasing length (most likely all 0s)
 // Return the path of the file after its last renaming or None if error
-fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
+fn wipe_name(orig_path: &Path, verbose: bool, remove_method: RemoveMethod) -> Option<PathBuf> {
     let file_name_len = orig_path.file_name().unwrap().to_str().unwrap().len();
 
     let mut last_path = PathBuf::from(orig_path);
@@ -524,16 +566,18 @@ fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
                         show_error!(
                             "{}: renamed to {}",
                             last_path.maybe_quote(),
-                            new_path.quote()
+                            new_path.display()
                         );
                     }
 
-                    // Sync every file rename
-                    let new_file = OpenOptions::new()
-                        .write(true)
-                        .open(new_path.clone())
-                        .expect("Failed to open renamed file for syncing");
-                    new_file.sync_all().expect("Failed to sync renamed file");
+                    if remove_method == RemoveMethod::WipeSync {
+                        // Sync every file rename
+                        let new_file = OpenOptions::new()
+                            .write(true)
+                            .open(new_path.clone())
+                            .expect("Failed to open renamed file for syncing");
+                        new_file.sync_all().expect("Failed to sync renamed file");
+                    }
 
                     last_path = new_path;
                     break;
@@ -554,12 +598,23 @@ fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
     Some(last_path)
 }
 
-fn do_remove(path: &Path, orig_filename: &str, verbose: bool) -> Result<(), io::Error> {
+fn do_remove(
+    path: &Path,
+    orig_filename: &str,
+    verbose: bool,
+    remove_method: RemoveMethod,
+) -> Result<(), io::Error> {
     if verbose {
         show_error!("{}: removing", orig_filename.maybe_quote());
     }
 
-    if let Some(rp) = wipe_name(path, verbose) {
+    let remove_path = if remove_method == RemoveMethod::Unlink {
+        Some(path.with_file_name(orig_filename))
+    } else {
+        wipe_name(path, verbose, remove_method)
+    };
+
+    if let Some(rp) = remove_path {
         fs::remove_file(rp)?;
     }
 
diff --git a/src/uu/shuf/Cargo.toml b/src/uu/shuf/Cargo.toml
index 2bbf2af149d..c1d2de7c8bd 100644
--- a/src/uu/shuf/Cargo.toml
+++ b/src/uu/shuf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_shuf"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shuf ~ (uutils) display random permutations of input lines"
diff --git a/src/uu/shuf/shuf.md b/src/uu/shuf/shuf.md
index b59799c3378..7bc1e0a6d60 100644
--- a/src/uu/shuf/shuf.md
+++ b/src/uu/shuf/shuf.md
@@ -3,7 +3,7 @@
 ```
 shuf [OPTION]... [FILE]
 shuf -e [OPTION]... [ARG]...
-shuf -i LO-HI [OPTION]...;
+shuf -i LO-HI [OPTION]...
 ```
 
 Shuffle the input by outputting a random permutation of input lines.
diff --git a/src/uu/shuf/src/shuf.rs b/src/uu/shuf/src/shuf.rs
index 8c636f1cb1d..de302435cb6 100644
--- a/src/uu/shuf/src/shuf.rs
+++ b/src/uu/shuf/src/shuf.rs
@@ -47,8 +47,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let mode = if let Some(args) = matches.get_many::<String>(options::ECHO) {
diff --git a/src/uu/sleep/Cargo.toml b/src/uu/sleep/Cargo.toml
index d3d1fe61e9f..94789f31312 100644
--- a/src/uu/sleep/Cargo.toml
+++ b/src/uu/sleep/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_sleep"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sleep ~ (uutils) pause for DURATION"
diff --git a/src/uu/sort/Cargo.toml b/src/uu/sort/Cargo.toml
index 8c1c03dc638..7f5938c7034 100644
--- a/src/uu/sort/Cargo.toml
+++ b/src/uu/sort/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_sort"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sort ~ (uutils) sort input lines"
diff --git a/src/uu/sort/src/sort.rs b/src/uu/sort/src/sort.rs
index 4e6e841874b..5fcfe2c82da 100644
--- a/src/uu/sort/src/sort.rs
+++ b/src/uu/sort/src/sort.rs
@@ -1029,7 +1029,6 @@ fn make_sort_mode_arg(mode: &'static str, short: char, help: &'static str) -> Ar
 #[uucore::main]
 #[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
     let mut settings = GlobalSettings::default();
 
     let matches = match uu_app().try_get_matches_from(args) {
@@ -1281,6 +1280,7 @@ pub fn uu_app() -> Command {
         .infer_long_args(true)
         .disable_help_flag(true)
         .disable_version_flag(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::HELP)
                 .long(options::HELP)
diff --git a/src/uu/split/Cargo.toml b/src/uu/split/Cargo.toml
index 6253dbf2be3..5a7ded4bc8b 100644
--- a/src/uu/split/Cargo.toml
+++ b/src/uu/split/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_split"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "split ~ (uutils) split input into output files"
diff --git a/src/uu/split/src/platform/unix.rs b/src/uu/split/src/platform/unix.rs
index f4adb818834..1fd990e0a91 100644
--- a/src/uu/split/src/platform/unix.rs
+++ b/src/uu/split/src/platform/unix.rs
@@ -7,9 +7,10 @@ use std::io::Write;
 use std::io::{BufWriter, Error, ErrorKind, Result};
 use std::path::Path;
 use std::process::{Child, Command, Stdio};
-use uucore::crash;
+use uucore::error::USimpleError;
 use uucore::fs;
 use uucore::fs::FileInformation;
+use uucore::show;
 
 /// A writer that writes to a shell_process' stdin
 ///
@@ -101,10 +102,13 @@ impl Drop for FilterWriter {
             .expect("Couldn't wait for child process");
         if let Some(return_code) = exit_status.code() {
             if return_code != 0 {
-                crash!(1, "Shell process returned {}", return_code);
+                show!(USimpleError::new(
+                    1,
+                    format!("Shell process returned {}", return_code)
+                ));
             }
         } else {
-            crash!(1, "Shell process terminated by signal")
+            show!(USimpleError::new(1, "Shell process terminated by signal"));
         }
     }
 }
@@ -113,22 +117,37 @@ impl Drop for FilterWriter {
 pub fn instantiate_current_writer(
     filter: &Option<String>,
     filename: &str,
+    is_new: bool,
 ) -> Result<BufWriter<Box<dyn Write>>> {
     match filter {
-        None => Ok(BufWriter::new(Box::new(
-            // write to the next file
-            std::fs::OpenOptions::new()
-                .write(true)
-                .create(true)
-                .truncate(true)
-                .open(std::path::Path::new(&filename))
-                .map_err(|_| {
-                    Error::new(
-                        ErrorKind::Other,
-                        format!("unable to open '{filename}'; aborting"),
-                    )
-                })?,
-        ) as Box<dyn Write>)),
+        None => {
+            let file = if is_new {
+                // create new file
+                std::fs::OpenOptions::new()
+                    .write(true)
+                    .create(true)
+                    .truncate(true)
+                    .open(std::path::Path::new(&filename))
+                    .map_err(|_| {
+                        Error::new(
+                            ErrorKind::Other,
+                            format!("unable to open '{filename}'; aborting"),
+                        )
+                    })?
+            } else {
+                // re-open file that we previously created to append to it
+                std::fs::OpenOptions::new()
+                    .append(true)
+                    .open(std::path::Path::new(&filename))
+                    .map_err(|_| {
+                        Error::new(
+                            ErrorKind::Other,
+                            format!("unable to re-open '{filename}'; aborting"),
+                        )
+                    })?
+            };
+            Ok(BufWriter::new(Box::new(file) as Box<dyn Write>))
+        }
         Some(ref filter_command) => Ok(BufWriter::new(Box::new(
             // spawn a shell command and write to it
             FilterWriter::new(filter_command, filename)?,
diff --git a/src/uu/split/src/platform/windows.rs b/src/uu/split/src/platform/windows.rs
index 8b90789896f..a531d6abc1f 100644
--- a/src/uu/split/src/platform/windows.rs
+++ b/src/uu/split/src/platform/windows.rs
@@ -14,9 +14,10 @@ use uucore::fs;
 pub fn instantiate_current_writer(
     _filter: &Option<String>,
     filename: &str,
+    is_new: bool,
 ) -> Result<BufWriter<Box<dyn Write>>> {
-    Ok(BufWriter::new(Box::new(
-        // write to the next file
+    let file = if is_new {
+        // create new file
         std::fs::OpenOptions::new()
             .write(true)
             .create(true)
@@ -25,10 +26,22 @@ pub fn instantiate_current_writer(
             .map_err(|_| {
                 Error::new(
                     ErrorKind::Other,
-                    format!("'{filename}' would overwrite input; aborting"),
+                    format!("unable to open '{filename}'; aborting"),
                 )
-            })?,
-    ) as Box<dyn Write>))
+            })?
+    } else {
+        // re-open file that we previously created to append to it
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(std::path::Path::new(&filename))
+            .map_err(|_| {
+                Error::new(
+                    ErrorKind::Other,
+                    format!("unable to re-open '{filename}'; aborting"),
+                )
+            })?
+    };
+    Ok(BufWriter::new(Box::new(file) as Box<dyn Write>))
 }
 
 pub fn paths_refer_to_same_file(p1: &str, p2: &str) -> bool {
diff --git a/src/uu/split/src/split.rs b/src/uu/split/src/split.rs
index 17a783d72f2..a837bcb21ec 100644
--- a/src/uu/split/src/split.rs
+++ b/src/uu/split/src/split.rs
@@ -3,7 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore nbbbb ncccc hexdigit
+// spell-checker:ignore nbbbb ncccc hexdigit getmaxstdio
 
 mod filenames;
 mod number;
@@ -18,11 +18,12 @@ use std::ffi::OsString;
 use std::fmt;
 use std::fs::{metadata, File};
 use std::io;
-use std::io::{stdin, BufRead, BufReader, BufWriter, ErrorKind, Read, Write};
+use std::io::{stdin, BufRead, BufReader, BufWriter, ErrorKind, Read, Seek, SeekFrom, Write};
 use std::path::Path;
 use std::u64;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UIoError, UResult, USimpleError, UUsageError};
+use uucore::parse_size::parse_size_u64;
 
 use uucore::uio_error;
 use uucore::{format_usage, help_about, help_section, help_usage};
@@ -40,11 +41,20 @@ static OPT_HEX_SUFFIXES_SHORT: &str = "-x";
 static OPT_SUFFIX_LENGTH: &str = "suffix-length";
 static OPT_VERBOSE: &str = "verbose";
 static OPT_SEPARATOR: &str = "separator";
-//The ---io and ---io-blksize parameters are consumed and ignored.
-//The parameter is included to make GNU coreutils tests pass.
-static OPT_IO: &str = "-io";
-static OPT_IO_BLKSIZE: &str = "-io-blksize";
 static OPT_ELIDE_EMPTY_FILES: &str = "elide-empty-files";
+static OPT_IO_BLKSIZE: &str = "-io-blksize";
+// Cap ---io-blksize value
+// For 64bit systems the max value is the same as in GNU
+// and is equivalent of `i32::MAX >> 20 << 20` operation.
+// On 32bit systems however, even though it fits within `u32` and `i32`,
+// it causes rust-lang `library/alloc/src/raw_vec.rs` to panic with 'capacity overflow' error.
+// Could be due to how `std::io::BufReader` handles internal buffers.
+// So we use much smaller value for those
+static OPT_IO_BLKSIZE_MAX: usize = if usize::BITS >= 64 {
+    2_146_435_072
+} else {
+    1_000_000_000
+};
 
 static ARG_INPUT: &str = "input";
 static ARG_PREFIX: &str = "prefix";
@@ -311,7 +321,6 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(OPT_NUMERIC_SUFFIXES)
                 .long(OPT_NUMERIC_SUFFIXES)
-                .alias("numeric")
                 .require_equals(true)
                 .num_args(0..=1)
                 .overrides_with_all([
@@ -338,7 +347,6 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(OPT_HEX_SUFFIXES)
                 .long(OPT_HEX_SUFFIXES)
-                .alias("hex")
                 .require_equals(true)
                 .num_args(0..=1)
                 .overrides_with_all([
@@ -373,12 +381,6 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::Append)
                 .help("use SEP instead of newline as the record separator; '\\0' (zero) specifies the NUL character"),
         )
-        .arg(
-            Arg::new(OPT_IO)
-                .long("io")
-                .alias(OPT_IO)
-                .hide(true),
-        )
         .arg(
             Arg::new(OPT_IO_BLKSIZE)
                 .long("io-blksize")
@@ -419,6 +421,7 @@ struct Settings {
     /// chunks. If this is `false`, then empty files will not be
     /// created.
     elide_empty_files: bool,
+    io_blksize: Option<usize>,
 }
 
 /// An error when parsing settings from command-line arguments.
@@ -441,6 +444,9 @@ enum SettingsError {
     /// r/K/N
     FilterWithKthChunkNumber,
 
+    /// Invalid IO block size
+    InvalidIOBlockSize(String),
+
     /// The `--filter` option is not supported on Windows.
     #[cfg(windows)]
     NotSupported,
@@ -471,6 +477,7 @@ impl fmt::Display for SettingsError {
             Self::FilterWithKthChunkNumber => {
                 write!(f, "--filter does not process a chunk extracted to stdout")
             }
+            Self::InvalidIOBlockSize(s) => write!(f, "invalid IO block size: {}", s.quote()),
             #[cfg(windows)]
             Self::NotSupported => write!(
                 f,
@@ -499,12 +506,29 @@ impl Settings {
                 match first.as_str() {
                     "\\0" => b'\0',
                     s if s.as_bytes().len() == 1 => s.as_bytes()[0],
-                    s => return Err(SettingsError::MultiCharacterSeparator(s.to_owned())),
+                    s => return Err(SettingsError::MultiCharacterSeparator(s.to_string())),
                 }
             }
             None => b'\n',
         };
 
+        let io_blksize: Option<usize> = if let Some(s) = matches.get_one::<String>(OPT_IO_BLKSIZE) {
+            match parse_size_u64(s) {
+                Ok(n) => {
+                    let n: usize = n
+                        .try_into()
+                        .map_err(|_| SettingsError::InvalidIOBlockSize(s.to_string()))?;
+                    if n > OPT_IO_BLKSIZE_MAX {
+                        return Err(SettingsError::InvalidIOBlockSize(s.to_string()));
+                    }
+                    Some(n)
+                }
+                _ => return Err(SettingsError::InvalidIOBlockSize(s.to_string())),
+            }
+        } else {
+            None
+        };
+
         let result = Self {
             prefix: matches.get_one::<String>(ARG_PREFIX).unwrap().clone(),
             suffix,
@@ -514,6 +538,7 @@ impl Settings {
             verbose: matches.value_source(OPT_VERBOSE) == Some(ValueSource::CommandLine),
             separator,
             elide_empty_files: matches.get_flag(OPT_ELIDE_EMPTY_FILES),
+            io_blksize,
         };
 
         #[cfg(windows)]
@@ -538,7 +563,11 @@ impl Settings {
         Ok(result)
     }
 
-    fn instantiate_current_writer(&self, filename: &str) -> io::Result<BufWriter<Box<dyn Write>>> {
+    fn instantiate_current_writer(
+        &self,
+        filename: &str,
+        is_new: bool,
+    ) -> io::Result<BufWriter<Box<dyn Write>>> {
         if platform::paths_refer_to_same_file(&self.input, filename) {
             return Err(io::Error::new(
                 ErrorKind::Other,
@@ -546,7 +575,7 @@ impl Settings {
             ));
         }
 
-        platform::instantiate_current_writer(&self.filter, filename)
+        platform::instantiate_current_writer(&self.filter, filename, is_new)
     }
 }
 
@@ -591,6 +620,93 @@ fn custom_write_all<T: Write>(
     }
 }
 
+/// Get the size of the input file in bytes
+/// Used only for subset of `--number=CHUNKS` strategy, as there is a need
+/// to determine input file size upfront in order to estimate the chunk size
+/// to be written into each of N files/chunks:
+/// * N       split into N files based on size of input
+/// * K/N     output Kth of N to stdout
+/// * l/N     split into N files without splitting lines/records
+/// * l/K/N   output Kth of N to stdout without splitting lines/records
+///
+/// For most files the size will be determined by either reading entire file content into a buffer
+/// or by `len()` function of [`std::fs::metadata`].
+///
+/// However, for some files which report filesystem metadata size that does not match
+/// their actual content size, we will need to attempt to find the end of file
+/// with direct `seek()` on [`std::fs::File`].
+///
+/// For STDIN stream - read into a buffer up to a limit
+/// If input stream does not EOF before that - return an error
+/// (i.e. "infinite" input as in `cat /dev/zero | split ...`, `yes | split ...` etc.).
+///
+/// Note: The `buf` might end up with either partial or entire input content.
+fn get_input_size<R>(
+    input: &String,
+    reader: &mut R,
+    buf: &mut Vec<u8>,
+    io_blksize: &Option<usize>,
+) -> std::io::Result<u64>
+where
+    R: BufRead,
+{
+    // Set read limit to io_blksize if specified
+    // Otherwise to OPT_IO_BLKSIZE_MAX
+    let read_limit = io_blksize.unwrap_or(OPT_IO_BLKSIZE_MAX) as u64;
+
+    // Try to read into buffer up to a limit
+    let num_bytes = reader
+        .by_ref()
+        .take(read_limit)
+        .read_to_end(buf)
+        .map(|n| n as u64)?;
+
+    if num_bytes < read_limit {
+        // Finite file or STDIN stream that fits entirely
+        // into a buffer within the limit
+        // Note: files like /dev/null or similar,
+        // empty STDIN stream,
+        // and files with true file size 0
+        // will also fit here
+        Ok(num_bytes)
+    } else if input == "-" {
+        // STDIN stream that did not fit all content into a buffer
+        // Most likely continuous/infinite input stream
+        return Err(io::Error::new(
+            ErrorKind::Other,
+            format!("{}: cannot determine input size", input),
+        ));
+    } else {
+        // Could be that file size is larger than set read limit
+        // Get the file size from filesystem metadata
+        let metadata = metadata(input)?;
+        let metadata_size = metadata.len();
+        if num_bytes <= metadata_size {
+            Ok(metadata_size)
+        } else {
+            // Could be a file from locations like /dev, /sys, /proc or similar
+            // which report filesystem metadata size that does not match
+            // their actual content size
+            // Attempt direct `seek()` for the end of a file
+            let mut tmp_fd = File::open(Path::new(input))?;
+            let end = tmp_fd.seek(SeekFrom::End(0))?;
+            if end > 0 {
+                Ok(end)
+            } else {
+                // Edge case of either "infinite" file (i.e. /dev/zero)
+                // or some other "special" non-standard file type
+                // Give up and return an error
+                // TODO It might be possible to do more here
+                // to address all possible file types and edge cases
+                return Err(io::Error::new(
+                    ErrorKind::Other,
+                    format!("{}: cannot determine file size", input),
+                ));
+            }
+        }
+    }
+}
+
 /// Write a certain number of bytes to one file, then move on to another one.
 ///
 /// This struct maintains an underlying writer representing the
@@ -636,7 +752,7 @@ impl<'a> ByteChunkWriter<'a> {
         if settings.verbose {
             println!("creating file {}", filename.quote());
         }
-        let inner = settings.instantiate_current_writer(&filename)?;
+        let inner = settings.instantiate_current_writer(&filename, true)?;
         Ok(ByteChunkWriter {
             settings,
             chunk_size,
@@ -674,7 +790,7 @@ impl<'a> Write for ByteChunkWriter<'a> {
                 if self.settings.verbose {
                     println!("creating file {}", filename.quote());
                 }
-                self.inner = self.settings.instantiate_current_writer(&filename)?;
+                self.inner = self.settings.instantiate_current_writer(&filename, true)?;
             }
 
             // If the capacity of this chunk is greater than the number of
@@ -760,7 +876,7 @@ impl<'a> LineChunkWriter<'a> {
         if settings.verbose {
             println!("creating file {}", filename.quote());
         }
-        let inner = settings.instantiate_current_writer(&filename)?;
+        let inner = settings.instantiate_current_writer(&filename, true)?;
         Ok(LineChunkWriter {
             settings,
             chunk_size,
@@ -795,7 +911,7 @@ impl<'a> Write for LineChunkWriter<'a> {
                 if self.settings.verbose {
                     println!("creating file {}", filename.quote());
                 }
-                self.inner = self.settings.instantiate_current_writer(&filename)?;
+                self.inner = self.settings.instantiate_current_writer(&filename, true)?;
                 self.num_lines_remaining_in_current_chunk = self.chunk_size;
             }
 
@@ -867,7 +983,7 @@ impl<'a> LineBytesChunkWriter<'a> {
         if settings.verbose {
             println!("creating file {}", filename.quote());
         }
-        let inner = settings.instantiate_current_writer(&filename)?;
+        let inner = settings.instantiate_current_writer(&filename, true)?;
         Ok(LineBytesChunkWriter {
             settings,
             chunk_size,
@@ -933,7 +1049,7 @@ impl<'a> Write for LineBytesChunkWriter<'a> {
                 if self.settings.verbose {
                     println!("creating file {}", filename.quote());
                 }
-                self.inner = self.settings.instantiate_current_writer(&filename)?;
+                self.inner = self.settings.instantiate_current_writer(&filename, true)?;
                 self.num_bytes_remaining_in_current_chunk = self.chunk_size.try_into().unwrap();
             }
 
@@ -1018,155 +1134,218 @@ impl<'a> Write for LineBytesChunkWriter<'a> {
     }
 }
 
-/// Split a file into a specific number of chunks by byte.
-///
-/// This function always creates one output file for each chunk, even
-/// if there is an error reading or writing one of the chunks or if
-/// the input file is truncated. However, if the `filter` option is
-/// being used, then no files are created.
-///
-/// # Errors
-///
-/// This function returns an error if there is a problem reading from
-/// `reader` or writing to one of the output files.
-///
-/// Implements `--number=CHUNKS`
-/// Where CHUNKS
-/// * N
-fn split_into_n_chunks_by_byte<R>(
-    settings: &Settings,
-    reader: &mut R,
-    num_chunks: u64,
-) -> UResult<()>
-where
-    R: Read,
-{
-    // Get the size of the input file in bytes and compute the number
-    // of bytes per chunk.
-    //
-    // If the requested number of chunks exceeds the number of bytes
-    // in the file *and* the `elide_empty_files` parameter is enabled,
-    // then behave as if the number of chunks was set to the number of
-    // bytes in the file. This ensures that we don't write empty
-    // files. Otherwise, just write the `num_chunks - num_bytes` empty
-    // files.
-    let metadata = metadata(&settings.input).map_err(|_| {
-        USimpleError::new(1, format!("{}: cannot determine file size", settings.input))
-    })?;
-
-    let num_bytes = metadata.len();
-    let will_have_empty_files = settings.elide_empty_files && num_chunks > num_bytes;
-    let (num_chunks, chunk_size) = if will_have_empty_files {
-        let num_chunks = num_bytes;
-        let chunk_size = 1;
-        (num_chunks, chunk_size)
-    } else {
-        let chunk_size = (num_bytes / (num_chunks)).max(1);
-        (num_chunks, chunk_size)
-    };
-
-    // If we would have written zero chunks of output, then terminate
-    // immediately. This happens on `split -e -n 3 /dev/null`, for
-    // example.
-    if num_chunks == 0 || num_bytes == 0 {
-        return Ok(());
-    }
-
-    let num_chunks: usize = num_chunks
-        .try_into()
-        .map_err(|_| USimpleError::new(1, "Number of chunks too big"))?;
-
-    // This object is responsible for creating the filename for each chunk.
-    let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)?;
+/// Output file parameters
+struct OutFile {
+    filename: String,
+    maybe_writer: Option<BufWriter<Box<dyn Write>>>,
+    is_new: bool,
+}
 
-    // Create one writer for each chunk. This will create each
-    // of the underlying files (if not in `--filter` mode).
-    let mut writers = vec![];
-    for _ in 0..num_chunks {
-        let filename = filename_iterator
-            .next()
-            .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
-        let writer = settings.instantiate_current_writer(filename.as_str())?;
-        writers.push(writer);
-    }
+/// A set of output files
+/// Used in [`n_chunks_by_byte`], [`n_chunks_by_line`]
+/// and [`n_chunks_by_line_round_robin`] functions.
+type OutFiles = Vec<OutFile>;
+trait ManageOutFiles {
+    /// Initialize a new set of output files
+    /// Each OutFile is generated with filename, while the writer for it could be
+    /// optional, to be instantiated later by the calling function as needed.
+    /// Optional writers could happen in the following situations:
+    /// * in [`n_chunks_by_line`] and [`n_chunks_by_line_round_robin`] if `elide_empty_files` parameter is set to `true`
+    /// * if the number of files is greater than system limit for open files
+    fn init(num_files: u64, settings: &Settings, is_writer_optional: bool) -> UResult<Self>
+    where
+        Self: Sized;
+    /// Get the writer for the output file by index.
+    /// If system limit of open files has been reached
+    /// it will try to close one of previously instantiated writers
+    /// to free up resources and re-try instantiating current writer,
+    /// except for `--filter` mode.
+    /// The writers that get closed to free up resources for the current writer
+    /// are flagged as `is_new=false`, so they can be re-opened for appending
+    /// instead of created anew if we need to keep writing into them later,
+    /// i.e. in case of round robin distribution as in [`n_chunks_by_line_round_robin`]
+    fn get_writer(
+        &mut self,
+        idx: usize,
+        settings: &Settings,
+    ) -> UResult<&mut BufWriter<Box<dyn Write>>>;
+}
 
-    // Write `chunk_size` bytes from the reader into each writer
-    // except the last.
-    //
-    // The last writer gets all remaining bytes so that if the number
-    // of bytes in the input file was not evenly divisible by
-    // `num_chunks`, we don't leave any bytes behind.
-    for writer in writers.iter_mut().take(num_chunks - 1) {
-        match io::copy(&mut reader.by_ref().take(chunk_size), writer) {
-            Ok(_) => continue,
-            Err(e) if ignorable_io_error(&e, settings) => continue,
-            Err(e) => return Err(uio_error!(e, "input/output error")),
-        };
+impl ManageOutFiles for OutFiles {
+    fn init(num_files: u64, settings: &Settings, is_writer_optional: bool) -> UResult<Self> {
+        // This object is responsible for creating the filename for each chunk
+        let mut filename_iterator: FilenameIterator<'_> =
+            FilenameIterator::new(&settings.prefix, &settings.suffix)
+                .map_err(|e| io::Error::new(ErrorKind::Other, format!("{e}")))?;
+        let mut out_files: Self = Self::new();
+        for _ in 0..num_files {
+            let filename = filename_iterator
+                .next()
+                .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
+            let maybe_writer = if is_writer_optional {
+                None
+            } else {
+                let instantiated = settings.instantiate_current_writer(filename.as_str(), true);
+                // If there was an error instantiating the writer for a file,
+                // it could be due to hitting the system limit of open files,
+                // so record it as None and let [`get_writer`] function handle closing/re-opening
+                // of writers as needed within system limits.
+                // However, for `--filter` child process writers - propagate the error,
+                // as working around system limits of open files for child shell processes
+                // is currently not supported (same as in GNU)
+                match instantiated {
+                    Ok(writer) => Some(writer),
+                    Err(e) if settings.filter.is_some() => {
+                        return Err(e.into());
+                    }
+                    Err(_) => None,
+                }
+            };
+            out_files.push(OutFile {
+                filename,
+                maybe_writer,
+                is_new: true,
+            });
+        }
+        Ok(out_files)
     }
 
-    // Write all the remaining bytes to the last chunk.
-    let i = num_chunks - 1;
-    let last_chunk_size = num_bytes - (chunk_size * (num_chunks as u64 - 1));
-    match io::copy(&mut reader.by_ref().take(last_chunk_size), &mut writers[i]) {
-        Ok(_) => Ok(()),
-        Err(e) if ignorable_io_error(&e, settings) => Ok(()),
-        Err(e) => Err(uio_error!(e, "input/output error")),
+    fn get_writer(
+        &mut self,
+        idx: usize,
+        settings: &Settings,
+    ) -> UResult<&mut BufWriter<Box<dyn Write>>> {
+        if self[idx].maybe_writer.is_some() {
+            Ok(self[idx].maybe_writer.as_mut().unwrap())
+        } else {
+            // Writer was not instantiated upfront or was temporarily closed due to system resources constraints.
+            // Instantiate it and record for future use.
+            let maybe_writer =
+                settings.instantiate_current_writer(self[idx].filename.as_str(), self[idx].is_new);
+            if let Ok(writer) = maybe_writer {
+                self[idx].maybe_writer = Some(writer);
+                Ok(self[idx].maybe_writer.as_mut().unwrap())
+            } else if settings.filter.is_some() {
+                // Propagate error if in `--filter` mode
+                Err(maybe_writer.err().unwrap().into())
+            } else {
+                // Could have hit system limit for open files.
+                // Try to close one previously instantiated writer first
+                for (i, out_file) in self.iter_mut().enumerate() {
+                    if i != idx && out_file.maybe_writer.is_some() {
+                        out_file.maybe_writer.as_mut().unwrap().flush()?;
+                        out_file.maybe_writer = None;
+                        out_file.is_new = false;
+                        break;
+                    }
+                }
+                // And then try to instantiate the writer again
+                // If this fails - give up and propagate the error
+                self[idx].maybe_writer =
+                    Some(settings.instantiate_current_writer(
+                        self[idx].filename.as_str(),
+                        self[idx].is_new,
+                    )?);
+                Ok(self[idx].maybe_writer.as_mut().unwrap())
+            }
+        }
     }
 }
 
-/// Print the k-th chunk of a file to stdout, splitting by byte.
+/// Split a file or STDIN into a specific number of chunks by byte.
+///
+/// When file size cannot be evenly divided into the number of chunks of the same size,
+/// the first X chunks are 1 byte longer than the rest,
+/// where X is a modulus reminder of (file size % number of chunks)
 ///
-/// This function is like [`split_into_n_chunks_by_byte`], but instead
-/// of writing each chunk to its own file, it only writes to stdout
-/// the contents of the chunk identified by `chunk_number`
+/// In Kth chunk of N mode - writes to STDOUT the contents of the chunk identified by `kth_chunk`
+///
+/// In N chunks mode - this function always creates one output file for each chunk, even
+/// if there is an error reading or writing one of the chunks or if
+/// the input file is truncated. However, if the `--filter` option is
+/// being used, then files will only be created if `$FILE` variable was used
+/// in filter command,
+/// i.e. `split -n 10 --filter='head -c1 > $FILE' in`
 ///
 /// # Errors
 ///
 /// This function returns an error if there is a problem reading from
-/// `reader` or writing to stdout.
+/// `reader` or writing to one of the output files or stdout.
+///
+/// # See also
+///
+/// * [`n_chunks_by_line`], which splits its input into a specific number of chunks by line.
 ///
 /// Implements `--number=CHUNKS`
 /// Where CHUNKS
+/// * N
 /// * K/N
-fn kth_chunks_by_byte<R>(
+fn n_chunks_by_byte<R>(
     settings: &Settings,
     reader: &mut R,
-    chunk_number: u64,
     num_chunks: u64,
+    kth_chunk: Option<u64>,
 ) -> UResult<()>
 where
     R: BufRead,
 {
-    // Get the size of the input file in bytes and compute the number
-    // of bytes per chunk.
-    //
-    // If the requested number of chunks exceeds the number of bytes
-    // in the file - just write empty byte string to stdout
-    // NOTE: the `elide_empty_files` parameter is ignored here
-    // as we do not generate any files
-    // and instead writing to stdout
-    let metadata = metadata(&settings.input).map_err(|_| {
-        USimpleError::new(1, format!("{}: cannot determine file size", settings.input))
-    })?;
-
-    let num_bytes = metadata.len();
-    // If input file is empty and we would have written zero chunks of output,
-    // then terminate immediately.
-    // This happens on `split -e -n 3 /dev/null`, for example.
-    if num_bytes == 0 {
+    // Get the size of the input in bytes
+    let initial_buf = &mut Vec::new();
+    let mut num_bytes = get_input_size(&settings.input, reader, initial_buf, &settings.io_blksize)?;
+    let mut reader = initial_buf.chain(reader);
+
+    // If input file is empty and we would not have determined the Kth chunk
+    // in the Kth chunk of N chunk mode, then terminate immediately.
+    // This happens on `split -n 3/10 /dev/null`, for example.
+    if kth_chunk.is_some() && num_bytes == 0 {
         return Ok(());
     }
 
-    // Write to stdout instead of to a file.
-    let stdout = std::io::stdout();
-    let mut writer = stdout.lock();
+    // If the requested number of chunks exceeds the number of bytes
+    // in the input:
+    // * in Kth chunk of N mode - just write empty byte string to stdout
+    //   NOTE: the `elide_empty_files` parameter is ignored here
+    //   as we do not generate any files
+    //   and instead writing to stdout
+    // * In N chunks mode - if the `elide_empty_files` parameter is enabled,
+    //   then behave as if the number of chunks was set to the number of
+    //   bytes in the file. This ensures that we don't write empty
+    //   files. Otherwise, just write the `num_chunks - num_bytes` empty files.
+    let num_chunks = if kth_chunk.is_none() && settings.elide_empty_files && num_chunks > num_bytes
+    {
+        num_bytes
+    } else {
+        num_chunks
+    };
 
-    let chunk_size = (num_bytes / (num_chunks)).max(1);
-    let mut num_bytes: usize = num_bytes.try_into().unwrap();
+    // If we would have written zero chunks of output, then terminate
+    // immediately. This happens on `split -e -n 3 /dev/null`, for
+    // example.
+    if num_chunks == 0 {
+        return Ok(());
+    }
 
-    let mut i = 1;
-    loop {
-        let buf: &mut Vec<u8> = &mut vec![];
+    // In Kth chunk of N mode - we will write to stdout instead of to a file.
+    let mut stdout_writer = std::io::stdout().lock();
+    // In N chunks mode - we will write to `num_chunks` files
+    let mut out_files: OutFiles = OutFiles::new();
+
+    // Calculate chunk size base and modulo reminder
+    // to be used in calculating chunk_size later on
+    let chunk_size_base = num_bytes / num_chunks;
+    let chunk_size_reminder = num_bytes % num_chunks;
+
+    // If in N chunks mode
+    // Create one writer for each chunk.
+    // This will create each of the underlying files
+    // or stdin pipes to child shell/command processes if in `--filter` mode
+    if kth_chunk.is_none() {
+        out_files = OutFiles::init(num_chunks, settings, false)?;
+    }
+
+    for i in 1_u64..=num_chunks {
+        let chunk_size = chunk_size_base + (chunk_size_reminder > i - 1) as u64;
+        let buf = &mut Vec::new();
         if num_bytes > 0 {
             // Read `chunk_size` bytes from the reader into `buf`
             // except the last.
@@ -1176,15 +1355,17 @@ where
             // `num_chunks`, we don't leave any bytes behind.
             let limit = {
                 if i == num_chunks {
-                    num_bytes.try_into().unwrap()
+                    num_bytes
                 } else {
                     chunk_size
                 }
             };
+
             let n_bytes_read = reader.by_ref().take(limit).read_to_end(buf);
+
             match n_bytes_read {
                 Ok(n_bytes) => {
-                    num_bytes -= n_bytes;
+                    num_bytes -= n_bytes as u64;
                 }
                 Err(error) => {
                     return Err(USimpleError::new(
@@ -1193,11 +1374,20 @@ where
                     ));
                 }
             }
-            if i == chunk_number {
-                writer.write_all(buf)?;
-                break;
+
+            match kth_chunk {
+                Some(chunk_number) => {
+                    if i == chunk_number {
+                        stdout_writer.write_all(buf)?;
+                        break;
+                    }
+                }
+                None => {
+                    let idx = (i - 1) as usize;
+                    let writer = out_files.get_writer(idx, settings)?;
+                    writer.write_all(buf)?;
+                }
             }
-            i += 1;
         } else {
             break;
         }
@@ -1205,12 +1395,22 @@ where
     Ok(())
 }
 
-/// Split a file into a specific number of chunks by line.
+/// Split a file or STDIN into a specific number of chunks by line.
 ///
-/// This function always creates one output file for each chunk, even
+/// It is most likely that input cannot be evenly divided into the number of chunks
+/// of the same size in bytes or number of lines, since we cannot break lines.
+/// It is also likely that there could be empty files (having `elide_empty_files` is disabled)
+/// when a long line overlaps one or more chunks.
+///
+/// In Kth chunk of N mode - writes to STDOUT the contents of the chunk identified by `kth_chunk`
+/// Note: the `elide_empty_files` flag is ignored in this mode
+///
+/// In N chunks mode - this function always creates one output file for each chunk, even
 /// if there is an error reading or writing one of the chunks or if
-/// the input file is truncated. However, if the `filter` option is
-/// being used, then no files are created.
+/// the input file is truncated. However, if the `--filter` option is
+/// being used, then files will only be created if `$FILE` variable was used
+/// in filter command,
+/// i.e. `split -n l/10 --filter='head -c1 > $FILE' in`
 ///
 /// # Errors
 ///
@@ -1219,141 +1419,135 @@ where
 ///
 /// # See also
 ///
-/// * [`kth_chunk_by_line`], which splits its input in the same way,
-///   but writes only one specified chunk to stdout.
+/// * [`n_chunks_by_byte`], which splits its input into a specific number of chunks by byte.
 ///
 /// Implements `--number=CHUNKS`
 /// Where CHUNKS
 /// * l/N
-fn split_into_n_chunks_by_line<R>(
+/// * l/K/N
+fn n_chunks_by_line<R>(
     settings: &Settings,
     reader: &mut R,
     num_chunks: u64,
+    kth_chunk: Option<u64>,
 ) -> UResult<()>
 where
     R: BufRead,
 {
-    // Get the size of the input file in bytes and compute the number
+    // Get the size of the input in bytes and compute the number
     // of bytes per chunk.
-    let metadata = metadata(&settings.input).map_err(|_| {
-        USimpleError::new(1, format!("{}: cannot determine file size", settings.input))
-    })?;
-    let num_bytes = metadata.len();
-    let chunk_size = (num_bytes / num_chunks) as usize;
-
-    // This object is responsible for creating the filename for each chunk.
-    let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)?;
-
-    // Create one writer for each chunk. This will create each
-    // of the underlying files (if not in `--filter` mode).
-    let mut writers = vec![];
-    for _ in 0..num_chunks {
-        let filename = filename_iterator
-            .next()
-            .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
-        let writer = settings.instantiate_current_writer(filename.as_str())?;
-        writers.push(writer);
+    let initial_buf = &mut Vec::new();
+    let num_bytes = get_input_size(&settings.input, reader, initial_buf, &settings.io_blksize)?;
+    let reader = initial_buf.chain(reader);
+
+    // If input file is empty and we would not have determined the Kth chunk
+    // in the Kth chunk of N chunk mode, then terminate immediately.
+    // This happens on `split -n l/3/10 /dev/null`, for example.
+    // Similarly, if input file is empty and `elide_empty_files` parameter is enabled,
+    // then we would have written zero chunks of output,
+    // so terminate immediately as well.
+    // This happens on `split -e -n l/3 /dev/null`, for example.
+    if num_bytes == 0 && (kth_chunk.is_some() || settings.elide_empty_files) {
+        return Ok(());
     }
 
-    let mut num_bytes_remaining_in_current_chunk = chunk_size;
-    let mut i = 0;
-    let sep = settings.separator;
-    for line_result in reader.split(sep) {
-        let line = line_result.unwrap();
-        let maybe_writer = writers.get_mut(i);
-        let writer = maybe_writer.unwrap();
-        let bytes = line.as_slice();
-        custom_write_all(bytes, writer, settings)?;
-        custom_write_all(&[sep], writer, settings)?;
-
-        // Add one byte for the separator character.
-        let num_bytes = bytes.len() + 1;
-        if num_bytes > num_bytes_remaining_in_current_chunk {
-            num_bytes_remaining_in_current_chunk = chunk_size;
-            i += 1;
-        } else {
-            num_bytes_remaining_in_current_chunk -= num_bytes;
-        }
+    // In Kth chunk of N mode - we will write to stdout instead of to a file.
+    let mut stdout_writer = std::io::stdout().lock();
+    // In N chunks mode - we will write to `num_chunks` files
+    let mut out_files: OutFiles = OutFiles::new();
+
+    // Calculate chunk size base and modulo reminder
+    // to be used in calculating `num_bytes_should_be_written` later on
+    let chunk_size_base = num_bytes / num_chunks;
+    let chunk_size_reminder = num_bytes % num_chunks;
+
+    // If in N chunks mode
+    // Generate filenames for each file and
+    // if `elide_empty_files` parameter is NOT enabled - instantiate the writer
+    // which will create each of the underlying files or stdin pipes
+    // to child shell/command processes if in `--filter` mode.
+    // Otherwise keep writer optional, to be instantiated later if there is data
+    // to write for the associated chunk.
+    if kth_chunk.is_none() {
+        out_files = OutFiles::init(num_chunks, settings, settings.elide_empty_files)?;
     }
 
-    Ok(())
-}
-
-/// Print the k-th chunk of a file, splitting by line.
-///
-/// This function is like [`split_into_n_chunks_by_line`], but instead
-/// of writing each chunk to its own file, it only writes to stdout
-/// the contents of the chunk identified by `chunk_number`.
-///
-/// # Errors
-///
-/// This function returns an error if there is a problem reading from
-/// `reader` or writing to one of the output files.
-///
-/// # See also
-///
-/// * [`split_into_n_chunks_by_line`], which splits its input in the
-///   same way, but writes each chunk to its own file.
-///
-/// Implements `--number=CHUNKS`
-/// Where CHUNKS
-/// * l/K/N
-fn kth_chunk_by_line<R>(
-    settings: &Settings,
-    reader: &mut R,
-    chunk_number: u64,
-    num_chunks: u64,
-) -> UResult<()>
-where
-    R: BufRead,
-{
-    // Get the size of the input file in bytes and compute the number
-    // of bytes per chunk.
-    let metadata = metadata(&settings.input).map_err(|_| {
-        USimpleError::new(1, format!("{}: cannot determine file size", settings.input))
-    })?;
-    let num_bytes = metadata.len();
-    let chunk_size = (num_bytes / num_chunks) as usize;
-
-    // Write to stdout instead of to a file.
-    let stdout = std::io::stdout();
-    let mut writer = stdout.lock();
-
-    let mut num_bytes_remaining_in_current_chunk = chunk_size;
-    let mut i = 1;
+    let mut chunk_number = 1;
     let sep = settings.separator;
+    let mut num_bytes_should_be_written = chunk_size_base + (chunk_size_reminder > 0) as u64;
+    let mut num_bytes_written = 0;
+
     for line_result in reader.split(sep) {
-        let line = line_result?;
+        let mut line = line_result?;
+        // add separator back in at the end of the line,
+        // since `reader.split(sep)` removes it,
+        // except if the last line did not end with separator character
+        if (num_bytes_written + line.len() as u64) < num_bytes {
+            line.push(sep);
+        }
         let bytes = line.as_slice();
-        if i == chunk_number {
-            writer.write_all(bytes)?;
-            writer.write_all(&[sep])?;
+
+        match kth_chunk {
+            Some(kth) => {
+                if chunk_number == kth {
+                    stdout_writer.write_all(bytes)?;
+                }
+            }
+            None => {
+                // Should write into a file
+                let idx = (chunk_number - 1) as usize;
+                let writer = out_files.get_writer(idx, settings)?;
+                custom_write_all(bytes, writer, settings)?;
+            }
         }
 
-        // Add one byte for the separator character.
-        let num_bytes = bytes.len() + 1;
-        if num_bytes >= num_bytes_remaining_in_current_chunk {
-            num_bytes_remaining_in_current_chunk = chunk_size;
-            i += 1;
-        } else {
-            num_bytes_remaining_in_current_chunk -= num_bytes;
+        // Advance to the next chunk if the current one is filled.
+        // There could be a situation when a long line, which started in current chunk,
+        // would overlap the next chunk (or even several next chunks),
+        // and since we cannot break lines for this split strategy, we could end up with
+        // empty files in place(s) of skipped chunk(s)
+        let num_line_bytes = bytes.len() as u64;
+        num_bytes_written += num_line_bytes;
+        let mut skipped = -1;
+        while num_bytes_should_be_written <= num_bytes_written {
+            num_bytes_should_be_written +=
+                chunk_size_base + (chunk_size_reminder > chunk_number) as u64;
+            chunk_number += 1;
+            skipped += 1;
         }
 
-        if i > chunk_number {
-            break;
+        // If a chunk was skipped and `elide_empty_files` flag is set,
+        // roll chunk_number back to preserve sequential continuity
+        // of file names for files written to,
+        // except for Kth chunk of N mode
+        if settings.elide_empty_files && skipped > 0 && kth_chunk.is_none() {
+            chunk_number -= skipped as u64;
         }
-    }
 
+        if let Some(kth) = kth_chunk {
+            if chunk_number > kth {
+                break;
+            }
+        }
+    }
     Ok(())
 }
 
-/// Split a file into a specific number of chunks by line, but
-/// assign lines via round-robin
+/// Split a file or STDIN into a specific number of chunks by line, but
+/// assign lines via round-robin.
+/// Note: There is no need to know the size of the input upfront for this method,
+/// since the lines are assigned to chunks randomly and the size of each chunk
+/// does not need to be estimated. As a result, "infinite" inputs are supported
+/// for this method, i.e. `yes | split -n r/10` or `yes | split -n r/3/11`
 ///
-/// This function always creates one output file for each chunk, even
+/// In Kth chunk of N mode - writes to stdout the contents of the chunk identified by `kth_chunk`
+///
+/// In N chunks mode - this function always creates one output file for each chunk, even
 /// if there is an error reading or writing one of the chunks or if
-/// the input file is truncated. However, if the `filter` option is
-/// being used, then no files are created.
+/// the input file is truncated. However, if the `--filter` option is
+/// being used, then files will only be created if `$FILE` variable was used
+/// in filter command,
+/// i.e. `split -n r/10 --filter='head -c1 > $FILE' in`
 ///
 /// # Errors
 ///
@@ -1362,105 +1556,67 @@ where
 ///
 /// # See also
 ///
-/// * [`split_into_n_chunks_by_line`], which splits its input in the same way,
-///   but without round robin distribution.
+/// * [`n_chunks_by_line`], which splits its input into a specific number of chunks by line.
 ///
 /// Implements `--number=CHUNKS`
 /// Where CHUNKS
 /// * r/N
-fn split_into_n_chunks_by_line_round_robin<R>(
+/// * r/K/N
+fn n_chunks_by_line_round_robin<R>(
     settings: &Settings,
     reader: &mut R,
     num_chunks: u64,
+    kth_chunk: Option<u64>,
 ) -> UResult<()>
 where
     R: BufRead,
 {
-    // This object is responsible for creating the filename for each chunk.
-    let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)
-        .map_err(|e| io::Error::new(ErrorKind::Other, format!("{e}")))?;
-
-    // Create one writer for each chunk. This will create each
-    // of the underlying files (if not in `--filter` mode).
-    let mut writers = vec![];
-    for _ in 0..num_chunks {
-        let filename = filename_iterator
-            .next()
-            .ok_or_else(|| io::Error::new(ErrorKind::Other, "output file suffixes exhausted"))?;
-        let writer = settings.instantiate_current_writer(filename.as_str())?;
-        writers.push(writer);
+    // In Kth chunk of N mode - we will write to stdout instead of to a file.
+    let mut stdout_writer = std::io::stdout().lock();
+    // In N chunks mode - we will write to `num_chunks` files
+    let mut out_files: OutFiles = OutFiles::new();
+
+    // If in N chunks mode
+    // Create one writer for each chunk.
+    // This will create each of the underlying files
+    // or stdin pipes to child shell/command processes if in `--filter` mode
+    if kth_chunk.is_none() {
+        out_files = OutFiles::init(num_chunks, settings, settings.elide_empty_files)?;
     }
 
     let num_chunks: usize = num_chunks.try_into().unwrap();
     let sep = settings.separator;
     let mut closed_writers = 0;
-    for (i, line_result) in reader.split(sep).enumerate() {
-        let maybe_writer = writers.get_mut(i % num_chunks);
-        let writer = maybe_writer.unwrap();
-        let mut line = line_result.unwrap();
-        line.push(sep);
-        let bytes = line.as_slice();
-        let writer_stdin_open = custom_write_all(bytes, writer, settings)?;
-        if !writer_stdin_open {
-            closed_writers += 1;
-            if closed_writers == num_chunks {
-                // all writers are closed - stop reading
-                break;
-            }
-        }
-    }
 
-    Ok(())
-}
+    let mut i = 0;
+    loop {
+        let line = &mut Vec::new();
+        let num_bytes_read = reader.by_ref().read_until(sep, line)?;
 
-/// Print the k-th chunk of a file, splitting by line, but
-/// assign lines via round-robin to the specified number of output
-/// chunks, but output only the *k*th chunk.
-///
-/// This function is like [`kth_chunk_by_line`], as it only writes to stdout and
-/// prints out only *k*th chunk
-/// It is also like [`split_into_n_chunks_by_line_round_robin`], as it is assigning chunks
-/// using round robin distribution
-///
-/// # Errors
-///
-/// This function returns an error if there is a problem reading from
-/// `reader` or writing to one of the output files.
-///
-/// # See also
-///
-/// * [`split_into_n_chunks_by_line_round_robin`], which splits its input in the
-///   same way, but writes each chunk to its own file.
-///
-/// Implements `--number=CHUNKS`
-/// Where CHUNKS
-/// * r/K/N
-fn kth_chunk_by_line_round_robin<R>(
-    settings: &Settings,
-    reader: &mut R,
-    chunk_number: u64,
-    num_chunks: u64,
-) -> UResult<()>
-where
-    R: BufRead,
-{
-    // Write to stdout instead of to a file.
-    let stdout = std::io::stdout();
-    let mut writer = stdout.lock();
+        // if there is nothing else to read - exit the loop
+        if num_bytes_read == 0 {
+            break;
+        };
 
-    let num_chunks: usize = num_chunks.try_into().unwrap();
-    let chunk_number: usize = chunk_number.try_into().unwrap();
-    let sep = settings.separator;
-    // The chunk number is given as a 1-indexed number, but it
-    // is a little easier to deal with a 0-indexed number
-    // since `.enumerate()` returns index `i` starting with 0
-    let chunk_number = chunk_number - 1;
-    for (i, line_result) in reader.split(sep).enumerate() {
-        let line = line_result?;
         let bytes = line.as_slice();
-        if (i % num_chunks) == chunk_number {
-            writer.write_all(bytes)?;
-            writer.write_all(&[sep])?;
+        match kth_chunk {
+            Some(chunk_number) => {
+                if (i % num_chunks) == (chunk_number - 1) as usize {
+                    stdout_writer.write_all(bytes)?;
+                }
+            }
+            None => {
+                let writer = out_files.get_writer(i % num_chunks, settings)?;
+                let writer_stdin_open = custom_write_all(bytes, writer, settings)?;
+                if !writer_stdin_open {
+                    closed_writers += 1;
+                }
+            }
+        }
+        i += 1;
+        if closed_writers == num_chunks {
+            // all writers are closed - stop reading
+            break;
         }
     }
     Ok(())
@@ -1468,7 +1624,7 @@ where
 
 #[allow(clippy::cognitive_complexity)]
 fn split(settings: &Settings) -> UResult<()> {
-    let mut reader = BufReader::new(if settings.input == "-" {
+    let r_box = if settings.input == "-" {
         Box::new(stdin()) as Box<dyn Read>
     } else {
         let r = File::open(Path::new(&settings.input)).map_err_context(|| {
@@ -1478,26 +1634,33 @@ fn split(settings: &Settings) -> UResult<()> {
             )
         })?;
         Box::new(r) as Box<dyn Read>
-    });
+    };
+    let mut reader = if let Some(c) = settings.io_blksize {
+        BufReader::with_capacity(c, r_box)
+    } else {
+        BufReader::new(r_box)
+    };
 
     match settings.strategy {
         Strategy::Number(NumberType::Bytes(num_chunks)) => {
-            split_into_n_chunks_by_byte(settings, &mut reader, num_chunks)
+            // split_into_n_chunks_by_byte(settings, &mut reader, num_chunks)
+            n_chunks_by_byte(settings, &mut reader, num_chunks, None)
         }
         Strategy::Number(NumberType::KthBytes(chunk_number, num_chunks)) => {
-            kth_chunks_by_byte(settings, &mut reader, chunk_number, num_chunks)
+            // kth_chunks_by_byte(settings, &mut reader, chunk_number, num_chunks)
+            n_chunks_by_byte(settings, &mut reader, num_chunks, Some(chunk_number))
         }
         Strategy::Number(NumberType::Lines(num_chunks)) => {
-            split_into_n_chunks_by_line(settings, &mut reader, num_chunks)
+            n_chunks_by_line(settings, &mut reader, num_chunks, None)
         }
         Strategy::Number(NumberType::KthLines(chunk_number, num_chunks)) => {
-            kth_chunk_by_line(settings, &mut reader, chunk_number, num_chunks)
+            n_chunks_by_line(settings, &mut reader, num_chunks, Some(chunk_number))
         }
         Strategy::Number(NumberType::RoundRobin(num_chunks)) => {
-            split_into_n_chunks_by_line_round_robin(settings, &mut reader, num_chunks)
+            n_chunks_by_line_round_robin(settings, &mut reader, num_chunks, None)
         }
         Strategy::Number(NumberType::KthRoundRobin(chunk_number, num_chunks)) => {
-            kth_chunk_by_line_round_robin(settings, &mut reader, chunk_number, num_chunks)
+            n_chunks_by_line_round_robin(settings, &mut reader, num_chunks, Some(chunk_number))
         }
         Strategy::Lines(chunk_size) => {
             let mut writer = LineChunkWriter::new(chunk_size, settings)?;
diff --git a/src/uu/split/src/strategy.rs b/src/uu/split/src/strategy.rs
index e85abcee58b..7b934f72047 100644
--- a/src/uu/split/src/strategy.rs
+++ b/src/uu/split/src/strategy.rs
@@ -8,7 +8,10 @@
 use crate::{OPT_BYTES, OPT_LINES, OPT_LINE_BYTES, OPT_NUMBER};
 use clap::{parser::ValueSource, ArgMatches};
 use std::fmt;
-use uucore::parse_size::{parse_size_u64, parse_size_u64_max, ParseSizeError};
+use uucore::{
+    display::Quotable,
+    parse_size::{parse_size_u64, parse_size_u64_max, ParseSizeError},
+};
 
 /// Sub-strategy of the [`Strategy::Number`]
 /// Splitting a file into a specific number of chunks.
@@ -208,10 +211,10 @@ impl fmt::Display for StrategyError {
             Self::Lines(e) => write!(f, "invalid number of lines: {e}"),
             Self::Bytes(e) => write!(f, "invalid number of bytes: {e}"),
             Self::NumberType(NumberTypeError::NumberOfChunks(s)) => {
-                write!(f, "invalid number of chunks: {s}")
+                write!(f, "invalid number of chunks: {}", s.quote())
             }
             Self::NumberType(NumberTypeError::ChunkNumber(s)) => {
-                write!(f, "invalid chunk number: {s}")
+                write!(f, "invalid chunk number: {}", s.quote())
             }
             Self::MultipleWays => write!(f, "cannot split in more than one way"),
         }
diff --git a/src/uu/stat/Cargo.toml b/src/uu/stat/Cargo.toml
index 5ed91a88cb6..dd28fc5f382 100644
--- a/src/uu/stat/Cargo.toml
+++ b/src/uu/stat/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_stat"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stat ~ (uutils) display FILE status"
diff --git a/src/uu/stdbuf/Cargo.toml b/src/uu/stdbuf/Cargo.toml
index ed7a0e2e11e..fdee4f68433 100644
--- a/src/uu/stdbuf/Cargo.toml
+++ b/src/uu/stdbuf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_stdbuf"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stdbuf ~ (uutils) run COMMAND with modified standard stream buffering"
@@ -20,7 +20,7 @@ tempfile = { workspace = true }
 uucore = { workspace = true }
 
 [build-dependencies]
-libstdbuf = { version = "0.0.23", package = "uu_stdbuf_libstdbuf", path = "src/libstdbuf" }
+libstdbuf = { version = "0.0.24", package = "uu_stdbuf_libstdbuf", path = "src/libstdbuf" }
 
 [[bin]]
 name = "stdbuf"
diff --git a/src/uu/stdbuf/src/libstdbuf/Cargo.toml b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
index be97c47aeaf..eab74dc089e 100644
--- a/src/uu/stdbuf/src/libstdbuf/Cargo.toml
+++ b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_stdbuf_libstdbuf"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stdbuf/libstdbuf ~ (uutils); dynamic library required for stdbuf"
@@ -22,7 +22,6 @@ crate-type = [
 [dependencies]
 cpp = "0.5"
 libc = { workspace = true }
-uucore = { version = ">=0.0.19", package = "uucore", path = "../../../../uucore" }
 
 [build-dependencies]
 cpp_build = "0.5"
diff --git a/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs b/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
index a29d01b78f3..d744ca4c545 100644
--- a/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
+++ b/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
@@ -5,10 +5,9 @@
 // spell-checker:ignore (ToDO) IOFBF IOLBF IONBF cstdio setvbuf
 
 use cpp::cpp;
-use libc::{c_char, c_int, size_t, FILE, _IOFBF, _IOLBF, _IONBF};
+use libc::{c_char, c_int, fileno, size_t, FILE, _IOFBF, _IOLBF, _IONBF};
 use std::env;
 use std::ptr;
-use uucore::crash;
 
 cpp! {{
     #include <cstdio>
@@ -40,7 +39,10 @@ fn set_buffer(stream: *mut FILE, value: &str) {
         input => {
             let buff_size: usize = match input.parse() {
                 Ok(num) => num,
-                Err(e) => crash!(1, "incorrect size of buffer!: {}", e),
+                Err(_) => {
+                    eprintln!("failed to allocate a {} byte stdio buffer", value);
+                    std::process::exit(1);
+                }
             };
             (_IOFBF, buff_size as size_t)
         }
@@ -52,7 +54,11 @@ fn set_buffer(stream: *mut FILE, value: &str) {
         res = libc::setvbuf(stream, buffer, mode, size);
     }
     if res != 0 {
-        crash!(res, "error while calling setvbuf!");
+        eprintln!(
+            "could not set buffering of {} to mode {}",
+            unsafe { fileno(stream) },
+            mode
+        );
     }
 }
 
diff --git a/src/uu/stdbuf/src/stdbuf.rs b/src/uu/stdbuf/src/stdbuf.rs
index 8578282752e..2436274e7f8 100644
--- a/src/uu/stdbuf/src/stdbuf.rs
+++ b/src/uu/stdbuf/src/stdbuf.rs
@@ -7,7 +7,7 @@
 
 use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use std::fs::File;
-use std::io::{self, Write};
+use std::io::Write;
 use std::os::unix::process::ExitStatusExt;
 use std::path::PathBuf;
 use std::process;
@@ -15,7 +15,7 @@ use tempfile::tempdir;
 use tempfile::TempDir;
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
 use uucore::parse_size::parse_size_u64;
-use uucore::{crash, format_usage, help_about, help_section, help_usage};
+use uucore::{format_usage, help_about, help_section, help_usage};
 
 const ABOUT: &str = help_about!("stdbuf.md");
 const USAGE: &str = help_usage!("stdbuf.md");
@@ -66,13 +66,13 @@ struct ProgramOptionsError(String);
     target_os = "netbsd",
     target_os = "dragonflybsd"
 ))]
-fn preload_strings() -> (&'static str, &'static str) {
-    ("LD_PRELOAD", "so")
+fn preload_strings() -> UResult<(&'static str, &'static str)> {
+    Ok(("LD_PRELOAD", "so"))
 }
 
 #[cfg(target_vendor = "apple")]
-fn preload_strings() -> (&'static str, &'static str) {
-    ("DYLD_LIBRARY_PATH", "dylib")
+fn preload_strings() -> UResult<(&'static str, &'static str)> {
+    Ok(("DYLD_LIBRARY_PATH", "dylib"))
 }
 
 #[cfg(not(any(
@@ -83,10 +83,11 @@ fn preload_strings() -> (&'static str, &'static str) {
     target_os = "dragonflybsd",
     target_vendor = "apple"
 )))]
-fn preload_strings() -> (&'static str, &'static str) {
-    use uucore::crash;
-
-    crash!(1, "Command not supported for this operating system!")
+fn preload_strings() -> UResult<(&'static str, &'static str)> {
+    Err(USimpleError::new(
+        1,
+        "Command not supported for this operating system!",
+    ))
 }
 
 fn check_option(matches: &ArgMatches, name: &str) -> Result<BufferType, ProgramOptionsError> {
@@ -102,7 +103,7 @@ fn check_option(matches: &ArgMatches, name: &str) -> Result<BufferType, ProgramO
                 }
             }
             x => parse_size_u64(x).map_or_else(
-                |e| crash!(125, "invalid mode {}", e),
+                |e| Err(ProgramOptionsError(format!("invalid mode {e}"))),
                 |m| {
                     Ok(BufferType::Size(m.try_into().map_err(|_| {
                         ProgramOptionsError(format!(
@@ -128,8 +129,8 @@ fn set_command_env(command: &mut process::Command, buffer_name: &str, buffer_typ
     }
 }
 
-fn get_preload_env(tmp_dir: &TempDir) -> io::Result<(String, PathBuf)> {
-    let (preload, extension) = preload_strings();
+fn get_preload_env(tmp_dir: &TempDir) -> UResult<(String, PathBuf)> {
+    let (preload, extension) = preload_strings()?;
     let inject_path = tmp_dir.path().join("libstdbuf").with_extension(extension);
 
     let mut file = File::create(&inject_path)?;
@@ -140,8 +141,6 @@ fn get_preload_env(tmp_dir: &TempDir) -> io::Result<(String, PathBuf)> {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let options = ProgramOptions::try_from(&matches).map_err(|e| UUsageError::new(125, e.0))?;
@@ -151,7 +150,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let command_params: Vec<&str> = command_values.map(|s| s.as_ref()).collect();
 
     let tmp_dir = tempdir().unwrap();
-    let (preload_env, libstdbuf) = get_preload_env(&tmp_dir).map_err_context(String::new)?;
+    let (preload_env, libstdbuf) = get_preload_env(&tmp_dir)?;
     command.env(preload_env, libstdbuf);
     set_command_env(&mut command, "_STDBUF_I", &options.stdin);
     set_command_env(&mut command, "_STDBUF_O", &options.stdout);
diff --git a/src/uu/stty/Cargo.toml b/src/uu/stty/Cargo.toml
index a353c66030f..51863220d5f 100644
--- a/src/uu/stty/Cargo.toml
+++ b/src/uu/stty/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_stty"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stty ~ (uutils) print or change terminal characteristics"
diff --git a/src/uu/stty/src/stty.rs b/src/uu/stty/src/stty.rs
index 669285750b4..5a5c31f5e60 100644
--- a/src/uu/stty/src/stty.rs
+++ b/src/uu/stty/src/stty.rs
@@ -176,8 +176,6 @@ ioctl_write_ptr_bad!(
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let opts = Options::from(&matches)?;
diff --git a/src/uu/sum/Cargo.toml b/src/uu/sum/Cargo.toml
index 04be0fe72db..56711b6fd29 100644
--- a/src/uu/sum/Cargo.toml
+++ b/src/uu/sum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_sum"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sum ~ (uutils) display checksum and block counts for input"
diff --git a/src/uu/sum/src/sum.rs b/src/uu/sum/src/sum.rs
index 38ad3964ec8..d1f383351aa 100644
--- a/src/uu/sum/src/sum.rs
+++ b/src/uu/sum/src/sum.rs
@@ -102,8 +102,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let files: Vec<String> = match matches.get_many::<String>(options::FILE) {
diff --git a/src/uu/sum/sum.md b/src/uu/sum/sum.md
index ca3adb81f36..93dbdbf62d0 100644
--- a/src/uu/sum/sum.md
+++ b/src/uu/sum/sum.md
@@ -1,7 +1,7 @@
 # sum
 
 ```
-sum [OPTION]... [FILE]..."
+sum [OPTION]... [FILE]...
 ```
 
 Checksum and count the blocks in a file.
diff --git a/src/uu/sync/Cargo.toml b/src/uu/sync/Cargo.toml
index 4048115243a..0c93433928c 100644
--- a/src/uu/sync/Cargo.toml
+++ b/src/uu/sync/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_sync"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sync ~ (uutils) synchronize cache writes to storage"
diff --git a/src/uu/tac/Cargo.toml b/src/uu/tac/Cargo.toml
index 164972c5f45..a89f179e388 100644
--- a/src/uu/tac/Cargo.toml
+++ b/src/uu/tac/Cargo.toml
@@ -2,7 +2,7 @@
 
 [package]
 name = "uu_tac"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tac ~ (uutils) concatenate and display input lines in reverse order"
diff --git a/src/uu/tac/src/tac.rs b/src/uu/tac/src/tac.rs
index b8cb61029da..3865c61ae48 100644
--- a/src/uu/tac/src/tac.rs
+++ b/src/uu/tac/src/tac.rs
@@ -33,8 +33,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let before = matches.get_flag(options::BEFORE);
diff --git a/src/uu/tail/Cargo.toml b/src/uu/tail/Cargo.toml
index 636480e08ba..826f7f83daf 100644
--- a/src/uu/tail/Cargo.toml
+++ b/src/uu/tail/Cargo.toml
@@ -1,7 +1,7 @@
 # spell-checker:ignore (libs) kqueue fundu
 [package]
 name = "uu_tail"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tail ~ (uutils) display the last lines of input"
diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs
index 0488e0808ed..edac4b151cb 100644
--- a/src/uu/tail/src/tail.rs
+++ b/src/uu/tail/src/tail.rs
@@ -31,7 +31,7 @@ use std::fs::File;
 use std::io::{self, stdin, stdout, BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
-use uucore::error::{get_exit_code, set_exit_code, FromIo, UError, UResult, USimpleError};
+use uucore::error::{get_exit_code, set_exit_code, FromIo, UResult, USimpleError};
 use uucore::{show, show_error};
 
 #[uucore::main]
diff --git a/src/uu/tee/Cargo.toml b/src/uu/tee/Cargo.toml
index 441b891a4ad..b84e7cb314a 100644
--- a/src/uu/tee/Cargo.toml
+++ b/src/uu/tee/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_tee"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tee ~ (uutils) display input and copy to FILE"
diff --git a/src/uu/test/Cargo.toml b/src/uu/test/Cargo.toml
index bc27511867e..35132cd27b2 100644
--- a/src/uu/test/Cargo.toml
+++ b/src/uu/test/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_test"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "test ~ (uutils) evaluate comparison and file type expressions"
@@ -17,7 +17,7 @@ path = "src/test.rs"
 [dependencies]
 clap = { workspace = true }
 libc = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["process"] }
 
 [target.'cfg(target_os = "redox")'.dependencies]
 redox_syscall = { workspace = true }
diff --git a/src/uu/test/src/test.rs b/src/uu/test/src/test.rs
index 4f230a590df..9d3c2b29031 100644
--- a/src/uu/test/src/test.rs
+++ b/src/uu/test/src/test.rs
@@ -17,6 +17,8 @@ use std::fs;
 use std::os::unix::fs::MetadataExt;
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
+#[cfg(not(windows))]
+use uucore::process::{getegid, geteuid};
 use uucore::{format_usage, help_about, help_section};
 
 const ABOUT: &str = help_about!("test.md");
@@ -27,10 +29,11 @@ const ABOUT: &str = help_about!("test.md");
 // So, we use test or [ instead of {} so that the usage string is correct.
 const USAGE: &str = "\
 test EXPRESSION
-test
+[
 [ EXPRESSION ]
 [ ]
-[ OPTION";
+[ OPTION
+]";
 
 // We use after_help so that this comes after the usage string (it would come before if we used about)
 const AFTER_HELP: &str = help_section!("after help", "test.md");
@@ -276,7 +279,7 @@ fn path(path: &OsStr, condition: &PathCondition) -> bool {
 
     let geteuid = || {
         #[cfg(not(target_os = "redox"))]
-        let euid = unsafe { libc::geteuid() };
+        let euid = geteuid();
         #[cfg(target_os = "redox")]
         let euid = syscall::geteuid().unwrap() as u32;
 
@@ -285,7 +288,7 @@ fn path(path: &OsStr, condition: &PathCondition) -> bool {
 
     let getegid = || {
         #[cfg(not(target_os = "redox"))]
-        let egid = unsafe { libc::getegid() };
+        let egid = getegid();
         #[cfg(target_os = "redox")]
         let egid = syscall::getegid().unwrap() as u32;
 
diff --git a/src/uu/test/test.md b/src/uu/test/test.md
index e67eb1824ab..b198c220b24 100644
--- a/src/uu/test/test.md
+++ b/src/uu/test/test.md
@@ -2,10 +2,11 @@
 
 ```
 test EXPRESSION
-test
+[
 [ EXPRESSION ]
 [ ]
 [ OPTION
+]
 ```
 
 Check file types and compare values.
diff --git a/src/uu/timeout/Cargo.toml b/src/uu/timeout/Cargo.toml
index 4f6c062bb8a..3a9500a2e96 100644
--- a/src/uu/timeout/Cargo.toml
+++ b/src/uu/timeout/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_timeout"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "timeout ~ (uutils) run COMMAND with a DURATION time limit"
diff --git a/src/uu/timeout/src/timeout.rs b/src/uu/timeout/src/timeout.rs
index 5e73fe2ab50..958bc647e10 100644
--- a/src/uu/timeout/src/timeout.rs
+++ b/src/uu/timeout/src/timeout.rs
@@ -107,8 +107,6 @@ impl Config {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
 
     let config = Config::from(&matches)?;
diff --git a/src/uu/touch/Cargo.toml b/src/uu/touch/Cargo.toml
index d67cd1f8a16..51cc4ac3f41 100644
--- a/src/uu/touch/Cargo.toml
+++ b/src/uu/touch/Cargo.toml
@@ -1,7 +1,7 @@
 # spell-checker:ignore datetime
 [package]
 name = "uu_touch"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "touch ~ (uutils) change FILE timestamps"
diff --git a/src/uu/touch/src/touch.rs b/src/uu/touch/src/touch.rs
index d9399a051f6..ebdff8d2116 100644
--- a/src/uu/touch/src/touch.rs
+++ b/src/uu/touch/src/touch.rs
@@ -11,13 +11,13 @@ use chrono::{
     TimeZone, Timelike,
 };
 use clap::builder::ValueParser;
-use clap::{crate_version, Arg, ArgAction, ArgGroup, Command};
+use clap::{crate_version, Arg, ArgAction, ArgGroup, ArgMatches, Command};
 use filetime::{set_file_times, set_symlink_file_times, FileTime};
 use std::ffi::OsString;
 use std::fs::{self, File};
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::error::{FromIo, UResult, USimpleError};
 use uucore::{format_usage, help_about, help_usage, show};
 
 const ABOUT: &str = help_about!("touch.md");
@@ -73,7 +73,6 @@ fn filetime_to_datetime(ft: &FileTime) -> Option<DateTime<Local>> {
 }
 
 #[uucore::main]
-#[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
 
@@ -86,37 +85,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             ),
         )
     })?;
-    let (mut atime, mut mtime) = match (
-        matches.get_one::<OsString>(options::sources::REFERENCE),
-        matches.get_one::<String>(options::sources::DATE),
-    ) {
-        (Some(reference), Some(date)) => {
-            let (atime, mtime) = stat(Path::new(reference), !matches.get_flag(options::NO_DEREF))?;
-            let atime = filetime_to_datetime(&atime).ok_or_else(|| {
-                USimpleError::new(1, "Could not process the reference access time")
-            })?;
-            let mtime = filetime_to_datetime(&mtime).ok_or_else(|| {
-                USimpleError::new(1, "Could not process the reference modification time")
-            })?;
-            (parse_date(atime, date)?, parse_date(mtime, date)?)
-        }
-        (Some(reference), None) => {
-            stat(Path::new(reference), !matches.get_flag(options::NO_DEREF))?
-        }
-        (None, Some(date)) => {
-            let timestamp = parse_date(Local::now(), date)?;
-            (timestamp, timestamp)
-        }
-        (None, None) => {
-            let timestamp = if let Some(ts) = matches.get_one::<String>(options::sources::TIMESTAMP)
-            {
-                parse_timestamp(ts)?
-            } else {
-                datetime_to_filetime(&Local::now())
-            };
-            (timestamp, timestamp)
-        }
-    };
+
+    let (atime, mtime) = determine_times(&matches)?;
 
     for filename in files {
         // FIXME: find a way to avoid having to clone the path
@@ -165,48 +135,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             }
         }
 
-        // If changing "only" atime or mtime, grab the existing value of the other.
-        // Note that "-a" and "-m" may be passed together; this is not an xor.
-        if matches.get_flag(options::ACCESS)
-            || matches.get_flag(options::MODIFICATION)
-            || matches.contains_id(options::TIME)
-        {
-            let st = stat(path, !matches.get_flag(options::NO_DEREF))?;
-            let time = matches
-                .get_one::<String>(options::TIME)
-                .map(|s| s.as_str())
-                .unwrap_or("");
-
-            if !(matches.get_flag(options::ACCESS)
-                || time.contains(&"access".to_owned())
-                || time.contains(&"atime".to_owned())
-                || time.contains(&"use".to_owned()))
-            {
-                atime = st.0;
-            }
-
-            if !(matches.get_flag(options::MODIFICATION)
-                || time.contains(&"modify".to_owned())
-                || time.contains(&"mtime".to_owned()))
-            {
-                mtime = st.1;
-            }
-        }
-
-        // sets the file access and modification times for a file or a symbolic link.
-        // The filename, access time (atime), and modification time (mtime) are provided as inputs.
-
-        // If the filename is not "-", indicating a special case for touch -h -,
-        // the code checks if the NO_DEREF flag is set, which means the user wants to
-        // set the times for a symbolic link itself, rather than the file it points to.
-        if filename == "-" {
-            filetime::set_file_times(path, atime, mtime)
-        } else if matches.get_flag(options::NO_DEREF) {
-            set_symlink_file_times(path, atime, mtime)
-        } else {
-            set_file_times(path, atime, mtime)
-        }
-        .map_err_context(|| format!("setting times of {}", path.quote()))?;
+        update_times(&matches, path, atime, mtime, filename)?;
     }
     Ok(())
 }
@@ -307,6 +236,92 @@ pub fn uu_app() -> Command {
         )
 }
 
+// Determine the access and modification time
+fn determine_times(matches: &ArgMatches) -> UResult<(FileTime, FileTime)> {
+    match (
+        matches.get_one::<OsString>(options::sources::REFERENCE),
+        matches.get_one::<String>(options::sources::DATE),
+    ) {
+        (Some(reference), Some(date)) => {
+            let (atime, mtime) = stat(Path::new(&reference), !matches.get_flag(options::NO_DEREF))?;
+            let atime = filetime_to_datetime(&atime).ok_or_else(|| {
+                USimpleError::new(1, "Could not process the reference access time")
+            })?;
+            let mtime = filetime_to_datetime(&mtime).ok_or_else(|| {
+                USimpleError::new(1, "Could not process the reference modification time")
+            })?;
+            Ok((parse_date(atime, date)?, parse_date(mtime, date)?))
+        }
+        (Some(reference), None) => {
+            stat(Path::new(&reference), !matches.get_flag(options::NO_DEREF))
+        }
+        (None, Some(date)) => {
+            let timestamp = parse_date(Local::now(), date)?;
+            Ok((timestamp, timestamp))
+        }
+        (None, None) => {
+            let timestamp = if let Some(ts) = matches.get_one::<String>(options::sources::TIMESTAMP)
+            {
+                parse_timestamp(ts)?
+            } else {
+                datetime_to_filetime(&Local::now())
+            };
+            Ok((timestamp, timestamp))
+        }
+    }
+}
+
+// Updating file access and modification times based on user-specified options
+fn update_times(
+    matches: &ArgMatches,
+    path: &Path,
+    mut atime: FileTime,
+    mut mtime: FileTime,
+    filename: &OsString,
+) -> UResult<()> {
+    // If changing "only" atime or mtime, grab the existing value of the other.
+    // Note that "-a" and "-m" may be passed together; this is not an xor.
+    if matches.get_flag(options::ACCESS)
+        || matches.get_flag(options::MODIFICATION)
+        || matches.contains_id(options::TIME)
+    {
+        let st = stat(path, !matches.get_flag(options::NO_DEREF))?;
+        let time = matches
+            .get_one::<String>(options::TIME)
+            .map(|s| s.as_str())
+            .unwrap_or("");
+
+        if !(matches.get_flag(options::ACCESS)
+            || time.contains(&"access".to_owned())
+            || time.contains(&"atime".to_owned())
+            || time.contains(&"use".to_owned()))
+        {
+            atime = st.0;
+        }
+
+        if !(matches.get_flag(options::MODIFICATION)
+            || time.contains(&"modify".to_owned())
+            || time.contains(&"mtime".to_owned()))
+        {
+            mtime = st.1;
+        }
+    }
+
+    // sets the file access and modification times for a file or a symbolic link.
+    // The filename, access time (atime), and modification time (mtime) are provided as inputs.
+
+    // If the filename is not "-", indicating a special case for touch -h -,
+    // the code checks if the NO_DEREF flag is set, which means the user wants to
+    // set the times for a symbolic link itself, rather than the file it points to.
+    if filename == "-" {
+        filetime::set_file_times(path, atime, mtime)
+    } else if matches.get_flag(options::NO_DEREF) {
+        set_symlink_file_times(path, atime, mtime)
+    } else {
+        set_file_times(path, atime, mtime)
+    }
+    .map_err_context(|| format!("setting times of {}", path.quote()))
+}
 // Get metadata of the provided path
 // If `follow` is `true`, the function will try to follow symlinks
 // If `follow` is `false` or the symlink is broken, the function will return metadata of the symlink itself
diff --git a/src/uu/tr/Cargo.toml b/src/uu/tr/Cargo.toml
index a07679dd187..ff1efbe921f 100644
--- a/src/uu/tr/Cargo.toml
+++ b/src/uu/tr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_tr"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tr ~ (uutils) translate characters within input and display"
diff --git a/src/uu/tr/src/convert.rs b/src/uu/tr/src/convert.rs
deleted file mode 100644
index 28a80e9f52e..00000000000
--- a/src/uu/tr/src/convert.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-
-// spell-checker:ignore (strings) anychar combinator
-
-use nom::{
-    branch::alt,
-    bytes::complete::tag,
-    character::complete::{anychar, one_of},
-    combinator::{map_opt, recognize},
-    multi::{many0, many_m_n},
-    sequence::preceded,
-    IResult,
-};
-
-fn parse_octal(input: &str) -> IResult<&str, char> {
-    map_opt(
-        preceded(tag("\\"), recognize(many_m_n(1, 3, one_of("01234567")))),
-        |out: &str| {
-            u32::from_str_radix(out, 8)
-                .map(std::char::from_u32)
-                .ok()
-                .flatten()
-        },
-    )(input)
-}
-
-pub fn reduce_octal_to_char(input: &str) -> String {
-    many0(alt((parse_octal, anychar)))(input)
-        .map(|(_, r)| r)
-        .unwrap()
-        .into_iter()
-        .collect()
-}
diff --git a/src/uu/tr/src/operation.rs b/src/uu/tr/src/operation.rs
index b7d74427a9e..5565de6a16d 100644
--- a/src/uu/tr/src/operation.rs
+++ b/src/uu/tr/src/operation.rs
@@ -3,14 +3,14 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (strings) anychar combinator Alnum Punct Xdigit alnum punct xdigit cntrl
+// spell-checker:ignore (strings) anychar combinator Alnum Punct Xdigit alnum punct xdigit cntrl boop
 
 use nom::{
     branch::alt,
-    bytes::complete::tag,
-    character::complete::{anychar, digit1},
-    combinator::{map, peek, value},
-    multi::many0,
+    bytes::complete::{tag, take},
+    character::complete::{digit1, one_of},
+    combinator::{map, map_opt, peek, recognize, value},
+    multi::{many0, many_m_n},
     sequence::{delimited, preceded, separated_pair},
     IResult,
 };
@@ -62,10 +62,10 @@ impl UError for BadSequence {}
 
 #[derive(Debug, Clone, Copy)]
 pub enum Sequence {
-    Char(char),
-    CharRange(u32, u32),
-    CharStar(char),
-    CharRepeat(char, usize),
+    Char(u8),
+    CharRange(u8, u8),
+    CharStar(u8),
+    CharRepeat(u8, usize),
     Alnum,
     Alpha,
     Blank,
@@ -81,21 +81,17 @@ pub enum Sequence {
 }
 
 impl Sequence {
-    pub fn flatten(&self) -> Box<dyn Iterator<Item = char>> {
+    pub fn flatten(&self) -> Box<dyn Iterator<Item = u8>> {
         match self {
             Self::Char(c) => Box::new(std::iter::once(*c)),
-            Self::CharRange(l, r) => Box::new((*l..=*r).flat_map(std::char::from_u32)),
+            Self::CharRange(l, r) => Box::new(*l..=*r),
             Self::CharStar(c) => Box::new(std::iter::repeat(*c)),
             Self::CharRepeat(c, n) => Box::new(std::iter::repeat(*c).take(*n)),
-            Self::Alnum => Box::new(('0'..='9').chain('A'..='Z').chain('a'..='z')),
-            Self::Alpha => Box::new(('A'..='Z').chain('a'..='z')),
+            Self::Alnum => Box::new((b'0'..=b'9').chain(b'A'..=b'Z').chain(b'a'..=b'z')),
+            Self::Alpha => Box::new((b'A'..=b'Z').chain(b'a'..=b'z')),
             Self::Blank => Box::new(unicode_table::BLANK.iter().cloned()),
-            Self::Control => Box::new(
-                (0..=31)
-                    .chain(std::iter::once(127))
-                    .flat_map(std::char::from_u32),
-            ),
-            Self::Digit => Box::new('0'..='9'),
+            Self::Control => Box::new((0..=31).chain(std::iter::once(127))),
+            Self::Digit => Box::new(b'0'..=b'9'),
             Self::Graph => Box::new(
                 (48..=57) // digit
                     .chain(65..=90) // uppercase
@@ -105,10 +101,9 @@ impl Sequence {
                     .chain(58..=64)
                     .chain(91..=96)
                     .chain(123..=126)
-                    .chain(std::iter::once(32)) // space
-                    .flat_map(std::char::from_u32),
+                    .chain(std::iter::once(32)), // space
             ),
-            Self::Lower => Box::new('a'..='z'),
+            Self::Lower => Box::new(b'a'..=b'z'),
             Self::Print => Box::new(
                 (48..=57) // digit
                     .chain(65..=90) // uppercase
@@ -117,29 +112,22 @@ impl Sequence {
                     .chain(33..=47)
                     .chain(58..=64)
                     .chain(91..=96)
-                    .chain(123..=126)
-                    .flat_map(std::char::from_u32),
-            ),
-            Self::Punct => Box::new(
-                (33..=47)
-                    .chain(58..=64)
-                    .chain(91..=96)
-                    .chain(123..=126)
-                    .flat_map(std::char::from_u32),
+                    .chain(123..=126),
             ),
+            Self::Punct => Box::new((33..=47).chain(58..=64).chain(91..=96).chain(123..=126)),
             Self::Space => Box::new(unicode_table::SPACES.iter().cloned()),
-            Self::Upper => Box::new('A'..='Z'),
-            Self::Xdigit => Box::new(('0'..='9').chain('A'..='F').chain('a'..='f')),
+            Self::Upper => Box::new(b'A'..=b'Z'),
+            Self::Xdigit => Box::new((b'0'..=b'9').chain(b'A'..=b'F').chain(b'a'..=b'f')),
         }
     }
 
     // Hide all the nasty sh*t in here
     // TODO: Make the 2 set lazily generate the character mapping as necessary.
     pub fn solve_set_characters(
-        set1_str: &str,
-        set2_str: &str,
+        set1_str: &[u8],
+        set2_str: &[u8],
         truncate_set1_flag: bool,
-    ) -> Result<(Vec<char>, Vec<char>), BadSequence> {
+    ) -> Result<(Vec<u8>, Vec<u8>), BadSequence> {
         let set1 = Self::from_str(set1_str)?;
         let set2 = Self::from_str(set2_str)?;
 
@@ -164,7 +152,7 @@ impl Sequence {
                     .count();
                 let star_compensate_len = set1_len.saturating_sub(set2_len);
                 let (left, right) = (partition.next(), partition.next());
-                let set2_solved: Vec<char> = match (left, right) {
+                let set2_solved: Vec<_> = match (left, right) {
                     (None, None) => match char_star {
                         Some(c) => std::iter::repeat(*c).take(star_compensate_len).collect(),
                         None => std::iter::empty().collect(),
@@ -201,7 +189,7 @@ impl Sequence {
                             .collect(),
                     },
                 };
-                let mut set1_solved: Vec<char> = set1.iter().flat_map(Self::flatten).collect();
+                let mut set1_solved: Vec<_> = set1.iter().flat_map(Self::flatten).collect();
                 if truncate_set1_flag {
                     set1_solved.truncate(set2_solved.len());
                 }
@@ -216,7 +204,7 @@ impl Sequence {
 }
 
 impl Sequence {
-    pub fn from_str(input: &str) -> Result<Vec<Self>, BadSequence> {
+    pub fn from_str(input: &[u8]) -> Result<Vec<Self>, BadSequence> {
         many0(alt((
             Self::parse_char_range,
             Self::parse_char_star,
@@ -232,27 +220,38 @@ impl Sequence {
         .collect::<Result<Vec<_>, _>>()
     }
 
-    fn parse_backslash(input: &str) -> IResult<&str, char> {
-        preceded(tag("\\"), anychar)(input).map(|(l, a)| {
+    fn parse_octal(input: &[u8]) -> IResult<&[u8], u8> {
+        map_opt(
+            preceded(tag("\\"), recognize(many_m_n(1, 3, one_of("01234567")))),
+            |out: &[u8]| u8::from_str_radix(std::str::from_utf8(out).expect("boop"), 8).ok(),
+        )(input)
+    }
+
+    fn parse_backslash(input: &[u8]) -> IResult<&[u8], u8> {
+        preceded(tag("\\"), Self::single_char)(input).map(|(l, a)| {
             let c = match a {
-                'a' => unicode_table::BEL,
-                'b' => unicode_table::BS,
-                'f' => unicode_table::FF,
-                'n' => unicode_table::LF,
-                'r' => unicode_table::CR,
-                't' => unicode_table::HT,
-                'v' => unicode_table::VT,
+                b'a' => unicode_table::BEL,
+                b'b' => unicode_table::BS,
+                b'f' => unicode_table::FF,
+                b'n' => unicode_table::LF,
+                b'r' => unicode_table::CR,
+                b't' => unicode_table::HT,
+                b'v' => unicode_table::VT,
                 x => x,
             };
             (l, c)
         })
     }
 
-    fn parse_backslash_or_char(input: &str) -> IResult<&str, char> {
-        alt((Self::parse_backslash, anychar))(input)
+    fn parse_backslash_or_char(input: &[u8]) -> IResult<&[u8], u8> {
+        alt((Self::parse_octal, Self::parse_backslash, Self::single_char))(input)
+    }
+
+    fn single_char(input: &[u8]) -> IResult<&[u8], u8> {
+        take(1usize)(input).map(|(l, a)| (l, a[0]))
     }
 
-    fn parse_char_range(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+    fn parse_char_range(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
         separated_pair(
             Self::parse_backslash_or_char,
             tag("-"),
@@ -261,41 +260,42 @@ impl Sequence {
         .map(|(l, (a, b))| {
             (l, {
                 let (start, end) = (u32::from(a), u32::from(b));
-                Ok(Self::CharRange(start, end))
+                Ok(Self::CharRange(start as u8, end as u8))
             })
         })
     }
 
-    fn parse_char_star(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+    fn parse_char_star(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
         delimited(tag("["), Self::parse_backslash_or_char, tag("*]"))(input)
             .map(|(l, a)| (l, Ok(Self::CharStar(a))))
     }
 
-    fn parse_char_repeat(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+    fn parse_char_repeat(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
         delimited(
             tag("["),
             separated_pair(Self::parse_backslash_or_char, tag("*"), digit1),
             tag("]"),
         )(input)
         .map(|(l, (c, cnt_str))| {
-            let result = if cnt_str.starts_with('0') {
-                match usize::from_str_radix(cnt_str, 8) {
+            let s = String::from_utf8_lossy(cnt_str);
+            let result = if cnt_str.starts_with(b"0") {
+                match usize::from_str_radix(&s, 8) {
                     Ok(0) => Ok(Self::CharStar(c)),
                     Ok(count) => Ok(Self::CharRepeat(c, count)),
-                    Err(_) => Err(BadSequence::InvalidRepeatCount(cnt_str.to_string())),
+                    Err(_) => Err(BadSequence::InvalidRepeatCount(s.to_string())),
                 }
             } else {
-                match cnt_str.parse::<usize>() {
+                match s.parse::<usize>() {
                     Ok(0) => Ok(Self::CharStar(c)),
                     Ok(count) => Ok(Self::CharRepeat(c, count)),
-                    Err(_) => Err(BadSequence::InvalidRepeatCount(cnt_str.to_string())),
+                    Err(_) => Err(BadSequence::InvalidRepeatCount(s.to_string())),
                 }
             };
             (l, result)
         })
     }
 
-    fn parse_class(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+    fn parse_class(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
         delimited(
             tag("[:"),
             alt((
@@ -322,7 +322,7 @@ impl Sequence {
         )(input)
     }
 
-    fn parse_char_equal(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+    fn parse_char_equal(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
         delimited(
             tag("[="),
             alt((
@@ -338,17 +338,17 @@ impl Sequence {
 }
 
 pub trait SymbolTranslator {
-    fn translate(&mut self, current: char) -> Option<char>;
+    fn translate(&mut self, current: u8) -> Option<u8>;
 }
 
 #[derive(Debug)]
 pub struct DeleteOperation {
-    set: Vec<char>,
+    set: Vec<u8>,
     complement_flag: bool,
 }
 
 impl DeleteOperation {
-    pub fn new(set: Vec<char>, complement_flag: bool) -> Self {
+    pub fn new(set: Vec<u8>, complement_flag: bool) -> Self {
         Self {
             set,
             complement_flag,
@@ -357,8 +357,8 @@ impl DeleteOperation {
 }
 
 impl SymbolTranslator for DeleteOperation {
-    fn translate(&mut self, current: char) -> Option<char> {
-        let found = self.set.iter().any(|sequence| sequence.eq(&current));
+    fn translate(&mut self, current: u8) -> Option<u8> {
+        let found = self.set.iter().any(|sequence| *sequence == current);
         if self.complement_flag == found {
             Some(current)
         } else {
@@ -368,15 +368,15 @@ impl SymbolTranslator for DeleteOperation {
 }
 
 pub struct TranslateOperationComplement {
-    iter: u32,
+    iter: u8,
     set2_iter: usize,
-    set1: Vec<char>,
-    set2: Vec<char>,
-    translation_map: HashMap<char, char>,
+    set1: Vec<u8>,
+    set2: Vec<u8>,
+    translation_map: HashMap<u8, u8>,
 }
 
 impl TranslateOperationComplement {
-    fn new(set1: Vec<char>, set2: Vec<char>) -> Self {
+    fn new(set1: Vec<u8>, set2: Vec<u8>) -> Self {
         Self {
             iter: 0,
             set2_iter: 0,
@@ -389,11 +389,11 @@ impl TranslateOperationComplement {
 
 #[derive(Debug)]
 pub struct TranslateOperationStandard {
-    translation_map: HashMap<char, char>,
+    translation_map: HashMap<u8, u8>,
 }
 
 impl TranslateOperationStandard {
-    fn new(set1: Vec<char>, set2: Vec<char>) -> Result<Self, BadSequence> {
+    fn new(set1: Vec<u8>, set2: Vec<u8>) -> Result<Self, BadSequence> {
         if let Some(fallback) = set2.last().copied() {
             Ok(Self {
                 translation_map: set1
@@ -417,18 +417,17 @@ pub enum TranslateOperation {
 }
 
 impl TranslateOperation {
-    fn next_complement_char(iter: u32, ignore_list: &[char]) -> (u32, char) {
+    fn next_complement_char(iter: u8, ignore_list: &[u8]) -> (u8, u8) {
         (iter..)
-            .filter_map(std::char::from_u32)
-            .filter(|c| !ignore_list.iter().any(|s| s.eq(c)))
-            .map(|c| (u32::from(c) + 1, c))
+            .filter(|c| !ignore_list.iter().any(|s| s == c))
+            .map(|c| (c + 1, c))
             .next()
             .expect("exhausted all possible characters")
     }
 }
 
 impl TranslateOperation {
-    pub fn new(set1: Vec<char>, set2: Vec<char>, complement: bool) -> Result<Self, BadSequence> {
+    pub fn new(set1: Vec<u8>, set2: Vec<u8>, complement: bool) -> Result<Self, BadSequence> {
         if complement {
             Ok(Self::Complement(TranslateOperationComplement::new(
                 set1, set2,
@@ -440,7 +439,7 @@ impl TranslateOperation {
 }
 
 impl SymbolTranslator for TranslateOperation {
-    fn translate(&mut self, current: char) -> Option<char> {
+    fn translate(&mut self, current: u8) -> Option<u8> {
         match self {
             Self::Standard(TranslateOperationStandard { translation_map }) => Some(
                 translation_map
@@ -482,13 +481,13 @@ impl SymbolTranslator for TranslateOperation {
 
 #[derive(Debug, Clone)]
 pub struct SqueezeOperation {
-    set1: HashSet<char>,
+    set1: HashSet<u8>,
     complement: bool,
-    previous: Option<char>,
+    previous: Option<u8>,
 }
 
 impl SqueezeOperation {
-    pub fn new(set1: Vec<char>, complement: bool) -> Self {
+    pub fn new(set1: Vec<u8>, complement: bool) -> Self {
         Self {
             set1: set1.into_iter().collect(),
             complement,
@@ -498,7 +497,7 @@ impl SqueezeOperation {
 }
 
 impl SymbolTranslator for SqueezeOperation {
-    fn translate(&mut self, current: char) -> Option<char> {
+    fn translate(&mut self, current: u8) -> Option<u8> {
         if self.complement {
             let next = if self.set1.contains(&current) {
                 Some(current)
@@ -537,15 +536,15 @@ where
     R: BufRead,
     W: Write,
 {
-    let mut buf = String::new();
-    let mut output_buf = String::new();
-    while let Ok(length) = input.read_line(&mut buf) {
+    let mut buf = Vec::new();
+    let mut output_buf = Vec::new();
+    while let Ok(length) = input.read_until(b'\n', &mut buf) {
         if length == 0 {
             break;
         } else {
-            let filtered = buf.chars().filter_map(|c| translator.translate(c));
+            let filtered = buf.iter().filter_map(|c| translator.translate(*c));
             output_buf.extend(filtered);
-            output.write_all(output_buf.as_bytes()).unwrap();
+            output.write_all(&output_buf).unwrap();
         }
         buf.clear();
         output_buf.clear();
diff --git a/src/uu/tr/src/tr.rs b/src/uu/tr/src/tr.rs
index 9c6e7a7da58..28b99a10f46 100644
--- a/src/uu/tr/src/tr.rs
+++ b/src/uu/tr/src/tr.rs
@@ -5,7 +5,6 @@
 
 // spell-checker:ignore (ToDO) allocs bset dflag cflag sflag tflag
 
-mod convert;
 mod operation;
 mod unicode_table;
 
@@ -33,8 +32,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
 
     let delete_flag = matches.get_flag(options::DELETE);
@@ -42,14 +39,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let squeeze_flag = matches.get_flag(options::SQUEEZE);
     let truncate_set1_flag = matches.get_flag(options::TRUNCATE_SET1);
 
-    let sets = matches
+    // Ultimately this should be OsString, but we might want to wait for the
+    // pattern API on OsStr
+    let sets: Vec<_> = matches
         .get_many::<String>(options::SETS)
-        .map(|v| {
-            v.map(ToString::to_string)
-                .map(|input| convert::reduce_octal_to_char(&input))
-                .collect::<Vec<_>>()
-        })
-        .unwrap_or_default();
+        .into_iter()
+        .flatten()
+        .map(ToOwned::to_owned)
+        .collect();
+
     let sets_len = sets.len();
 
     if sets.is_empty() {
@@ -63,7 +61,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         ));
     }
 
-    if let Some(first) = sets.get(0) {
+    if let Some(first) = sets.first() {
         if first.ends_with('\\') {
             show!(USimpleError::new(
                 0,
@@ -80,8 +78,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let mut sets_iter = sets.iter().map(|c| c.as_str());
     let (set1, set2) = Sequence::solve_set_characters(
-        sets_iter.next().unwrap_or_default(),
-        sets_iter.next().unwrap_or_default(),
+        sets_iter.next().unwrap_or_default().as_bytes(),
+        sets_iter.next().unwrap_or_default().as_bytes(),
         truncate_set1_flag,
     )?;
 
diff --git a/src/uu/tr/src/unicode_table.rs b/src/uu/tr/src/unicode_table.rs
index a00a30b8bee..5d31ab37569 100644
--- a/src/uu/tr/src/unicode_table.rs
+++ b/src/uu/tr/src/unicode_table.rs
@@ -3,13 +3,13 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-pub static BEL: char = '\u{0007}';
-pub static BS: char = '\u{0008}';
-pub static HT: char = '\u{0009}';
-pub static LF: char = '\u{000A}';
-pub static VT: char = '\u{000B}';
-pub static FF: char = '\u{000C}';
-pub static CR: char = '\u{000D}';
-pub static SPACE: char = '\u{0020}';
-pub static SPACES: &[char] = &[HT, LF, VT, FF, CR, SPACE];
-pub static BLANK: &[char] = &[SPACE, HT];
+pub static BEL: u8 = 0x7;
+pub static BS: u8 = 0x8;
+pub static HT: u8 = 0x9;
+pub static LF: u8 = 0xA;
+pub static VT: u8 = 0xB;
+pub static FF: u8 = 0xC;
+pub static CR: u8 = 0xD;
+pub static SPACE: u8 = 0x20;
+pub static SPACES: &[u8] = &[HT, LF, VT, FF, CR, SPACE];
+pub static BLANK: &[u8] = &[SPACE, HT];
diff --git a/src/uu/true/Cargo.toml b/src/uu/true/Cargo.toml
index 8c4080724b6..eae893d2176 100644
--- a/src/uu/true/Cargo.toml
+++ b/src/uu/true/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_true"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "true ~ (uutils) do nothing and succeed"
diff --git a/src/uu/truncate/Cargo.toml b/src/uu/truncate/Cargo.toml
index 254a004e779..2ea443ce7f4 100644
--- a/src/uu/truncate/Cargo.toml
+++ b/src/uu/truncate/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_truncate"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "truncate ~ (uutils) truncate (or extend) FILE to SIZE"
diff --git a/src/uu/tsort/Cargo.toml b/src/uu/tsort/Cargo.toml
index 567d41e0b79..f0430b41b3b 100644
--- a/src/uu/tsort/Cargo.toml
+++ b/src/uu/tsort/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_tsort"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tsort ~ (uutils) topologically sort input (partially ordered) pairs"
diff --git a/src/uu/tsort/src/tsort.rs b/src/uu/tsort/src/tsort.rs
index e71710847ea..2bc9d317576 100644
--- a/src/uu/tsort/src/tsort.rs
+++ b/src/uu/tsort/src/tsort.rs
@@ -20,8 +20,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let input = matches
@@ -34,7 +32,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         stdin_buf = stdin();
         &mut stdin_buf as &mut dyn Read
     } else {
-        file_buf = File::open(Path::new(&input)).map_err_context(|| input.to_string())?;
+        let path = Path::new(&input);
+        if path.is_dir() {
+            return Err(USimpleError::new(
+                1,
+                format!("{}: read error: Is a directory", input),
+            ));
+        }
+        file_buf = File::open(path).map_err_context(|| input.to_string())?;
         &mut file_buf as &mut dyn Read
     });
 
diff --git a/src/uu/tty/Cargo.toml b/src/uu/tty/Cargo.toml
index 95734e6c933..d6065d4679e 100644
--- a/src/uu/tty/Cargo.toml
+++ b/src/uu/tty/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_tty"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tty ~ (uutils) display the name of the terminal connected to standard input"
diff --git a/src/uu/uname/Cargo.toml b/src/uu/uname/Cargo.toml
index cfd459c5bf1..f9883eef93c 100644
--- a/src/uu/uname/Cargo.toml
+++ b/src/uu/uname/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_uname"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uname ~ (uutils) display system information"
diff --git a/src/uu/unexpand/Cargo.toml b/src/uu/unexpand/Cargo.toml
index 459a67b9015..d10239b960e 100644
--- a/src/uu/unexpand/Cargo.toml
+++ b/src/uu/unexpand/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_unexpand"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "unexpand ~ (uutils) convert input spaces to tabs"
diff --git a/src/uu/unexpand/src/unexpand.rs b/src/uu/unexpand/src/unexpand.rs
index 11ad43060a6..7336376eb6c 100644
--- a/src/uu/unexpand/src/unexpand.rs
+++ b/src/uu/unexpand/src/unexpand.rs
@@ -11,11 +11,12 @@ use std::fmt;
 use std::fs::File;
 use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Stdout, Write};
 use std::num::IntErrorKind;
+use std::path::Path;
 use std::str::from_utf8;
 use unicode_width::UnicodeWidthChar;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult};
-use uucore::{crash, crash_if_err, format_usage, help_about, help_usage};
+use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::{crash_if_err, format_usage, help_about, help_usage, show};
 
 const USAGE: &str = help_usage!("unexpand.md");
 const ABOUT: &str = help_about!("unexpand.md");
@@ -105,8 +106,8 @@ impl Options {
             && !matches.get_flag(options::FIRST_ONLY);
         let uflag = !matches.get_flag(options::NO_UTF8);
 
-        let files = match matches.get_one::<String>(options::FILE) {
-            Some(v) => vec![v.to_string()],
+        let files = match matches.get_many::<String>(options::FILE) {
+            Some(v) => v.cloned().collect(),
             None => vec!["-".to_owned()],
         };
 
@@ -161,7 +162,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let matches = uu_app().try_get_matches_from(expand_shortcuts(&args))?;
 
-    unexpand(&Options::new(&matches)?).map_err_context(String::new)
+    unexpand(&Options::new(&matches)?)
 }
 
 pub fn uu_app() -> Command {
@@ -209,16 +210,19 @@ pub fn uu_app() -> Command {
         )
 }
 
-fn open(path: &str) -> BufReader<Box<dyn Read + 'static>> {
+fn open(path: &str) -> UResult<BufReader<Box<dyn Read + 'static>>> {
     let file_buf;
-    if path == "-" {
-        BufReader::new(Box::new(stdin()) as Box<dyn Read>)
+    let filename = Path::new(path);
+    if filename.is_dir() {
+        Err(Box::new(USimpleError {
+            code: 1,
+            message: format!("{}: Is a directory", filename.display()),
+        }))
+    } else if path == "-" {
+        Ok(BufReader::new(Box::new(stdin()) as Box<dyn Read>))
     } else {
-        file_buf = match File::open(path) {
-            Ok(a) => a,
-            Err(e) => crash!(1, "{}: {}", path.maybe_quote(), e),
-        };
-        BufReader::new(Box::new(file_buf) as Box<dyn Read>)
+        file_buf = File::open(path).map_err_context(|| path.to_string())?;
+        Ok(BufReader::new(Box::new(file_buf) as Box<dyn Read>))
     }
 }
 
@@ -315,106 +319,108 @@ fn next_char_info(uflag: bool, buf: &[u8], byte: usize) -> (CharType, usize, usi
 }
 
 #[allow(clippy::cognitive_complexity)]
-fn unexpand(options: &Options) -> std::io::Result<()> {
+fn unexpand_line(
+    buf: &mut Vec<u8>,
+    output: &mut BufWriter<std::io::Stdout>,
+    options: &Options,
+    lastcol: usize,
+    ts: &[usize],
+) -> std::io::Result<()> {
+    let mut byte = 0; // offset into the buffer
+    let mut col = 0; // the current column
+    let mut scol = 0; // the start col for the current span, i.e., the already-printed width
+    let mut init = true; // are we at the start of the line?
+    let mut pctype = CharType::Other;
+
+    while byte < buf.len() {
+        // when we have a finite number of columns, never convert past the last column
+        if lastcol > 0 && col >= lastcol {
+            write_tabs(output, ts, scol, col, pctype == CharType::Tab, init, true);
+            output.write_all(&buf[byte..])?;
+            scol = col;
+            break;
+        }
+
+        // figure out how big the next char is, if it's UTF-8
+        let (ctype, cwidth, nbytes) = next_char_info(options.uflag, buf, byte);
+
+        // now figure out how many columns this char takes up, and maybe print it
+        let tabs_buffered = init || options.aflag;
+        match ctype {
+            CharType::Space | CharType::Tab => {
+                // compute next col, but only write space or tab chars if not buffering
+                col += if ctype == CharType::Space {
+                    1
+                } else {
+                    next_tabstop(ts, col).unwrap_or(1)
+                };
+
+                if !tabs_buffered {
+                    output.write_all(&buf[byte..byte + nbytes])?;
+                    scol = col; // now printed up to this column
+                }
+            }
+            CharType::Other | CharType::Backspace => {
+                // always
+                write_tabs(
+                    output,
+                    ts,
+                    scol,
+                    col,
+                    pctype == CharType::Tab,
+                    init,
+                    options.aflag,
+                );
+                init = false; // no longer at the start of a line
+                col = if ctype == CharType::Other {
+                    // use computed width
+                    col + cwidth
+                } else if col > 0 {
+                    // Backspace case, but only if col > 0
+                    col - 1
+                } else {
+                    0
+                };
+                output.write_all(&buf[byte..byte + nbytes])?;
+                scol = col; // we've now printed up to this column
+            }
+        }
+
+        byte += nbytes; // move on to next char
+        pctype = ctype; // save the previous type
+    }
+
+    // write out anything remaining
+    write_tabs(output, ts, scol, col, pctype == CharType::Tab, init, true);
+    output.flush()?;
+    buf.truncate(0); // clear out the buffer
+
+    Ok(())
+}
+
+fn unexpand(options: &Options) -> UResult<()> {
     let mut output = BufWriter::new(stdout());
     let ts = &options.tabstops[..];
     let mut buf = Vec::new();
     let lastcol = if ts.len() > 1 { *ts.last().unwrap() } else { 0 };
 
     for file in &options.files {
-        let mut fh = open(file);
+        let mut fh = match open(file) {
+            Ok(reader) => reader,
+            Err(err) => {
+                show!(err);
+                continue;
+            }
+        };
 
         while match fh.read_until(b'\n', &mut buf) {
             Ok(s) => s > 0,
             Err(_) => !buf.is_empty(),
         } {
-            let mut byte = 0; // offset into the buffer
-            let mut col = 0; // the current column
-            let mut scol = 0; // the start col for the current span, i.e., the already-printed width
-            let mut init = true; // are we at the start of the line?
-            let mut pctype = CharType::Other;
-
-            while byte < buf.len() {
-                // when we have a finite number of columns, never convert past the last column
-                if lastcol > 0 && col >= lastcol {
-                    write_tabs(
-                        &mut output,
-                        ts,
-                        scol,
-                        col,
-                        pctype == CharType::Tab,
-                        init,
-                        true,
-                    );
-                    output.write_all(&buf[byte..])?;
-                    scol = col;
-                    break;
-                }
-
-                // figure out how big the next char is, if it's UTF-8
-                let (ctype, cwidth, nbytes) = next_char_info(options.uflag, &buf, byte);
-
-                // now figure out how many columns this char takes up, and maybe print it
-                let tabs_buffered = init || options.aflag;
-                match ctype {
-                    CharType::Space | CharType::Tab => {
-                        // compute next col, but only write space or tab chars if not buffering
-                        col += if ctype == CharType::Space {
-                            1
-                        } else {
-                            next_tabstop(ts, col).unwrap_or(1)
-                        };
-
-                        if !tabs_buffered {
-                            output.write_all(&buf[byte..byte + nbytes])?;
-                            scol = col; // now printed up to this column
-                        }
-                    }
-                    CharType::Other | CharType::Backspace => {
-                        // always
-                        write_tabs(
-                            &mut output,
-                            ts,
-                            scol,
-                            col,
-                            pctype == CharType::Tab,
-                            init,
-                            options.aflag,
-                        );
-                        init = false; // no longer at the start of a line
-                        col = if ctype == CharType::Other {
-                            // use computed width
-                            col + cwidth
-                        } else if col > 0 {
-                            // Backspace case, but only if col > 0
-                            col - 1
-                        } else {
-                            0
-                        };
-                        output.write_all(&buf[byte..byte + nbytes])?;
-                        scol = col; // we've now printed up to this column
-                    }
-                }
-
-                byte += nbytes; // move on to next char
-                pctype = ctype; // save the previous type
-            }
-
-            // write out anything remaining
-            write_tabs(
-                &mut output,
-                ts,
-                scol,
-                col,
-                pctype == CharType::Tab,
-                init,
-                true,
-            );
-            output.flush()?;
-            buf.truncate(0); // clear out the buffer
+            unexpand_line(&mut buf, &mut output, options, lastcol, ts)?;
         }
     }
-    output.flush()
+    Ok(())
 }
 
 #[cfg(test)]
diff --git a/src/uu/uniq/Cargo.toml b/src/uu/uniq/Cargo.toml
index efe5ca8ee53..52d1d22e16a 100644
--- a/src/uu/uniq/Cargo.toml
+++ b/src/uu/uniq/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_uniq"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uniq ~ (uutils) filter identical adjacent lines from input"
diff --git a/src/uu/uniq/uniq.md b/src/uu/uniq/uniq.md
index dea57081b77..20de52395ba 100644
--- a/src/uu/uniq/uniq.md
+++ b/src/uu/uniq/uniq.md
@@ -1,7 +1,7 @@
 # uniq
 
 ```
-uniq [OPTION]... [INPUT [OUTPUT]]...
+uniq [OPTION]... [INPUT [OUTPUT]]
 ```
 
 Report or omit repeated lines.
diff --git a/src/uu/unlink/Cargo.toml b/src/uu/unlink/Cargo.toml
index c6bfcd66bb7..854df092c1b 100644
--- a/src/uu/unlink/Cargo.toml
+++ b/src/uu/unlink/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_unlink"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "unlink ~ (uutils) remove a (file system) link to FILE"
diff --git a/src/uu/unlink/unlink.md b/src/uu/unlink/unlink.md
index 4468fb20450..eebcd9ef31d 100644
--- a/src/uu/unlink/unlink.md
+++ b/src/uu/unlink/unlink.md
@@ -2,6 +2,7 @@
 
 ```
 unlink [FILE]
+unlink OPTION
 ```
 
 Unlink the file at `FILE`.
diff --git a/src/uu/uptime/Cargo.toml b/src/uu/uptime/Cargo.toml
index 899a30dfaa5..0013e980a67 100644
--- a/src/uu/uptime/Cargo.toml
+++ b/src/uu/uptime/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_uptime"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uptime ~ (uutils) display dynamic system information"
diff --git a/src/uu/uptime/src/platform/mod.rs b/src/uu/uptime/src/platform/mod.rs
new file mode 100644
index 00000000000..e0e87dca1bf
--- /dev/null
+++ b/src/uu/uptime/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/uptime/src/platform/openbsd.rs b/src/uu/uptime/src/platform/openbsd.rs
new file mode 100644
index 00000000000..7e6970c1f09
--- /dev/null
+++ b/src/uu/uptime/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let _matches = uu_app().try_get_matches_from(args)?;
+
+    println!("unsupported command on OpenBSD");
+    Ok(())
+}
diff --git a/src/uu/uptime/src/platform/unix.rs b/src/uu/uptime/src/platform/unix.rs
new file mode 100644
index 00000000000..df3e5e6536f
--- /dev/null
+++ b/src/uu/uptime/src/platform/unix.rs
@@ -0,0 +1,161 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (ToDO) getloadavg upsecs updays nusers loadavg boottime uphours upmins
+
+use crate::options;
+use crate::uu_app;
+
+use chrono::{Local, TimeZone, Utc};
+
+use uucore::libc::time_t;
+
+use uucore::error::{UResult, USimpleError};
+
+#[cfg(unix)]
+use uucore::libc::getloadavg;
+
+#[cfg(windows)]
+extern "C" {
+    fn GetTickCount() -> uucore::libc::uint32_t;
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().try_get_matches_from(args)?;
+
+    let (boot_time, user_count) = process_utmpx();
+    let uptime = get_uptime(boot_time);
+    if uptime < 0 {
+        Err(USimpleError::new(1, "could not retrieve system uptime"))
+    } else {
+        if matches.get_flag(options::SINCE) {
+            let initial_date = Local
+                .timestamp_opt(Utc::now().timestamp() - uptime, 0)
+                .unwrap();
+            println!("{}", initial_date.format("%Y-%m-%d %H:%M:%S"));
+            return Ok(());
+        }
+
+        print_time();
+        let upsecs = uptime;
+        print_uptime(upsecs);
+        print_nusers(user_count);
+        print_loadavg();
+
+        Ok(())
+    }
+}
+
+#[cfg(unix)]
+fn print_loadavg() {
+    use uucore::libc::c_double;
+
+    let mut avg: [c_double; 3] = [0.0; 3];
+    let loads: i32 = unsafe { getloadavg(avg.as_mut_ptr(), 3) };
+
+    if loads == -1 {
+        println!();
+    } else {
+        print!("load average: ");
+        for n in 0..loads {
+            print!(
+                "{:.2}{}",
+                avg[n as usize],
+                if n == loads - 1 { "\n" } else { ", " }
+            );
+        }
+    }
+}
+
+#[cfg(windows)]
+fn print_loadavg() {
+    // XXX: currently this is a noop as Windows does not seem to have anything comparable to
+    //      getloadavg()
+}
+
+#[cfg(unix)]
+fn process_utmpx() -> (Option<time_t>, usize) {
+    use uucore::utmpx::*;
+
+    let mut nusers = 0;
+    let mut boot_time = None;
+
+    for line in Utmpx::iter_all_records() {
+        match line.record_type() {
+            USER_PROCESS => nusers += 1,
+            BOOT_TIME => {
+                let dt = line.login_time();
+                if dt.unix_timestamp() > 0 {
+                    boot_time = Some(dt.unix_timestamp() as time_t);
+                }
+            }
+            _ => continue,
+        }
+    }
+    (boot_time, nusers)
+}
+
+#[cfg(windows)]
+fn process_utmpx() -> (Option<time_t>, usize) {
+    (None, 0) // TODO: change 0 to number of users
+}
+
+fn print_nusers(nusers: usize) {
+    match nusers.cmp(&1) {
+        std::cmp::Ordering::Equal => print!("1 user,  "),
+        std::cmp::Ordering::Greater => print!("{nusers} users,  "),
+        _ => {}
+    };
+}
+
+fn print_time() {
+    let local_time = Local::now().time();
+
+    print!(" {} ", local_time.format("%H:%M:%S"));
+}
+
+#[cfg(unix)]
+fn get_uptime(boot_time: Option<time_t>) -> i64 {
+    use std::fs::File;
+    use std::io::Read;
+
+    let mut proc_uptime_s = String::new();
+
+    let proc_uptime = File::open("/proc/uptime")
+        .ok()
+        .and_then(|mut f| f.read_to_string(&mut proc_uptime_s).ok())
+        .and_then(|_| proc_uptime_s.split_whitespace().next())
+        .and_then(|s| s.split('.').next().unwrap_or("0").parse().ok());
+
+    proc_uptime.unwrap_or_else(|| match boot_time {
+        Some(t) => {
+            let now = Local::now().timestamp();
+            #[cfg(target_pointer_width = "64")]
+            let boottime: i64 = t;
+            #[cfg(not(target_pointer_width = "64"))]
+            let boottime: i64 = t.into();
+            now - boottime
+        }
+        None => -1,
+    })
+}
+
+#[cfg(windows)]
+fn get_uptime(_boot_time: Option<time_t>) -> i64 {
+    unsafe { GetTickCount() as i64 }
+}
+
+fn print_uptime(upsecs: i64) {
+    let updays = upsecs / 86400;
+    let uphours = (upsecs - (updays * 86400)) / 3600;
+    let upmins = (upsecs - (updays * 86400) - (uphours * 3600)) / 60;
+    match updays.cmp(&1) {
+        std::cmp::Ordering::Equal => print!("up {updays:1} day, {uphours:2}:{upmins:02},  "),
+        std::cmp::Ordering::Greater => {
+            print!("up {updays:1} days, {uphours:2}:{upmins:02},  ");
+        }
+        _ => print!("up  {uphours:2}:{upmins:02}, "),
+    };
+}
diff --git a/src/uu/uptime/src/uptime.rs b/src/uu/uptime/src/uptime.rs
index 778fbc92047..196ae60bae0 100644
--- a/src/uu/uptime/src/uptime.rs
+++ b/src/uu/uptime/src/uptime.rs
@@ -3,15 +3,11 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) getloadavg upsecs updays nusers loadavg boottime uphours upmins
-
-use chrono::{Local, TimeZone, Utc};
 use clap::{crate_version, Arg, ArgAction, Command};
 
-use uucore::libc::time_t;
 use uucore::{format_usage, help_about, help_usage};
 
-use uucore::error::{UResult, USimpleError};
+mod platform;
 
 const ABOUT: &str = help_about!("uptime.md");
 const USAGE: &str = help_usage!("uptime.md");
@@ -19,40 +15,8 @@ pub mod options {
     pub static SINCE: &str = "since";
 }
 
-#[cfg(unix)]
-use uucore::libc::getloadavg;
-
-#[cfg(windows)]
-extern "C" {
-    fn GetTickCount() -> uucore::libc::uint32_t;
-}
-
 #[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().try_get_matches_from(args)?;
-
-    let (boot_time, user_count) = process_utmpx();
-    let uptime = get_uptime(boot_time);
-    if uptime < 0 {
-        Err(USimpleError::new(1, "could not retrieve system uptime"))
-    } else {
-        if matches.get_flag(options::SINCE) {
-            let initial_date = Local
-                .timestamp_opt(Utc::now().timestamp() - uptime, 0)
-                .unwrap();
-            println!("{}", initial_date.format("%Y-%m-%d %H:%M:%S"));
-            return Ok(());
-        }
-
-        print_time();
-        let upsecs = uptime;
-        print_uptime(upsecs);
-        print_nusers(user_count);
-        print_loadavg();
-
-        Ok(())
-    }
-}
+use platform::uumain;
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
@@ -68,115 +32,3 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
 }
-
-#[cfg(unix)]
-fn print_loadavg() {
-    use uucore::libc::c_double;
-
-    let mut avg: [c_double; 3] = [0.0; 3];
-    let loads: i32 = unsafe { getloadavg(avg.as_mut_ptr(), 3) };
-
-    if loads == -1 {
-        println!();
-    } else {
-        print!("load average: ");
-        for n in 0..loads {
-            print!(
-                "{:.2}{}",
-                avg[n as usize],
-                if n == loads - 1 { "\n" } else { ", " }
-            );
-        }
-    }
-}
-
-#[cfg(windows)]
-fn print_loadavg() {
-    // XXX: currently this is a noop as Windows does not seem to have anything comparable to
-    //      getloadavg()
-}
-
-#[cfg(unix)]
-fn process_utmpx() -> (Option<time_t>, usize) {
-    use uucore::utmpx::*;
-
-    let mut nusers = 0;
-    let mut boot_time = None;
-
-    for line in Utmpx::iter_all_records() {
-        match line.record_type() {
-            USER_PROCESS => nusers += 1,
-            BOOT_TIME => {
-                let dt = line.login_time();
-                if dt.unix_timestamp() > 0 {
-                    boot_time = Some(dt.unix_timestamp() as time_t);
-                }
-            }
-            _ => continue,
-        }
-    }
-    (boot_time, nusers)
-}
-
-#[cfg(windows)]
-fn process_utmpx() -> (Option<time_t>, usize) {
-    (None, 0) // TODO: change 0 to number of users
-}
-
-fn print_nusers(nusers: usize) {
-    match nusers.cmp(&1) {
-        std::cmp::Ordering::Equal => print!("1 user,  "),
-        std::cmp::Ordering::Greater => print!("{nusers} users,  "),
-        _ => {}
-    };
-}
-
-fn print_time() {
-    let local_time = Local::now().time();
-
-    print!(" {} ", local_time.format("%H:%M:%S"));
-}
-
-#[cfg(unix)]
-fn get_uptime(boot_time: Option<time_t>) -> i64 {
-    use std::fs::File;
-    use std::io::Read;
-
-    let mut proc_uptime_s = String::new();
-
-    let proc_uptime = File::open("/proc/uptime")
-        .ok()
-        .and_then(|mut f| f.read_to_string(&mut proc_uptime_s).ok())
-        .and_then(|_| proc_uptime_s.split_whitespace().next())
-        .and_then(|s| s.split('.').next().unwrap_or("0").parse().ok());
-
-    proc_uptime.unwrap_or_else(|| match boot_time {
-        Some(t) => {
-            let now = Local::now().timestamp();
-            #[cfg(target_pointer_width = "64")]
-            let boottime: i64 = t;
-            #[cfg(not(target_pointer_width = "64"))]
-            let boottime: i64 = t.into();
-            now - boottime
-        }
-        None => -1,
-    })
-}
-
-#[cfg(windows)]
-fn get_uptime(_boot_time: Option<time_t>) -> i64 {
-    unsafe { GetTickCount() as i64 }
-}
-
-fn print_uptime(upsecs: i64) {
-    let updays = upsecs / 86400;
-    let uphours = (upsecs - (updays * 86400)) / 3600;
-    let upmins = (upsecs - (updays * 86400) - (uphours * 3600)) / 60;
-    match updays.cmp(&1) {
-        std::cmp::Ordering::Equal => print!("up {updays:1} day, {uphours:2}:{upmins:02},  "),
-        std::cmp::Ordering::Greater => {
-            print!("up {updays:1} days, {uphours:2}:{upmins:02},  ");
-        }
-        _ => print!("up  {uphours:2}:{upmins:02}, "),
-    };
-}
diff --git a/src/uu/users/Cargo.toml b/src/uu/users/Cargo.toml
index 030c7d62551..8e29b119e8a 100644
--- a/src/uu/users/Cargo.toml
+++ b/src/uu/users/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_users"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "users ~ (uutils) display names of currently logged-in users"
diff --git a/src/uu/users/src/platform/mod.rs b/src/uu/users/src/platform/mod.rs
new file mode 100644
index 00000000000..e0e87dca1bf
--- /dev/null
+++ b/src/uu/users/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/users/src/platform/openbsd.rs b/src/uu/users/src/platform/openbsd.rs
new file mode 100644
index 00000000000..7e6970c1f09
--- /dev/null
+++ b/src/uu/users/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let _matches = uu_app().try_get_matches_from(args)?;
+
+    println!("unsupported command on OpenBSD");
+    Ok(())
+}
diff --git a/src/uu/users/src/platform/unix.rs b/src/uu/users/src/platform/unix.rs
new file mode 100644
index 00000000000..99c9ce776bb
--- /dev/null
+++ b/src/uu/users/src/platform/unix.rs
@@ -0,0 +1,53 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (paths) wtmp
+
+use crate::uu_app;
+
+use std::ffi::OsString;
+use std::path::Path;
+
+use uucore::error::UResult;
+use uucore::utmpx::{self, Utmpx};
+
+static ARG_FILES: &str = "files";
+
+fn get_long_usage() -> String {
+    format!(
+        "Output who is currently logged in according to FILE.
+If FILE is not specified, use {}.  /var/log/wtmp as FILE is common.",
+        utmpx::DEFAULT_FILE
+    )
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app()
+        .after_help(get_long_usage())
+        .try_get_matches_from(args)?;
+
+    let files: Vec<&Path> = matches
+        .get_many::<OsString>(ARG_FILES)
+        .map(|v| v.map(AsRef::as_ref).collect())
+        .unwrap_or_default();
+
+    let filename = if files.is_empty() {
+        utmpx::DEFAULT_FILE.as_ref()
+    } else {
+        files[0]
+    };
+
+    let mut users = Utmpx::iter_all_records_from(filename)
+        .filter(Utmpx::is_user_process)
+        .map(|ut| ut.user())
+        .collect::<Vec<_>>();
+
+    if !users.is_empty() {
+        users.sort();
+        println!("{}", users.join(" "));
+    }
+
+    Ok(())
+}
diff --git a/src/uu/users/src/users.rs b/src/uu/users/src/users.rs
index 199882b7eab..d299399f311 100644
--- a/src/uu/users/src/users.rs
+++ b/src/uu/users/src/users.rs
@@ -5,57 +5,19 @@
 
 // spell-checker:ignore (paths) wtmp
 
-use std::ffi::OsString;
-use std::path::Path;
-
 use clap::builder::ValueParser;
 use clap::{crate_version, Arg, Command};
-use uucore::error::UResult;
-use uucore::utmpx::{self, Utmpx};
 use uucore::{format_usage, help_about, help_usage};
 
+mod platform;
+
 const ABOUT: &str = help_about!("users.md");
 const USAGE: &str = help_usage!("users.md");
 
 static ARG_FILES: &str = "files";
 
-fn get_long_usage() -> String {
-    format!(
-        "Output who is currently logged in according to FILE.
-If FILE is not specified, use {}.  /var/log/wtmp as FILE is common.",
-        utmpx::DEFAULT_FILE
-    )
-}
-
 #[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app()
-        .after_help(get_long_usage())
-        .try_get_matches_from(args)?;
-
-    let files: Vec<&Path> = matches
-        .get_many::<OsString>(ARG_FILES)
-        .map(|v| v.map(AsRef::as_ref).collect())
-        .unwrap_or_default();
-
-    let filename = if files.is_empty() {
-        utmpx::DEFAULT_FILE.as_ref()
-    } else {
-        files[0]
-    };
-
-    let mut users = Utmpx::iter_all_records_from(filename)
-        .filter(Utmpx::is_user_process)
-        .map(|ut| ut.user())
-        .collect::<Vec<_>>();
-
-    if !users.is_empty() {
-        users.sort();
-        println!("{}", users.join(" "));
-    }
-
-    Ok(())
-}
+use platform::uumain;
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
diff --git a/src/uu/vdir/Cargo.toml b/src/uu/vdir/Cargo.toml
index d14e10d9565..3c7e55eda69 100644
--- a/src/uu/vdir/Cargo.toml
+++ b/src/uu/vdir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_vdir"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shortcut to ls -l -b"
diff --git a/src/uu/vdir/vdir.md b/src/uu/vdir/vdir.md
new file mode 100644
index 00000000000..c7a0cae3643
--- /dev/null
+++ b/src/uu/vdir/vdir.md
@@ -0,0 +1,10 @@
+# vdir
+
+```
+vdir [OPTION]... [FILE]...
+```
+
+List directory contents.
+Ignore files and directories starting with a '.' by default.
+
+Mandatory arguments to long options are mandatory for short options too.
diff --git a/src/uu/wc/Cargo.toml b/src/uu/wc/Cargo.toml
index 8471472f867..516e3be46a3 100644
--- a/src/uu/wc/Cargo.toml
+++ b/src/uu/wc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_wc"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "wc ~ (uutils) display newline, word, and byte counts for input"
diff --git a/src/uu/wc/src/count_fast.rs b/src/uu/wc/src/count_fast.rs
index 863625921bf..85d3d1d2b36 100644
--- a/src/uu/wc/src/count_fast.rs
+++ b/src/uu/wc/src/count_fast.rs
@@ -2,6 +2,8 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+
+// cSpell:ignore sysconf
 use crate::word_count::WordCount;
 
 use super::WordCountable;
@@ -11,11 +13,19 @@ use std::fs::OpenOptions;
 use std::io::{self, ErrorKind, Read};
 
 #[cfg(unix)]
-use libc::S_IFREG;
+use libc::{sysconf, S_IFREG, _SC_PAGESIZE};
 #[cfg(unix)]
 use nix::sys::stat;
+#[cfg(unix)]
+use std::io::{Seek, SeekFrom};
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::os::unix::io::AsRawFd;
+#[cfg(windows)]
+use std::os::windows::fs::MetadataExt;
+#[cfg(windows)]
+const FILE_ATTRIBUTE_ARCHIVE: u32 = 32;
+#[cfg(windows)]
+const FILE_ATTRIBUTE_NORMAL: u32 = 128;
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use libc::S_IFIFO;
@@ -72,6 +82,8 @@ fn count_bytes_using_splice(fd: &impl AsRawFd) -> Result<usize, usize> {
 ///   1. On Unix,  we can simply `stat` the file if it is regular.
 ///   2. On Linux -- if the above did not work -- we can use splice to count
 ///      the number of bytes if the file is a FIFO.
+///   3. On Windows we can use `std::os::windows::fs::MetadataExt` to get file size
+///      for regular files
 ///   3. Otherwise, we just read normally, but without the overhead of counting
 ///      other things such as lines and words.
 #[inline]
@@ -87,11 +99,60 @@ pub(crate) fn count_bytes_fast<T: WordCountable>(handle: &mut T) -> (usize, Opti
             // If stat.st_size = 0 then
             //  - either the size is 0
             //  - or the size is unknown.
-            // The second case happens for files in pseudo-filesystems. For
-            // example with /proc/version and /sys/kernel/profiling. So,
-            // if it is 0 we don't report that and instead do a full read.
-            if (stat.st_mode as libc::mode_t & S_IFREG) != 0 && stat.st_size > 0 {
-                return (stat.st_size as usize, None);
+            // The second case happens for files in pseudo-filesystems.
+            // For example with /proc/version.
+            // So, if it is 0 we don't report that and instead do a full read.
+            //
+            // Another thing to consider for files in pseudo-filesystems like /proc, /sys
+            // and similar is that they could report `st_size` greater than actual content.
+            // For example /sys/kernel/profiling could report `st_size` equal to
+            // system page size (typically 4096 on 64bit system), while it's file content
+            // would count up only to a couple of bytes.
+            // This condition usually occurs for files in pseudo-filesystems like /proc, /sys
+            // that report `st_size` in the multiples of system page size.
+            // In such cases - attempt `seek()` almost to the end of the file
+            // and then fall back on read to count the rest.
+            //
+            // And finally a special case of input redirection in *nix shell:
+            // `( wc -c ; wc -c ) < file` should return
+            // ```
+            // size_of_file
+            // 0
+            // ```
+            // Similarly
+            // `( head -c1 ; wc -c ) < file` should return
+            // ```
+            // first_byte_of_file
+            // size_of_file - 1
+            // ```
+            // Since the input stream from file is treated as continuous across both commands inside ().
+            // In cases like this, due to `<` redirect, the `stat.st_mode` would report input as a regular file
+            // and `stat.st_size` would report the size of file on disk
+            // and NOT the remaining number of bytes in the input stream.
+            // However, the raw file descriptor in this situation would be equal to `0`
+            // for STDIN in both invocations.
+            // Therefore we cannot rely of `st_size` here and should fall back on full read.
+            if fd > 0 && (stat.st_mode as libc::mode_t & S_IFREG) != 0 && stat.st_size > 0 {
+                let sys_page_size = unsafe { sysconf(_SC_PAGESIZE) as usize };
+                if stat.st_size as usize % sys_page_size > 0 {
+                    // regular file or file from /proc, /sys and similar pseudo-filesystems
+                    // with size that is NOT a multiple of system page size
+                    return (stat.st_size as usize, None);
+                } else if let Some(file) = handle.inner_file() {
+                    // On some platforms `stat.st_blksize` and `stat.st_size`
+                    // are of different types: i64 vs i32
+                    // i.e. MacOS on Apple Silicon (aarch64-apple-darwin),
+                    // Debian Linux on ARM (aarch64-unknown-linux-gnu),
+                    // 32bit i686 targets, etc.
+                    // While on the others they are of the same type.
+                    #[allow(clippy::unnecessary_cast)]
+                    let offset =
+                        stat.st_size as i64 - stat.st_size as i64 % (stat.st_blksize as i64 + 1);
+
+                    if let Ok(n) = file.seek(SeekFrom::Start(offset as u64)) {
+                        byte_count = n as usize;
+                    }
+                }
             }
             #[cfg(any(target_os = "linux", target_os = "android"))]
             {
@@ -107,6 +168,21 @@ pub(crate) fn count_bytes_fast<T: WordCountable>(handle: &mut T) -> (usize, Opti
         }
     }
 
+    #[cfg(windows)]
+    {
+        if let Some(file) = handle.inner_file() {
+            if let Ok(metadata) = file.metadata() {
+                let attributes = metadata.file_attributes();
+
+                if (attributes & FILE_ATTRIBUTE_ARCHIVE) != 0
+                    || (attributes & FILE_ATTRIBUTE_NORMAL) != 0
+                {
+                    return (metadata.file_size() as usize, None);
+                }
+            }
+        }
+    }
+
     // Fall back on `read`, but without the overhead of counting words and lines.
     let mut buf = [0_u8; BUF_SIZE];
     loop {
diff --git a/src/uu/wc/src/countable.rs b/src/uu/wc/src/countable.rs
index 64397446491..d27c7fb5968 100644
--- a/src/uu/wc/src/countable.rs
+++ b/src/uu/wc/src/countable.rs
@@ -17,12 +17,14 @@ use std::os::unix::io::AsRawFd;
 pub trait WordCountable: AsRawFd + Read {
     type Buffered: BufRead;
     fn buffered(self) -> Self::Buffered;
+    fn inner_file(&mut self) -> Option<&mut File>;
 }
 
 #[cfg(not(unix))]
 pub trait WordCountable: Read {
     type Buffered: BufRead;
     fn buffered(self) -> Self::Buffered;
+    fn inner_file(&mut self) -> Option<&mut File>;
 }
 
 impl WordCountable for StdinLock<'_> {
@@ -31,6 +33,9 @@ impl WordCountable for StdinLock<'_> {
     fn buffered(self) -> Self::Buffered {
         self
     }
+    fn inner_file(&mut self) -> Option<&mut File> {
+        None
+    }
 }
 
 impl WordCountable for File {
@@ -39,4 +44,8 @@ impl WordCountable for File {
     fn buffered(self) -> Self::Buffered {
         BufReader::new(self)
     }
+
+    fn inner_file(&mut self) -> Option<&mut File> {
+        Some(self)
+    }
 }
diff --git a/src/uu/wc/src/wc.rs b/src/uu/wc/src/wc.rs
index 663bbda151b..d69647c3804 100644
--- a/src/uu/wc/src/wc.rs
+++ b/src/uu/wc/src/wc.rs
@@ -167,7 +167,9 @@ impl<'a> Inputs<'a> {
                     None => Ok(Self::Files0From(input)),
                 }
             }
-            (Some(_), Some(_)) => Err(WcError::FilesDisabled.into()),
+            (Some(mut files), Some(_)) => {
+                Err(WcError::files_disabled(files.next().unwrap()).into())
+            }
         }
     }
 
@@ -342,8 +344,8 @@ impl TotalWhen {
 
 #[derive(Debug, Error)]
 enum WcError {
-    #[error("file operands cannot be combined with --files0-from")]
-    FilesDisabled,
+    #[error("extra operand '{extra}'\nfile operands cannot be combined with --files0-from")]
+    FilesDisabled { extra: Cow<'static, str> },
     #[error("when reading file names from stdin, no file name of '-' allowed")]
     StdinReprNotAllowed,
     #[error("invalid zero-length file name")]
@@ -365,11 +367,15 @@ impl WcError {
             None => Self::ZeroLengthFileName,
         }
     }
+    fn files_disabled(first_extra: &OsString) -> Self {
+        let extra = first_extra.to_string_lossy().into_owned().into();
+        Self::FilesDisabled { extra }
+    }
 }
 
 impl UError for WcError {
     fn usage(&self) -> bool {
-        matches!(self, Self::FilesDisabled)
+        matches!(self, Self::FilesDisabled { .. })
     }
 }
 
@@ -389,6 +395,7 @@ pub fn uu_app() -> Command {
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::BYTES)
                 .short('c')
diff --git a/src/uu/who/Cargo.toml b/src/uu/who/Cargo.toml
index 249d5a8eeec..f343942fc4b 100644
--- a/src/uu/who/Cargo.toml
+++ b/src/uu/who/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_who"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "who ~ (uutils) display information about currently logged-in users"
diff --git a/src/uu/who/src/platform/mod.rs b/src/uu/who/src/platform/mod.rs
new file mode 100644
index 00000000000..e0e87dca1bf
--- /dev/null
+++ b/src/uu/who/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/who/src/platform/openbsd.rs b/src/uu/who/src/platform/openbsd.rs
new file mode 100644
index 00000000000..7e6970c1f09
--- /dev/null
+++ b/src/uu/who/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let _matches = uu_app().try_get_matches_from(args)?;
+
+    println!("unsupported command on OpenBSD");
+    Ok(())
+}
diff --git a/src/uu/who/src/platform/unix.rs b/src/uu/who/src/platform/unix.rs
new file mode 100644
index 00000000000..b59b73a5703
--- /dev/null
+++ b/src/uu/who/src/platform/unix.rs
@@ -0,0 +1,430 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (ToDO) ttyname hostnames runlevel mesg wtmp statted boottime deadprocs initspawn clockchange curr runlvline pidstr exitstr hoststr
+
+use crate::options;
+use crate::uu_app;
+
+use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult};
+use uucore::libc::{ttyname, STDIN_FILENO, S_IWGRP};
+use uucore::utmpx::{self, time, Utmpx};
+
+use std::borrow::Cow;
+use std::ffi::CStr;
+use std::fmt::Write;
+use std::os::unix::fs::MetadataExt;
+use std::path::PathBuf;
+
+fn get_long_usage() -> String {
+    format!(
+        "If FILE is not specified, use {}.  /var/log/wtmp as FILE is common.\n\
+         If ARG1 ARG2 given, -m presumed: 'am i' or 'mom likes' are usual.",
+        utmpx::DEFAULT_FILE,
+    )
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app()
+        .after_help(get_long_usage())
+        .try_get_matches_from(args)?;
+
+    let files: Vec<String> = matches
+        .get_many::<String>(options::FILE)
+        .map(|v| v.map(ToString::to_string).collect())
+        .unwrap_or_default();
+
+    // If true, attempt to canonicalize hostnames via a DNS lookup.
+    let do_lookup = matches.get_flag(options::LOOKUP);
+
+    // If true, display only a list of usernames and count of
+    // the users logged on.
+    // Ignored for 'who am i'.
+    let short_list = matches.get_flag(options::COUNT);
+
+    let all = matches.get_flag(options::ALL);
+
+    // If true, display a line at the top describing each field.
+    let include_heading = matches.get_flag(options::HEADING);
+
+    // If true, display a '+' for each user if mesg y, a '-' if mesg n,
+    // or a '?' if their tty cannot be statted.
+    let include_mesg = all || matches.get_flag(options::MESG);
+
+    // If true, display the last boot time.
+    let need_boottime = all || matches.get_flag(options::BOOT);
+
+    // If true, display dead processes.
+    let need_deadprocs = all || matches.get_flag(options::DEAD);
+
+    // If true, display processes waiting for user login.
+    let need_login = all || matches.get_flag(options::LOGIN);
+
+    // If true, display processes started by init.
+    let need_initspawn = all || matches.get_flag(options::PROCESS);
+
+    // If true, display the last clock change.
+    let need_clockchange = all || matches.get_flag(options::TIME);
+
+    // If true, display the current runlevel.
+    let need_runlevel = all || matches.get_flag(options::RUNLEVEL);
+
+    let use_defaults = !(all
+        || need_boottime
+        || need_deadprocs
+        || need_login
+        || need_initspawn
+        || need_runlevel
+        || need_clockchange
+        || matches.get_flag(options::USERS));
+
+    // If true, display user processes.
+    let need_users = all || matches.get_flag(options::USERS) || use_defaults;
+
+    // If true, display the hours:minutes since each user has touched
+    // the keyboard, or "." if within the last minute, or "old" if
+    // not within the last day.
+    let include_idle = need_deadprocs || need_login || need_runlevel || need_users;
+
+    // If true, display process termination & exit status.
+    let include_exit = need_deadprocs;
+
+    // If true, display only name, line, and time fields.
+    let short_output = !include_exit && use_defaults;
+
+    // If true, display info only for the controlling tty.
+    let my_line_only = matches.get_flag(options::ONLY_HOSTNAME_USER) || files.len() == 2;
+
+    let mut who = Who {
+        do_lookup,
+        short_list,
+        short_output,
+        include_idle,
+        include_heading,
+        include_mesg,
+        include_exit,
+        need_boottime,
+        need_deadprocs,
+        need_login,
+        need_initspawn,
+        need_clockchange,
+        need_runlevel,
+        need_users,
+        my_line_only,
+        args: files,
+    };
+
+    who.exec()
+}
+
+struct Who {
+    do_lookup: bool,
+    short_list: bool,
+    short_output: bool,
+    include_idle: bool,
+    include_heading: bool,
+    include_mesg: bool,
+    include_exit: bool,
+    need_boottime: bool,
+    need_deadprocs: bool,
+    need_login: bool,
+    need_initspawn: bool,
+    need_clockchange: bool,
+    need_runlevel: bool,
+    need_users: bool,
+    my_line_only: bool,
+    args: Vec<String>,
+}
+
+fn idle_string<'a>(when: i64, boottime: i64) -> Cow<'a, str> {
+    thread_local! {
+        static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
+    }
+    NOW.with(|n| {
+        let now = n.unix_timestamp();
+        if boottime < when && now - 24 * 3600 < when && when <= now {
+            let seconds_idle = now - when;
+            if seconds_idle < 60 {
+                "  .  ".into()
+            } else {
+                format!(
+                    "{:02}:{:02}",
+                    seconds_idle / 3600,
+                    (seconds_idle % 3600) / 60
+                )
+                .into()
+            }
+        } else {
+            " old ".into()
+        }
+    })
+}
+
+fn time_string(ut: &Utmpx) -> String {
+    // "%b %e %H:%M"
+    let time_format: Vec<time::format_description::FormatItem> =
+        time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
+            .unwrap();
+    ut.login_time().format(&time_format).unwrap() // LC_ALL=C
+}
+
+#[inline]
+fn current_tty() -> String {
+    unsafe {
+        let res = ttyname(STDIN_FILENO);
+        if res.is_null() {
+            String::new()
+        } else {
+            CStr::from_ptr(res as *const _)
+                .to_string_lossy()
+                .trim_start_matches("/dev/")
+                .to_owned()
+        }
+    }
+}
+
+impl Who {
+    #[allow(clippy::cognitive_complexity)]
+    fn exec(&mut self) -> UResult<()> {
+        let run_level_chk = |_record: i16| {
+            #[cfg(not(target_os = "linux"))]
+            return false;
+
+            #[cfg(target_os = "linux")]
+            return _record == utmpx::RUN_LVL;
+        };
+
+        let f = if self.args.len() == 1 {
+            self.args[0].as_ref()
+        } else {
+            utmpx::DEFAULT_FILE
+        };
+        if self.short_list {
+            let users = Utmpx::iter_all_records_from(f)
+                .filter(Utmpx::is_user_process)
+                .map(|ut| ut.user())
+                .collect::<Vec<_>>();
+            println!("{}", users.join(" "));
+            println!("# users={}", users.len());
+        } else {
+            let records = Utmpx::iter_all_records_from(f);
+
+            if self.include_heading {
+                self.print_heading();
+            }
+            let cur_tty = if self.my_line_only {
+                current_tty()
+            } else {
+                String::new()
+            };
+
+            for ut in records {
+                if !self.my_line_only || cur_tty == ut.tty_device() {
+                    if self.need_users && ut.is_user_process() {
+                        self.print_user(&ut)?;
+                    } else if self.need_runlevel && run_level_chk(ut.record_type()) {
+                        if cfg!(target_os = "linux") {
+                            self.print_runlevel(&ut);
+                        }
+                    } else if self.need_boottime && ut.record_type() == utmpx::BOOT_TIME {
+                        self.print_boottime(&ut);
+                    } else if self.need_clockchange && ut.record_type() == utmpx::NEW_TIME {
+                        self.print_clockchange(&ut);
+                    } else if self.need_initspawn && ut.record_type() == utmpx::INIT_PROCESS {
+                        self.print_initspawn(&ut);
+                    } else if self.need_login && ut.record_type() == utmpx::LOGIN_PROCESS {
+                        self.print_login(&ut);
+                    } else if self.need_deadprocs && ut.record_type() == utmpx::DEAD_PROCESS {
+                        self.print_deadprocs(&ut);
+                    }
+                }
+
+                if ut.record_type() == utmpx::BOOT_TIME {}
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn print_runlevel(&self, ut: &Utmpx) {
+        let last = (ut.pid() / 256) as u8 as char;
+        let curr = (ut.pid() % 256) as u8 as char;
+        let runlvline = format!("run-level {curr}");
+        let comment = format!("last={}", if last == 'N' { 'S' } else { 'N' });
+
+        self.print_line(
+            "",
+            ' ',
+            &runlvline,
+            &time_string(ut),
+            "",
+            "",
+            if last.is_control() { "" } else { &comment },
+            "",
+        );
+    }
+
+    #[inline]
+    fn print_clockchange(&self, ut: &Utmpx) {
+        self.print_line("", ' ', "clock change", &time_string(ut), "", "", "", "");
+    }
+
+    #[inline]
+    fn print_login(&self, ut: &Utmpx) {
+        let comment = format!("id={}", ut.terminal_suffix());
+        let pidstr = format!("{}", ut.pid());
+        self.print_line(
+            "LOGIN",
+            ' ',
+            &ut.tty_device(),
+            &time_string(ut),
+            "",
+            &pidstr,
+            &comment,
+            "",
+        );
+    }
+
+    #[inline]
+    fn print_deadprocs(&self, ut: &Utmpx) {
+        let comment = format!("id={}", ut.terminal_suffix());
+        let pidstr = format!("{}", ut.pid());
+        let e = ut.exit_status();
+        let exitstr = format!("term={} exit={}", e.0, e.1);
+        self.print_line(
+            "",
+            ' ',
+            &ut.tty_device(),
+            &time_string(ut),
+            "",
+            &pidstr,
+            &comment,
+            &exitstr,
+        );
+    }
+
+    #[inline]
+    fn print_initspawn(&self, ut: &Utmpx) {
+        let comment = format!("id={}", ut.terminal_suffix());
+        let pidstr = format!("{}", ut.pid());
+        self.print_line(
+            "",
+            ' ',
+            &ut.tty_device(),
+            &time_string(ut),
+            "",
+            &pidstr,
+            &comment,
+            "",
+        );
+    }
+
+    #[inline]
+    fn print_boottime(&self, ut: &Utmpx) {
+        self.print_line("", ' ', "system boot", &time_string(ut), "", "", "", "");
+    }
+
+    fn print_user(&self, ut: &Utmpx) -> UResult<()> {
+        let mut p = PathBuf::from("/dev");
+        p.push(ut.tty_device().as_str());
+        let mesg;
+        let last_change;
+        match p.metadata() {
+            Ok(meta) => {
+                #[cfg(all(
+                    not(target_os = "android"),
+                    not(target_os = "freebsd"),
+                    not(target_vendor = "apple")
+                ))]
+                let iwgrp = S_IWGRP;
+                #[cfg(any(target_os = "android", target_os = "freebsd", target_vendor = "apple"))]
+                let iwgrp = S_IWGRP as u32;
+                mesg = if meta.mode() & iwgrp == 0 { '-' } else { '+' };
+                last_change = meta.atime();
+            }
+            _ => {
+                mesg = '?';
+                last_change = 0;
+            }
+        }
+
+        let idle = if last_change == 0 {
+            "  ?".into()
+        } else {
+            idle_string(last_change, 0)
+        };
+
+        let s = if self.do_lookup {
+            ut.canon_host().map_err_context(|| {
+                let host = ut.host();
+                format!(
+                    "failed to canonicalize {}",
+                    host.split(':').next().unwrap_or(&host).quote()
+                )
+            })?
+        } else {
+            ut.host()
+        };
+        let hoststr = if s.is_empty() { s } else { format!("({s})") };
+
+        self.print_line(
+            ut.user().as_ref(),
+            mesg,
+            ut.tty_device().as_ref(),
+            time_string(ut).as_str(),
+            idle.as_ref(),
+            format!("{}", ut.pid()).as_str(),
+            hoststr.as_str(),
+            "",
+        );
+
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn print_line(
+        &self,
+        user: &str,
+        state: char,
+        line: &str,
+        time: &str,
+        idle: &str,
+        pid: &str,
+        comment: &str,
+        exit: &str,
+    ) {
+        let mut buf = String::with_capacity(64);
+        let msg = vec![' ', state].into_iter().collect::<String>();
+
+        write!(buf, "{user:<8}").unwrap();
+        if self.include_mesg {
+            buf.push_str(&msg);
+        }
+        write!(buf, " {line:<12}").unwrap();
+        // "%b %e %H:%M" (LC_ALL=C)
+        let time_size = 3 + 2 + 2 + 1 + 2;
+        write!(buf, " {time:<time_size$}").unwrap();
+
+        if !self.short_output {
+            if self.include_idle {
+                write!(buf, " {idle:<6}").unwrap();
+            }
+            write!(buf, " {pid:>10}").unwrap();
+        }
+        write!(buf, " {comment:<8}").unwrap();
+        if self.include_exit {
+            write!(buf, " {exit:<12}").unwrap();
+        }
+        println!("{}", buf.trim_end());
+    }
+
+    #[inline]
+    fn print_heading(&self) {
+        self.print_line(
+            "NAME", ' ', "LINE", "TIME", "IDLE", "PID", "COMMENT", "EXIT",
+        );
+    }
+}
diff --git a/src/uu/who/src/who.rs b/src/uu/who/src/who.rs
index 5d952efffb2..1eb28e874e8 100644
--- a/src/uu/who/src/who.rs
+++ b/src/uu/who/src/who.rs
@@ -5,19 +5,11 @@
 
 // spell-checker:ignore (ToDO) ttyname hostnames runlevel mesg wtmp statted boottime deadprocs initspawn clockchange curr runlvline pidstr exitstr hoststr
 
-use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult};
-use uucore::libc::{ttyname, STDIN_FILENO, S_IWGRP};
-use uucore::utmpx::{self, time, Utmpx};
-
 use clap::{crate_version, Arg, ArgAction, Command};
-use std::borrow::Cow;
-use std::ffi::CStr;
-use std::fmt::Write;
-use std::os::unix::fs::MetadataExt;
-use std::path::PathBuf;
 use uucore::{format_usage, help_about, help_usage};
 
+mod platform;
+
 mod options {
     pub const ALL: &str = "all";
     pub const BOOT: &str = "boot";
@@ -44,109 +36,8 @@ static RUNLEVEL_HELP: &str = "print current runlevel";
 #[cfg(not(target_os = "linux"))]
 static RUNLEVEL_HELP: &str = "print current runlevel (This is meaningless on non Linux)";
 
-fn get_long_usage() -> String {
-    format!(
-        "If FILE is not specified, use {}.  /var/log/wtmp as FILE is common.\n\
-         If ARG1 ARG2 given, -m presumed: 'am i' or 'mom likes' are usual.",
-        utmpx::DEFAULT_FILE,
-    )
-}
-
 #[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
-    let matches = uu_app()
-        .after_help(get_long_usage())
-        .try_get_matches_from(args)?;
-
-    let files: Vec<String> = matches
-        .get_many::<String>(options::FILE)
-        .map(|v| v.map(ToString::to_string).collect())
-        .unwrap_or_default();
-
-    // If true, attempt to canonicalize hostnames via a DNS lookup.
-    let do_lookup = matches.get_flag(options::LOOKUP);
-
-    // If true, display only a list of usernames and count of
-    // the users logged on.
-    // Ignored for 'who am i'.
-    let short_list = matches.get_flag(options::COUNT);
-
-    let all = matches.get_flag(options::ALL);
-
-    // If true, display a line at the top describing each field.
-    let include_heading = matches.get_flag(options::HEADING);
-
-    // If true, display a '+' for each user if mesg y, a '-' if mesg n,
-    // or a '?' if their tty cannot be statted.
-    let include_mesg = all || matches.get_flag(options::MESG);
-
-    // If true, display the last boot time.
-    let need_boottime = all || matches.get_flag(options::BOOT);
-
-    // If true, display dead processes.
-    let need_deadprocs = all || matches.get_flag(options::DEAD);
-
-    // If true, display processes waiting for user login.
-    let need_login = all || matches.get_flag(options::LOGIN);
-
-    // If true, display processes started by init.
-    let need_initspawn = all || matches.get_flag(options::PROCESS);
-
-    // If true, display the last clock change.
-    let need_clockchange = all || matches.get_flag(options::TIME);
-
-    // If true, display the current runlevel.
-    let need_runlevel = all || matches.get_flag(options::RUNLEVEL);
-
-    let use_defaults = !(all
-        || need_boottime
-        || need_deadprocs
-        || need_login
-        || need_initspawn
-        || need_runlevel
-        || need_clockchange
-        || matches.get_flag(options::USERS));
-
-    // If true, display user processes.
-    let need_users = all || matches.get_flag(options::USERS) || use_defaults;
-
-    // If true, display the hours:minutes since each user has touched
-    // the keyboard, or "." if within the last minute, or "old" if
-    // not within the last day.
-    let include_idle = need_deadprocs || need_login || need_runlevel || need_users;
-
-    // If true, display process termination & exit status.
-    let include_exit = need_deadprocs;
-
-    // If true, display only name, line, and time fields.
-    let short_output = !include_exit && use_defaults;
-
-    // If true, display info only for the controlling tty.
-    let my_line_only = matches.get_flag(options::ONLY_HOSTNAME_USER) || files.len() == 2;
-
-    let mut who = Who {
-        do_lookup,
-        short_list,
-        short_output,
-        include_idle,
-        include_heading,
-        include_mesg,
-        include_exit,
-        need_boottime,
-        need_deadprocs,
-        need_login,
-        need_initspawn,
-        need_clockchange,
-        need_runlevel,
-        need_users,
-        my_line_only,
-        args: files,
-    };
-
-    who.exec()
-}
+use platform::uumain;
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
@@ -258,312 +149,3 @@ pub fn uu_app() -> Command {
                 .value_hint(clap::ValueHint::FilePath),
         )
 }
-
-struct Who {
-    do_lookup: bool,
-    short_list: bool,
-    short_output: bool,
-    include_idle: bool,
-    include_heading: bool,
-    include_mesg: bool,
-    include_exit: bool,
-    need_boottime: bool,
-    need_deadprocs: bool,
-    need_login: bool,
-    need_initspawn: bool,
-    need_clockchange: bool,
-    need_runlevel: bool,
-    need_users: bool,
-    my_line_only: bool,
-    args: Vec<String>,
-}
-
-fn idle_string<'a>(when: i64, boottime: i64) -> Cow<'a, str> {
-    thread_local! {
-        static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
-    }
-    NOW.with(|n| {
-        let now = n.unix_timestamp();
-        if boottime < when && now - 24 * 3600 < when && when <= now {
-            let seconds_idle = now - when;
-            if seconds_idle < 60 {
-                "  .  ".into()
-            } else {
-                format!(
-                    "{:02}:{:02}",
-                    seconds_idle / 3600,
-                    (seconds_idle % 3600) / 60
-                )
-                .into()
-            }
-        } else {
-            " old ".into()
-        }
-    })
-}
-
-fn time_string(ut: &Utmpx) -> String {
-    // "%b %e %H:%M"
-    let time_format: Vec<time::format_description::FormatItem> =
-        time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
-            .unwrap();
-    ut.login_time().format(&time_format).unwrap() // LC_ALL=C
-}
-
-#[inline]
-fn current_tty() -> String {
-    unsafe {
-        let res = ttyname(STDIN_FILENO);
-        if res.is_null() {
-            String::new()
-        } else {
-            CStr::from_ptr(res as *const _)
-                .to_string_lossy()
-                .trim_start_matches("/dev/")
-                .to_owned()
-        }
-    }
-}
-
-impl Who {
-    #[allow(clippy::cognitive_complexity)]
-    fn exec(&mut self) -> UResult<()> {
-        let run_level_chk = |_record: i16| {
-            #[cfg(not(target_os = "linux"))]
-            return false;
-
-            #[cfg(target_os = "linux")]
-            return _record == utmpx::RUN_LVL;
-        };
-
-        let f = if self.args.len() == 1 {
-            self.args[0].as_ref()
-        } else {
-            utmpx::DEFAULT_FILE
-        };
-        if self.short_list {
-            let users = Utmpx::iter_all_records_from(f)
-                .filter(Utmpx::is_user_process)
-                .map(|ut| ut.user())
-                .collect::<Vec<_>>();
-            println!("{}", users.join(" "));
-            println!("# users={}", users.len());
-        } else {
-            let records = Utmpx::iter_all_records_from(f);
-
-            if self.include_heading {
-                self.print_heading();
-            }
-            let cur_tty = if self.my_line_only {
-                current_tty()
-            } else {
-                String::new()
-            };
-
-            for ut in records {
-                if !self.my_line_only || cur_tty == ut.tty_device() {
-                    if self.need_users && ut.is_user_process() {
-                        self.print_user(&ut)?;
-                    } else if self.need_runlevel && run_level_chk(ut.record_type()) {
-                        if cfg!(target_os = "linux") {
-                            self.print_runlevel(&ut);
-                        }
-                    } else if self.need_boottime && ut.record_type() == utmpx::BOOT_TIME {
-                        self.print_boottime(&ut);
-                    } else if self.need_clockchange && ut.record_type() == utmpx::NEW_TIME {
-                        self.print_clockchange(&ut);
-                    } else if self.need_initspawn && ut.record_type() == utmpx::INIT_PROCESS {
-                        self.print_initspawn(&ut);
-                    } else if self.need_login && ut.record_type() == utmpx::LOGIN_PROCESS {
-                        self.print_login(&ut);
-                    } else if self.need_deadprocs && ut.record_type() == utmpx::DEAD_PROCESS {
-                        self.print_deadprocs(&ut);
-                    }
-                }
-
-                if ut.record_type() == utmpx::BOOT_TIME {}
-            }
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn print_runlevel(&self, ut: &Utmpx) {
-        let last = (ut.pid() / 256) as u8 as char;
-        let curr = (ut.pid() % 256) as u8 as char;
-        let runlvline = format!("run-level {curr}");
-        let comment = format!("last={}", if last == 'N' { 'S' } else { 'N' });
-
-        self.print_line(
-            "",
-            ' ',
-            &runlvline,
-            &time_string(ut),
-            "",
-            "",
-            if last.is_control() { "" } else { &comment },
-            "",
-        );
-    }
-
-    #[inline]
-    fn print_clockchange(&self, ut: &Utmpx) {
-        self.print_line("", ' ', "clock change", &time_string(ut), "", "", "", "");
-    }
-
-    #[inline]
-    fn print_login(&self, ut: &Utmpx) {
-        let comment = format!("id={}", ut.terminal_suffix());
-        let pidstr = format!("{}", ut.pid());
-        self.print_line(
-            "LOGIN",
-            ' ',
-            &ut.tty_device(),
-            &time_string(ut),
-            "",
-            &pidstr,
-            &comment,
-            "",
-        );
-    }
-
-    #[inline]
-    fn print_deadprocs(&self, ut: &Utmpx) {
-        let comment = format!("id={}", ut.terminal_suffix());
-        let pidstr = format!("{}", ut.pid());
-        let e = ut.exit_status();
-        let exitstr = format!("term={} exit={}", e.0, e.1);
-        self.print_line(
-            "",
-            ' ',
-            &ut.tty_device(),
-            &time_string(ut),
-            "",
-            &pidstr,
-            &comment,
-            &exitstr,
-        );
-    }
-
-    #[inline]
-    fn print_initspawn(&self, ut: &Utmpx) {
-        let comment = format!("id={}", ut.terminal_suffix());
-        let pidstr = format!("{}", ut.pid());
-        self.print_line(
-            "",
-            ' ',
-            &ut.tty_device(),
-            &time_string(ut),
-            "",
-            &pidstr,
-            &comment,
-            "",
-        );
-    }
-
-    #[inline]
-    fn print_boottime(&self, ut: &Utmpx) {
-        self.print_line("", ' ', "system boot", &time_string(ut), "", "", "", "");
-    }
-
-    fn print_user(&self, ut: &Utmpx) -> UResult<()> {
-        let mut p = PathBuf::from("/dev");
-        p.push(ut.tty_device().as_str());
-        let mesg;
-        let last_change;
-        match p.metadata() {
-            Ok(meta) => {
-                #[cfg(all(
-                    not(target_os = "android"),
-                    not(target_os = "freebsd"),
-                    not(target_vendor = "apple")
-                ))]
-                let iwgrp = S_IWGRP;
-                #[cfg(any(target_os = "android", target_os = "freebsd", target_vendor = "apple"))]
-                let iwgrp = S_IWGRP as u32;
-                mesg = if meta.mode() & iwgrp == 0 { '-' } else { '+' };
-                last_change = meta.atime();
-            }
-            _ => {
-                mesg = '?';
-                last_change = 0;
-            }
-        }
-
-        let idle = if last_change == 0 {
-            "  ?".into()
-        } else {
-            idle_string(last_change, 0)
-        };
-
-        let s = if self.do_lookup {
-            ut.canon_host().map_err_context(|| {
-                let host = ut.host();
-                format!(
-                    "failed to canonicalize {}",
-                    host.split(':').next().unwrap_or(&host).quote()
-                )
-            })?
-        } else {
-            ut.host()
-        };
-        let hoststr = if s.is_empty() { s } else { format!("({s})") };
-
-        self.print_line(
-            ut.user().as_ref(),
-            mesg,
-            ut.tty_device().as_ref(),
-            time_string(ut).as_str(),
-            idle.as_ref(),
-            format!("{}", ut.pid()).as_str(),
-            hoststr.as_str(),
-            "",
-        );
-
-        Ok(())
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn print_line(
-        &self,
-        user: &str,
-        state: char,
-        line: &str,
-        time: &str,
-        idle: &str,
-        pid: &str,
-        comment: &str,
-        exit: &str,
-    ) {
-        let mut buf = String::with_capacity(64);
-        let msg = vec![' ', state].into_iter().collect::<String>();
-
-        write!(buf, "{user:<8}").unwrap();
-        if self.include_mesg {
-            buf.push_str(&msg);
-        }
-        write!(buf, " {line:<12}").unwrap();
-        // "%b %e %H:%M" (LC_ALL=C)
-        let time_size = 3 + 2 + 2 + 1 + 2;
-        write!(buf, " {time:<time_size$}").unwrap();
-
-        if !self.short_output {
-            if self.include_idle {
-                write!(buf, " {idle:<6}").unwrap();
-            }
-            write!(buf, " {pid:>10}").unwrap();
-        }
-        write!(buf, " {comment:<8}").unwrap();
-        if self.include_exit {
-            write!(buf, " {exit:<12}").unwrap();
-        }
-        println!("{}", buf.trim_end());
-    }
-
-    #[inline]
-    fn print_heading(&self) {
-        self.print_line(
-            "NAME", ' ', "LINE", "TIME", "IDLE", "PID", "COMMENT", "EXIT",
-        );
-    }
-}
diff --git a/src/uu/whoami/Cargo.toml b/src/uu/whoami/Cargo.toml
index 5336568334f..7e47898efa2 100644
--- a/src/uu/whoami/Cargo.toml
+++ b/src/uu/whoami/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_whoami"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "whoami ~ (uutils) display user name of current effective user ID"
@@ -16,7 +16,7 @@ path = "src/whoami.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["entries"] }
+uucore = { workspace = true, features = ["entries", "process"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 windows-sys = { workspace = true, features = [
diff --git a/src/uu/whoami/src/platform/unix.rs b/src/uu/whoami/src/platform/unix.rs
index 31ab16fba4c..9310a6de0a2 100644
--- a/src/uu/whoami/src/platform/unix.rs
+++ b/src/uu/whoami/src/platform/unix.rs
@@ -7,10 +7,9 @@ use std::ffi::OsString;
 use std::io;
 
 use uucore::entries::uid2usr;
+use uucore::process::geteuid;
 
 pub fn get_username() -> io::Result<OsString> {
-    // SAFETY: getuid() does nothing with memory and is always successful.
-    let uid = unsafe { libc::geteuid() };
     // uid2usr should arguably return an OsString but currently doesn't
-    uid2usr(uid).map(Into::into)
+    uid2usr(geteuid()).map(Into::into)
 }
diff --git a/src/uu/yes/Cargo.toml b/src/uu/yes/Cargo.toml
index dd562cab675..1f59bdb16f5 100644
--- a/src/uu/yes/Cargo.toml
+++ b/src/uu/yes/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_yes"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "yes ~ (uutils) repeatedly display a line with STRING (or 'y')"
diff --git a/src/uucore/Cargo.toml b/src/uucore/Cargo.toml
index 370c8a3864c..78c01cd071c 100644
--- a/src/uucore/Cargo.toml
+++ b/src/uucore/Cargo.toml
@@ -2,7 +2,7 @@
 
 [package]
 name = "uucore"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uutils ~ 'core' uutils code library (cross-platform)"
@@ -33,8 +33,8 @@ time = { workspace = true, optional = true, features = [
   "macros",
 ] }
 # * "problem" dependencies (pinned)
-data-encoding = { version = "2.4", optional = true }
-data-encoding-macro = { version = "0.1.13", optional = true }
+data-encoding = { version = "2.5", optional = true }
+data-encoding-macro = { version = "0.1.14", optional = true }
 z85 = { version = "3.0.5", optional = true }
 libc = { workspace = true, optional = true }
 once_cell = { workspace = true }
@@ -54,6 +54,7 @@ sm3 = { workspace = true, optional = true }
 [target.'cfg(unix)'.dependencies]
 walkdir = { workspace = true, optional = true }
 nix = { workspace = true, features = ["fs", "uio", "zerocopy", "signal"] }
+xattr = { workspace = true, optional = true }
 
 [dev-dependencies]
 clap = { workspace = true }
@@ -72,12 +73,14 @@ windows-sys = { workspace = true, optional = true, default-features = false, fea
 default = []
 # * non-default features
 backup-control = []
+colors = []
 encoding = ["data-encoding", "data-encoding-macro", "z85", "thiserror"]
 entries = ["libc"]
 fs = ["dunce", "libc", "winapi-util", "windows-sys"]
 fsext = ["libc", "time", "windows-sys"]
+fsxattr = ["xattr"]
 lines = []
-memo = ["itertools"]
+format = ["itertools"]
 mode = ["libc"]
 perms = ["libc", "walkdir"]
 pipes = []
diff --git a/src/uucore/src/lib/features.rs b/src/uucore/src/lib/features.rs
index 3a99eb84f43..423ff34bad9 100644
--- a/src/uucore/src/lib/features.rs
+++ b/src/uucore/src/lib/features.rs
@@ -6,16 +6,18 @@
 
 #[cfg(feature = "backup-control")]
 pub mod backup_control;
+#[cfg(feature = "colors")]
+pub mod colors;
 #[cfg(feature = "encoding")]
 pub mod encoding;
+#[cfg(feature = "format")]
+pub mod format;
 #[cfg(feature = "fs")]
 pub mod fs;
 #[cfg(feature = "fsext")]
 pub mod fsext;
 #[cfg(feature = "lines")]
 pub mod lines;
-#[cfg(feature = "memo")]
-pub mod memo;
 #[cfg(feature = "quoting-style")]
 pub mod quoting_style;
 #[cfg(feature = "ranges")]
@@ -24,8 +26,6 @@ pub mod ranges;
 pub mod ringbuffer;
 #[cfg(feature = "sum")]
 pub mod sum;
-#[cfg(feature = "memo")]
-mod tokenize;
 #[cfg(feature = "update-control")]
 pub mod update_control;
 #[cfg(feature = "version-cmp")]
@@ -46,12 +46,15 @@ pub mod pipes;
 #[cfg(all(unix, feature = "process"))]
 pub mod process;
 
+#[cfg(all(unix, not(target_os = "macos"), feature = "fsxattr"))]
+pub mod fsxattr;
 #[cfg(all(unix, not(target_os = "fuchsia"), feature = "signals"))]
 pub mod signals;
 #[cfg(all(
     unix,
     not(target_os = "android"),
     not(target_os = "fuchsia"),
+    not(target_os = "openbsd"),
     not(target_os = "redox"),
     not(target_env = "musl"),
     feature = "utmpx"
diff --git a/src/uucore/src/lib/features/backup_control.rs b/src/uucore/src/lib/features/backup_control.rs
index 86c7cd72b1d..fedbb375cb7 100644
--- a/src/uucore/src/lib/features/backup_control.rs
+++ b/src/uucore/src/lib/features/backup_control.rs
@@ -662,7 +662,7 @@ mod tests {
         let target = Path::new("data.txt");
         let suffix = String::from(".bak");
 
-        assert!(source_is_target_backup(&source, &target, &suffix));
+        assert!(source_is_target_backup(source, target, &suffix));
     }
 
     #[test]
@@ -671,7 +671,7 @@ mod tests {
         let target = Path::new("backup.txt");
         let suffix = String::from(".bak");
 
-        assert!(!source_is_target_backup(&source, &target, &suffix));
+        assert!(!source_is_target_backup(source, target, &suffix));
     }
 
     #[test]
@@ -680,6 +680,6 @@ mod tests {
         let target = Path::new("example");
         let suffix = String::from("~");
 
-        assert!(source_is_target_backup(&source, &target, &suffix));
+        assert!(source_is_target_backup(source, target, &suffix));
     }
 }
diff --git a/src/uucore/src/lib/features/colors.rs b/src/uucore/src/lib/features/colors.rs
new file mode 100644
index 00000000000..e0de8b1e3e3
--- /dev/null
+++ b/src/uucore/src/lib/features/colors.rs
@@ -0,0 +1,264 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// cSpell:disable
+
+/// The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the
+/// slackware version of dircolors) are recognized but ignored.
+/// Global config options can be specified before TERM or COLORTERM entries
+/// below are TERM or COLORTERM entries, which can be glob patterns, which
+/// restrict following config to systems with matching environment variables.
+pub static TERMS: &[&str] = &[
+    "Eterm",
+    "ansi",
+    "*color*",
+    "con[0-9]*x[0-9]*",
+    "cons25",
+    "console",
+    "cygwin",
+    "*direct*",
+    "dtterm",
+    "gnome",
+    "hurd",
+    "jfbterm",
+    "konsole",
+    "kterm",
+    "linux",
+    "linux-c",
+    "mlterm",
+    "putty",
+    "rxvt*",
+    "screen*",
+    "st",
+    "terminator",
+    "tmux*",
+    "vt100",
+    "xterm*",
+];
+
+/// Below are the color init strings for the basic file types.
+/// One can use codes for 256 or more colors supported by modern terminals.
+/// The default color codes use the capabilities of an 8 color terminal
+/// with some additional attributes as per the following codes:
+/// Attribute codes:
+/// 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
+/// Text color codes:
+/// 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
+/// Background color codes:
+/// 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
+/// #NORMAL 00 /// no color code at all
+/// #FILE 00 /// regular file: use no color at all
+pub static FILE_TYPES: &[(&str, &str, &str)] = &[
+    ("RESET", "rs", "0"),                     // reset to "normal" color
+    ("DIR", "di", "01;34"),                   // directory
+    ("LINK", "ln", "01;36"),                  // symbolic link
+    ("MULTIHARDLINK", "mh", "00"),            // regular file with more than one link
+    ("FIFO", "pi", "40;33"),                  // pipe
+    ("SOCK", "so", "01;35"),                  // socket
+    ("DOOR", "do", "01;35"),                  // door
+    ("BLK", "bd", "40;33;01"),                // block device driver
+    ("CHR", "cd", "40;33;01"),                // character device driver
+    ("ORPHAN", "or", "40;31;01"),             // symlink to nonexistent file, or non-stat'able file
+    ("MISSING", "mi", "00"),                  // ... and the files they point to
+    ("SETUID", "su", "37;41"),                // file that is setuid (u+s)
+    ("SETGID", "sg", "30;43"),                // file that is setgid (g+s)
+    ("CAPABILITY", "ca", "00"),               // file with capability
+    ("STICKY_OTHER_WRITABLE", "tw", "30;42"), // dir that is sticky and other-writable (+t,o+w)
+    ("OTHER_WRITABLE", "ow", "34;42"),        // dir that is other-writable (o+w) and not sticky
+    ("STICKY", "st", "37;44"), // dir with the sticky bit set (+t) and not other-writable
+    ("EXEC", "ex", "01;32"),   // files with execute permission
+];
+
+/// Colors for file types
+///
+/// List any file extensions like '.gz' or '.tar' that you would like ls
+/// to color below. Put the extension, a space, and the color init string.
+/// (and any comments you want to add after a '#')
+pub static FILE_COLORS: &[(&str, &str)] = &[
+    /*
+    // Executables (Windows)
+    (".cmd", "01;32"),
+    (".exe", "01;32"),
+    (".com", "01;32"),
+    (".btm", "01;32"),
+    (".bat", "01;32"),
+    (".sh", "01;32"),
+    (".csh", "01;32"),*/
+    // Archives or compressed
+    (".tar", "01;31"),
+    (".tgz", "01;31"),
+    (".arc", "01;31"),
+    (".arj", "01;31"),
+    (".taz", "01;31"),
+    (".lha", "01;31"),
+    (".lz4", "01;31"),
+    (".lzh", "01;31"),
+    (".lzma", "01;31"),
+    (".tlz", "01;31"),
+    (".txz", "01;31"),
+    (".tzo", "01;31"),
+    (".t7z", "01;31"),
+    (".zip", "01;31"),
+    (".z", "01;31"),
+    (".dz", "01;31"),
+    (".gz", "01;31"),
+    (".lrz", "01;31"),
+    (".lz", "01;31"),
+    (".lzo", "01;31"),
+    (".xz", "01;31"),
+    (".zst", "01;31"),
+    (".tzst", "01;31"),
+    (".bz2", "01;31"),
+    (".bz", "01;31"),
+    (".tbz", "01;31"),
+    (".tbz2", "01;31"),
+    (".tz", "01;31"),
+    (".deb", "01;31"),
+    (".rpm", "01;31"),
+    (".jar", "01;31"),
+    (".war", "01;31"),
+    (".ear", "01;31"),
+    (".sar", "01;31"),
+    (".rar", "01;31"),
+    (".alz", "01;31"),
+    (".ace", "01;31"),
+    (".zoo", "01;31"),
+    (".cpio", "01;31"),
+    (".7z", "01;31"),
+    (".rz", "01;31"),
+    (".cab", "01;31"),
+    (".wim", "01;31"),
+    (".swm", "01;31"),
+    (".dwm", "01;31"),
+    (".esd", "01;31"),
+    // Image formats
+    (".avif", "01;35"),
+    (".jpg", "01;35"),
+    (".jpeg", "01;35"),
+    (".mjpg", "01;35"),
+    (".mjpeg", "01;35"),
+    (".gif", "01;35"),
+    (".bmp", "01;35"),
+    (".pbm", "01;35"),
+    (".pgm", "01;35"),
+    (".ppm", "01;35"),
+    (".tga", "01;35"),
+    (".xbm", "01;35"),
+    (".xpm", "01;35"),
+    (".tif", "01;35"),
+    (".tiff", "01;35"),
+    (".png", "01;35"),
+    (".svg", "01;35"),
+    (".svgz", "01;35"),
+    (".mng", "01;35"),
+    (".pcx", "01;35"),
+    (".mov", "01;35"),
+    (".mpg", "01;35"),
+    (".mpeg", "01;35"),
+    (".m2v", "01;35"),
+    (".mkv", "01;35"),
+    (".webm", "01;35"),
+    (".webp", "01;35"),
+    (".ogm", "01;35"),
+    (".mp4", "01;35"),
+    (".m4v", "01;35"),
+    (".mp4v", "01;35"),
+    (".vob", "01;35"),
+    (".qt", "01;35"),
+    (".nuv", "01;35"),
+    (".wmv", "01;35"),
+    (".asf", "01;35"),
+    (".rm", "01;35"),
+    (".rmvb", "01;35"),
+    (".flc", "01;35"),
+    (".avi", "01;35"),
+    (".fli", "01;35"),
+    (".flv", "01;35"),
+    (".gl", "01;35"),
+    (".dl", "01;35"),
+    (".xcf", "01;35"),
+    (".xwd", "01;35"),
+    (".yuv", "01;35"),
+    (".cgm", "01;35"),
+    (".emf", "01;35"),
+    // https://wiki.xiph.org/MIME_Types_and_File_Extensions
+    (".ogv", "01;35"),
+    (".ogx", "01;35"),
+    // Audio formats
+    (".aac", "00;36"),
+    (".au", "00;36"),
+    (".flac", "00;36"),
+    (".m4a", "00;36"),
+    (".mid", "00;36"),
+    (".midi", "00;36"),
+    (".mka", "00;36"),
+    (".mp3", "00;36"),
+    (".mpc", "00;36"),
+    (".ogg", "00;36"),
+    (".ra", "00;36"),
+    (".wav", "00;36"),
+    // https://wiki.xiph.org/MIME_Types_and_File_Extensions
+    (".oga", "00;36"),
+    (".opus", "00;36"),
+    (".spx", "00;36"),
+    (".xspf", "00;36"),
+    // Backup files
+    ("*~", "00;90"),
+    ("*#", "00;90"),
+    (".bak", "00;90"),
+    (".old", "00;90"),
+    (".orig", "00;90"),
+    (".part", "00;90"),
+    (".rej", "00;90"),
+    (".swp", "00;90"),
+    (".tmp", "00;90"),
+    (".dpkg-dist", "00;90"),
+    (".dpkg-old", "00;90"),
+    (".ucf-dist", "00;90"),
+    (".ucf-new", "00;90"),
+    (".ucf-old", "00;90"),
+    (".rpmnew", "00;90"),
+    (".rpmorig", "00;90"),
+    (".rpmsave", "00;90"),
+];
+
+pub static FILE_ATTRIBUTE_CODES: &[(&str, &str)] = &[
+    ("normal", "no"),
+    ("norm", "no"),
+    ("file", "fi"),
+    ("reset", "rs"),
+    ("dir", "di"),
+    ("lnk", "ln"),
+    ("link", "ln"),
+    ("symlink", "ln"),
+    ("orphan", "or"),
+    ("missing", "mi"),
+    ("fifo", "pi"),
+    ("pipe", "pi"),
+    ("sock", "so"),
+    ("blk", "bd"),
+    ("block", "bd"),
+    ("chr", "cd"),
+    ("char", "cd"),
+    ("door", "do"),
+    ("exec", "ex"),
+    ("left", "lc"),
+    ("leftcode", "lc"),
+    ("right", "rc"),
+    ("rightcode", "rc"),
+    ("end", "ec"),
+    ("endcode", "ec"),
+    ("suid", "su"),
+    ("setuid", "su"),
+    ("sgid", "sg"),
+    ("setgid", "sg"),
+    ("sticky", "st"),
+    ("other_writable", "ow"),
+    ("owr", "ow"),
+    ("sticky_other_writable", "tw"),
+    ("owt", "tw"),
+    ("capability", "ca"),
+    ("multihardlink", "mh"),
+    ("clrtoeol", "cl"),
+];
diff --git a/src/uucore/src/lib/features/encoding.rs b/src/uucore/src/lib/features/encoding.rs
index 14fdbb38ee7..db218d5f061 100644
--- a/src/uucore/src/lib/features/encoding.rs
+++ b/src/uucore/src/lib/features/encoding.rs
@@ -27,6 +27,7 @@ pub enum DecodeError {
 
 pub enum EncodeError {
     Z85InputLenNotMultipleOf4,
+    InvalidInput,
 }
 
 pub type DecodeResult = Result<Vec<u8>, DecodeError>;
@@ -148,8 +149,10 @@ impl<R: Read> Data<R> {
 
     pub fn encode(&mut self) -> Result<String, EncodeError> {
         let mut buf: Vec<u8> = vec![];
-        self.input.read_to_end(&mut buf).unwrap();
-        encode(self.format, buf.as_slice())
+        match self.input.read_to_end(&mut buf) {
+            Ok(_) => encode(self.format, buf.as_slice()),
+            Err(_) => Err(EncodeError::InvalidInput),
+        }
     }
 }
 
diff --git a/src/uucore/src/lib/features/entries.rs b/src/uucore/src/lib/features/entries.rs
index 29c9b437234..fa10ba2decb 100644
--- a/src/uucore/src/lib/features/entries.rs
+++ b/src/uucore/src/lib/features/entries.rs
@@ -35,7 +35,6 @@
 #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
 use libc::time_t;
 use libc::{c_char, c_int, gid_t, uid_t};
-#[cfg(not(target_os = "redox"))]
 use libc::{getgrgid, getgrnam, getgroups};
 use libc::{getpwnam, getpwuid, group, passwd};
 
@@ -67,7 +66,6 @@ extern "C" {
 /// > supplementary group IDs for the process is returned.  This allows
 /// > the caller to determine the size of a dynamically allocated list
 /// > to be used in a further call to getgroups().
-#[cfg(not(target_os = "redox"))]
 pub fn get_groups() -> IOResult<Vec<gid_t>> {
     let mut groups = Vec::new();
     loop {
@@ -337,7 +335,6 @@ macro_rules! f {
 }
 
 f!(getpwnam, getpwuid, uid_t, Passwd);
-#[cfg(not(target_os = "redox"))]
 f!(getgrnam, getgrgid, gid_t, Group);
 
 #[inline]
@@ -345,7 +342,6 @@ pub fn uid2usr(id: uid_t) -> IOResult<String> {
     Passwd::locate(id).map(|p| p.name)
 }
 
-#[cfg(not(target_os = "redox"))]
 #[inline]
 pub fn gid2grp(id: gid_t) -> IOResult<String> {
     Group::locate(id).map(|p| p.name)
@@ -356,7 +352,6 @@ pub fn usr2uid(name: &str) -> IOResult<uid_t> {
     Passwd::locate(name).map(|p| p.uid)
 }
 
-#[cfg(not(target_os = "redox"))]
 #[inline]
 pub fn grp2gid(name: &str) -> IOResult<gid_t> {
     Group::locate(name).map(|p| p.gid)
diff --git a/src/uucore/src/lib/features/format/argument.rs b/src/uucore/src/lib/features/format/argument.rs
new file mode 100644
index 00000000000..ef81fc3533b
--- /dev/null
+++ b/src/uucore/src/lib/features/format/argument.rs
@@ -0,0 +1,128 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use crate::{
+    error::set_exit_code,
+    features::format::num_parser::{ParseError, ParsedNumber},
+    quoting_style::{escape_name, Quotes, QuotingStyle},
+    show_error, show_warning,
+};
+use os_display::Quotable;
+use std::ffi::OsStr;
+
+/// An argument for formatting
+///
+/// Each of these variants is only accepted by their respective directives. For
+/// example, [`FormatArgument::Char`] requires a `%c` directive.
+///
+/// The [`FormatArgument::Unparsed`] variant contains a string that can be
+/// parsed into other types. This is used by the `printf` utility.
+#[derive(Clone, Debug)]
+pub enum FormatArgument {
+    Char(char),
+    String(String),
+    UnsignedInt(u64),
+    SignedInt(i64),
+    Float(f64),
+    /// Special argument that gets coerced into the other variants
+    Unparsed(String),
+}
+
+pub trait ArgumentIter<'a>: Iterator<Item = &'a FormatArgument> {
+    fn get_char(&mut self) -> char;
+    fn get_i64(&mut self) -> i64;
+    fn get_u64(&mut self) -> u64;
+    fn get_f64(&mut self) -> f64;
+    fn get_str(&mut self) -> &'a str;
+}
+
+impl<'a, T: Iterator<Item = &'a FormatArgument>> ArgumentIter<'a> for T {
+    fn get_char(&mut self) -> char {
+        let Some(next) = self.next() else {
+            return '\0';
+        };
+        match next {
+            FormatArgument::Char(c) => *c,
+            FormatArgument::Unparsed(s) => s.bytes().next().map_or('\0', char::from),
+            _ => '\0',
+        }
+    }
+
+    fn get_u64(&mut self) -> u64 {
+        let Some(next) = self.next() else {
+            return 0;
+        };
+        match next {
+            FormatArgument::UnsignedInt(n) => *n,
+            FormatArgument::Unparsed(s) => extract_value(ParsedNumber::parse_u64(s), s),
+            _ => 0,
+        }
+    }
+
+    fn get_i64(&mut self) -> i64 {
+        let Some(next) = self.next() else {
+            return 0;
+        };
+        match next {
+            FormatArgument::SignedInt(n) => *n,
+            FormatArgument::Unparsed(s) => extract_value(ParsedNumber::parse_i64(s), s),
+            _ => 0,
+        }
+    }
+
+    fn get_f64(&mut self) -> f64 {
+        let Some(next) = self.next() else {
+            return 0.0;
+        };
+        match next {
+            FormatArgument::Float(n) => *n,
+            FormatArgument::Unparsed(s) => extract_value(ParsedNumber::parse_f64(s), s),
+            _ => 0.0,
+        }
+    }
+
+    fn get_str(&mut self) -> &'a str {
+        match self.next() {
+            Some(FormatArgument::Unparsed(s) | FormatArgument::String(s)) => s,
+            _ => "",
+        }
+    }
+}
+
+fn extract_value<T: Default>(p: Result<T, ParseError<'_, T>>, input: &str) -> T {
+    match p {
+        Ok(v) => v,
+        Err(e) => {
+            set_exit_code(1);
+            let input = escape_name(
+                OsStr::new(input),
+                &QuotingStyle::C {
+                    quotes: Quotes::None,
+                },
+            );
+            match e {
+                ParseError::Overflow => {
+                    show_error!("{}: Numerical result out of range", input.quote());
+                    Default::default()
+                }
+                ParseError::NotNumeric => {
+                    show_error!("{}: expected a numeric value", input.quote());
+                    Default::default()
+                }
+                ParseError::PartialMatch(v, rest) => {
+                    if input.starts_with('\'') {
+                        show_warning!(
+                            "{}: character(s) following character constant have been ignored",
+                            &rest,
+                        );
+                    } else {
+                        show_error!("{}: value not completely converted", input.quote());
+                    }
+                    v
+                }
+            }
+        }
+    }
+}
diff --git a/src/uucore/src/lib/features/format/escape.rs b/src/uucore/src/lib/features/format/escape.rs
new file mode 100644
index 00000000000..9420507f3e3
--- /dev/null
+++ b/src/uucore/src/lib/features/format/escape.rs
@@ -0,0 +1,136 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Parsing of escape sequences
+
+#[derive(Debug)]
+pub enum EscapedChar {
+    /// A single byte
+    Byte(u8),
+    /// A unicode character
+    Char(char),
+    /// A character prefixed with a backslash (i.e. an invalid escape sequence)
+    Backslash(u8),
+    /// Specifies that the string should stop (`\c`)
+    End,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy)]
+enum Base {
+    Oct = 8,
+    Hex = 16,
+}
+
+impl Base {
+    fn max_digits(&self) -> u8 {
+        match self {
+            Self::Oct => 3,
+            Self::Hex => 2,
+        }
+    }
+
+    fn convert_digit(&self, c: u8) -> Option<u8> {
+        match self {
+            Self::Oct => {
+                if matches!(c, b'0'..=b'7') {
+                    Some(c - b'0')
+                } else {
+                    None
+                }
+            }
+            Self::Hex => match c {
+                b'0'..=b'9' => Some(c - b'0'),
+                b'A'..=b'F' => Some(c - b'A' + 10),
+                b'a'..=b'f' => Some(c - b'a' + 10),
+                _ => None,
+            },
+        }
+    }
+}
+
+/// Parse the numeric part of the `\xHHH` and `\0NNN` escape sequences
+fn parse_code(input: &mut &[u8], base: Base) -> Option<u8> {
+    // All arithmetic on `ret` needs to be wrapping, because octal input can
+    // take 3 digits, which is 9 bits, and therefore more than what fits in a
+    // `u8`. GNU just seems to wrap these values.
+    // Note that if we instead make `ret` a `u32` and use `char::from_u32` will
+    // yield incorrect results because it will interpret values larger than
+    // `u8::MAX` as unicode.
+    let [c, rest @ ..] = input else { return None };
+    let mut ret = base.convert_digit(*c)?;
+    *input = rest;
+
+    for _ in 1..base.max_digits() {
+        let [c, rest @ ..] = input else { break };
+        let Some(n) = base.convert_digit(*c) else {
+            break;
+        };
+        ret = ret.wrapping_mul(base as u8).wrapping_add(n);
+        *input = rest;
+    }
+
+    Some(ret)
+}
+
+// spell-checker:disable-next
+/// Parse `\uHHHH` and `\UHHHHHHHH`
+// TODO: This should print warnings and possibly halt execution when it fails to parse
+// TODO: If the character cannot be converted to u32, the input should be printed.
+fn parse_unicode(input: &mut &[u8], digits: u8) -> Option<char> {
+    let (c, rest) = input.split_first()?;
+    let mut ret = Base::Hex.convert_digit(*c)? as u32;
+    *input = rest;
+
+    for _ in 1..digits {
+        let (c, rest) = input.split_first()?;
+        let n = Base::Hex.convert_digit(*c)?;
+        ret = ret.wrapping_mul(Base::Hex as u32).wrapping_add(n as u32);
+        *input = rest;
+    }
+
+    char::from_u32(ret)
+}
+
+pub fn parse_escape_code(rest: &mut &[u8]) -> EscapedChar {
+    if let [c, new_rest @ ..] = rest {
+        // This is for the \NNN syntax for octal sequences.
+        // Note that '0' is intentionally omitted because that
+        // would be the \0NNN syntax.
+        if let b'1'..=b'7' = c {
+            if let Some(parsed) = parse_code(rest, Base::Oct) {
+                return EscapedChar::Byte(parsed);
+            }
+        }
+
+        *rest = new_rest;
+        match c {
+            b'\\' => EscapedChar::Byte(b'\\'),
+            b'"' => EscapedChar::Byte(b'"'),
+            b'a' => EscapedChar::Byte(b'\x07'),
+            b'b' => EscapedChar::Byte(b'\x08'),
+            b'c' => EscapedChar::End,
+            b'e' => EscapedChar::Byte(b'\x1b'),
+            b'f' => EscapedChar::Byte(b'\x0c'),
+            b'n' => EscapedChar::Byte(b'\n'),
+            b'r' => EscapedChar::Byte(b'\r'),
+            b't' => EscapedChar::Byte(b'\t'),
+            b'v' => EscapedChar::Byte(b'\x0b'),
+            b'x' => {
+                if let Some(c) = parse_code(rest, Base::Hex) {
+                    EscapedChar::Byte(c)
+                } else {
+                    EscapedChar::Backslash(b'x')
+                }
+            }
+            b'0' => EscapedChar::Byte(parse_code(rest, Base::Oct).unwrap_or(b'\0')),
+            b'u' => EscapedChar::Char(parse_unicode(rest, 4).unwrap_or('\0')),
+            b'U' => EscapedChar::Char(parse_unicode(rest, 8).unwrap_or('\0')),
+            c => EscapedChar::Backslash(*c),
+        }
+    } else {
+        EscapedChar::Byte(b'\\')
+    }
+}
diff --git a/src/uucore/src/lib/features/format/mod.rs b/src/uucore/src/lib/features/format/mod.rs
new file mode 100644
index 00000000000..8f662080dcb
--- /dev/null
+++ b/src/uucore/src/lib/features/format/mod.rs
@@ -0,0 +1,344 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! `printf`-style formatting
+//!
+//! Rust has excellent formatting capabilities, but the coreutils require very
+//! specific formatting that needs to work exactly like the GNU utilities.
+//! Naturally, the GNU behavior is based on the C `printf` functionality.
+//!
+//! Additionally, we need support for escape sequences for the `printf` utility.
+//!
+//! The [`printf`] and [`sprintf`] functions closely match the behavior of the
+//! corresponding C functions: the former renders a formatted string
+//! to stdout, the latter renders to a new [`String`] object.
+//!
+//! There are three kinds of parsing that we might want to do:
+//!
+//!  1. Parse only `printf` directives (for e.g. `seq`, `dd`)
+//!  2. Parse only escape sequences (for e.g. `echo`)
+//!  3. Parse both `printf` specifiers and escape sequences (for e.g. `printf`)
+//!
+//! This module aims to combine all three use cases. An iterator parsing each
+//! of these cases is provided by [`parse_escape_only`], [`parse_spec_only`]
+//! and [`parse_spec_and_escape`], respectively.
+//!
+//! There is a special [`Format`] type, which can be used to parse a format
+//! string containing exactly one directive and does not use any `*` in that
+//! directive. This format can be printed in a type-safe manner without failing
+//! (modulo IO errors).
+
+mod argument;
+mod escape;
+pub mod num_format;
+pub mod num_parser;
+mod spec;
+
+pub use argument::*;
+use spec::Spec;
+use std::{
+    error::Error,
+    fmt::Display,
+    io::{stdout, Write},
+    ops::ControlFlow,
+};
+
+use crate::error::UError;
+
+use self::{
+    escape::{parse_escape_code, EscapedChar},
+    num_format::Formatter,
+};
+
+#[derive(Debug)]
+pub enum FormatError {
+    SpecError(Vec<u8>),
+    IoError(std::io::Error),
+    NoMoreArguments,
+    InvalidArgument(FormatArgument),
+    TooManySpecs(Vec<u8>),
+    NeedAtLeastOneSpec(Vec<u8>),
+    WrongSpecType,
+}
+
+impl Error for FormatError {}
+impl UError for FormatError {}
+
+impl From<std::io::Error> for FormatError {
+    fn from(value: std::io::Error) -> Self {
+        Self::IoError(value)
+    }
+}
+
+impl Display for FormatError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::SpecError(s) => write!(
+                f,
+                "%{}: invalid conversion specification",
+                String::from_utf8_lossy(s)
+            ),
+            Self::TooManySpecs(s) => write!(
+                f,
+                "format '{}' has too many % directives",
+                String::from_utf8_lossy(s)
+            ),
+            Self::NeedAtLeastOneSpec(s) => write!(
+                f,
+                "format '{}' has no % directive",
+                String::from_utf8_lossy(s)
+            ),
+            // TODO: Error message below needs some work
+            Self::WrongSpecType => write!(f, "wrong % directive type was given"),
+            Self::IoError(_) => write!(f, "io error"),
+            Self::NoMoreArguments => write!(f, "no more arguments"),
+            Self::InvalidArgument(_) => write!(f, "invalid argument"),
+        }
+    }
+}
+
+/// A single item to format
+pub enum FormatItem<C: FormatChar> {
+    /// A format specifier
+    Spec(Spec),
+    /// A single character
+    Char(C),
+}
+
+pub trait FormatChar {
+    fn write(&self, writer: impl Write) -> std::io::Result<ControlFlow<()>>;
+}
+
+impl FormatChar for u8 {
+    fn write(&self, mut writer: impl Write) -> std::io::Result<ControlFlow<()>> {
+        writer.write_all(&[*self])?;
+        Ok(ControlFlow::Continue(()))
+    }
+}
+
+impl FormatChar for EscapedChar {
+    fn write(&self, mut writer: impl Write) -> std::io::Result<ControlFlow<()>> {
+        match self {
+            Self::Byte(c) => {
+                writer.write_all(&[*c])?;
+            }
+            Self::Char(c) => {
+                write!(writer, "{c}")?;
+            }
+            Self::Backslash(c) => {
+                writer.write_all(&[b'\\', *c])?;
+            }
+            Self::End => return Ok(ControlFlow::Break(())),
+        }
+        Ok(ControlFlow::Continue(()))
+    }
+}
+
+impl<C: FormatChar> FormatItem<C> {
+    pub fn write<'a>(
+        &self,
+        writer: impl Write,
+        args: &mut impl Iterator<Item = &'a FormatArgument>,
+    ) -> Result<ControlFlow<()>, FormatError> {
+        match self {
+            Self::Spec(spec) => spec.write(writer, args)?,
+            Self::Char(c) => return c.write(writer).map_err(FormatError::IoError),
+        };
+        Ok(ControlFlow::Continue(()))
+    }
+}
+
+/// Parse a format string containing % directives and escape sequences
+pub fn parse_spec_and_escape(
+    fmt: &[u8],
+) -> impl Iterator<Item = Result<FormatItem<EscapedChar>, FormatError>> + '_ {
+    let mut current = fmt;
+    std::iter::from_fn(move || match current {
+        [] => None,
+        [b'%', b'%', rest @ ..] => {
+            current = rest;
+            Some(Ok(FormatItem::Char(EscapedChar::Byte(b'%'))))
+        }
+        [b'%', rest @ ..] => {
+            current = rest;
+            let spec = match Spec::parse(&mut current) {
+                Ok(spec) => spec,
+                Err(slice) => return Some(Err(FormatError::SpecError(slice.to_vec()))),
+            };
+            Some(Ok(FormatItem::Spec(spec)))
+        }
+        [b'\\', rest @ ..] => {
+            current = rest;
+            Some(Ok(FormatItem::Char(parse_escape_code(&mut current))))
+        }
+        [c, rest @ ..] => {
+            current = rest;
+            Some(Ok(FormatItem::Char(EscapedChar::Byte(*c))))
+        }
+    })
+}
+
+/// Parse a format string containing % directives
+pub fn parse_spec_only(
+    fmt: &[u8],
+) -> impl Iterator<Item = Result<FormatItem<u8>, FormatError>> + '_ {
+    let mut current = fmt;
+    std::iter::from_fn(move || match current {
+        [] => None,
+        [b'%', b'%', rest @ ..] => {
+            current = rest;
+            Some(Ok(FormatItem::Char(b'%')))
+        }
+        [b'%', rest @ ..] => {
+            current = rest;
+            let spec = match Spec::parse(&mut current) {
+                Ok(spec) => spec,
+                Err(slice) => return Some(Err(FormatError::SpecError(slice.to_vec()))),
+            };
+            Some(Ok(FormatItem::Spec(spec)))
+        }
+        [c, rest @ ..] => {
+            current = rest;
+            Some(Ok(FormatItem::Char(*c)))
+        }
+    })
+}
+
+/// Parse a format string containing escape sequences
+pub fn parse_escape_only(fmt: &[u8]) -> impl Iterator<Item = EscapedChar> + '_ {
+    let mut current = fmt;
+    std::iter::from_fn(move || match current {
+        [] => None,
+        [b'\\', rest @ ..] => {
+            current = rest;
+            Some(parse_escape_code(&mut current))
+        }
+        [c, rest @ ..] => {
+            current = rest;
+            Some(EscapedChar::Byte(*c))
+        }
+    })
+}
+
+/// Write a formatted string to stdout.
+///
+/// `format_string` contains the template and `args` contains the
+/// arguments to render into the template.
+///
+/// See also [`sprintf`], which creates a new formatted [`String`].
+///
+/// # Examples
+///
+/// ```rust
+/// use uucore::format::{printf, FormatArgument};
+///
+/// printf("hello %s", &[FormatArgument::String("world".into())]).unwrap();
+/// // prints "hello world"
+/// ```
+pub fn printf<'a>(
+    format_string: impl AsRef<[u8]>,
+    arguments: impl IntoIterator<Item = &'a FormatArgument>,
+) -> Result<(), FormatError> {
+    printf_writer(stdout(), format_string, arguments)
+}
+
+fn printf_writer<'a>(
+    mut writer: impl Write,
+    format_string: impl AsRef<[u8]>,
+    args: impl IntoIterator<Item = &'a FormatArgument>,
+) -> Result<(), FormatError> {
+    let mut args = args.into_iter();
+    for item in parse_spec_only(format_string.as_ref()) {
+        item?.write(&mut writer, &mut args)?;
+    }
+    Ok(())
+}
+
+/// Create a new formatted string.
+///
+/// `format_string` contains the template and `args` contains the
+/// arguments to render into the template.
+///
+/// See also [`printf`], which prints to stdout.
+///
+/// # Examples
+///
+/// ```rust
+/// use uucore::format::{sprintf, FormatArgument};
+///
+/// let s = sprintf("hello %s", &[FormatArgument::String("world".into())]).unwrap();
+/// let s = std::str::from_utf8(&s).unwrap();
+/// assert_eq!(s, "hello world");
+/// ```
+pub fn sprintf<'a>(
+    format_string: impl AsRef<[u8]>,
+    arguments: impl IntoIterator<Item = &'a FormatArgument>,
+) -> Result<Vec<u8>, FormatError> {
+    let mut writer = Vec::new();
+    printf_writer(&mut writer, format_string, arguments)?;
+    Ok(writer)
+}
+
+/// A parsed format for a single float value
+///
+/// This is used by `seq`. It can be constructed with [`Format::parse`]
+/// and can write a value with [`Format::fmt`].
+///
+/// It can only accept a single specification without any asterisk parameters.
+/// If it does get more specifications, it will return an error.
+pub struct Format<F: Formatter> {
+    prefix: Vec<u8>,
+    suffix: Vec<u8>,
+    formatter: F,
+}
+
+impl<F: Formatter> Format<F> {
+    pub fn parse(format_string: impl AsRef<[u8]>) -> Result<Self, FormatError> {
+        let mut iter = parse_spec_only(format_string.as_ref());
+
+        let mut prefix = Vec::new();
+        let mut spec = None;
+        for item in &mut iter {
+            match item? {
+                FormatItem::Spec(s) => {
+                    spec = Some(s);
+                    break;
+                }
+                FormatItem::Char(c) => prefix.push(c),
+            }
+        }
+
+        let Some(spec) = spec else {
+            return Err(FormatError::NeedAtLeastOneSpec(
+                format_string.as_ref().to_vec(),
+            ));
+        };
+
+        let formatter = F::try_from_spec(spec)?;
+
+        let mut suffix = Vec::new();
+        for item in &mut iter {
+            match item? {
+                FormatItem::Spec(_) => {
+                    return Err(FormatError::TooManySpecs(format_string.as_ref().to_vec()));
+                }
+                FormatItem::Char(c) => suffix.push(c),
+            }
+        }
+
+        Ok(Self {
+            prefix,
+            suffix,
+            formatter,
+        })
+    }
+
+    pub fn fmt(&self, mut w: impl Write, f: F::Input) -> std::io::Result<()> {
+        w.write_all(&self.prefix)?;
+        self.formatter.fmt(&mut w, f)?;
+        w.write_all(&self.suffix)?;
+        Ok(())
+    }
+}
diff --git a/src/uucore/src/lib/features/format/num_format.rs b/src/uucore/src/lib/features/format/num_format.rs
new file mode 100644
index 00000000000..607c028c32c
--- /dev/null
+++ b/src/uucore/src/lib/features/format/num_format.rs
@@ -0,0 +1,641 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Utilities for formatting numbers in various formats
+
+use std::io::Write;
+
+use super::{
+    spec::{CanAsterisk, Spec},
+    FormatError,
+};
+
+pub trait Formatter {
+    type Input;
+    fn fmt(&self, writer: impl Write, x: Self::Input) -> std::io::Result<()>;
+    fn try_from_spec(s: Spec) -> Result<Self, FormatError>
+    where
+        Self: Sized;
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum UnsignedIntVariant {
+    Decimal,
+    Octal(Prefix),
+    Hexadecimal(Case, Prefix),
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum FloatVariant {
+    Decimal,
+    Scientific,
+    Shortest,
+    Hexadecimal,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Case {
+    Lowercase,
+    Uppercase,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Prefix {
+    No,
+    Yes,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ForceDecimal {
+    No,
+    Yes,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum PositiveSign {
+    None,
+    Plus,
+    Space,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum NumberAlignment {
+    Left,
+    RightSpace,
+    RightZero,
+}
+
+pub struct SignedInt {
+    pub width: usize,
+    pub precision: usize,
+    pub positive_sign: PositiveSign,
+    pub alignment: NumberAlignment,
+}
+
+impl Formatter for SignedInt {
+    type Input = i64;
+
+    fn fmt(&self, mut writer: impl Write, x: Self::Input) -> std::io::Result<()> {
+        if x >= 0 {
+            match self.positive_sign {
+                PositiveSign::None => Ok(()),
+                PositiveSign::Plus => write!(writer, "+"),
+                PositiveSign::Space => write!(writer, " "),
+            }?;
+        }
+
+        let s = format!("{:0width$}", x, width = self.precision);
+
+        match self.alignment {
+            NumberAlignment::Left => write!(writer, "{s:<width$}", width = self.width),
+            NumberAlignment::RightSpace => write!(writer, "{s:>width$}", width = self.width),
+            NumberAlignment::RightZero => write!(writer, "{s:0>width$}", width = self.width),
+        }
+    }
+
+    fn try_from_spec(s: Spec) -> Result<Self, FormatError> {
+        let Spec::SignedInt {
+            width,
+            precision,
+            positive_sign,
+            alignment,
+        } = s
+        else {
+            return Err(FormatError::WrongSpecType);
+        };
+
+        let width = match width {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+        };
+
+        let precision = match precision {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+        };
+
+        Ok(Self {
+            width,
+            precision,
+            positive_sign,
+            alignment,
+        })
+    }
+}
+
+pub struct UnsignedInt {
+    pub variant: UnsignedIntVariant,
+    pub width: usize,
+    pub precision: usize,
+    pub alignment: NumberAlignment,
+}
+
+impl Formatter for UnsignedInt {
+    type Input = u64;
+
+    fn fmt(&self, mut writer: impl Write, x: Self::Input) -> std::io::Result<()> {
+        let mut s = match self.variant {
+            UnsignedIntVariant::Decimal => format!("{x}"),
+            UnsignedIntVariant::Octal(Prefix::No) => format!("{x:o}"),
+            UnsignedIntVariant::Octal(Prefix::Yes) => {
+                // The prefix that rust uses is `0o`, but GNU uses `0`.
+                // We also need to take into account that 0 should not be 00
+                // Since this is an unsigned int, we do not need to take the minus
+                // sign into account.
+                if x == 0 {
+                    format!("{x:o}")
+                } else {
+                    format!("0{x:o}")
+                }
+            }
+            UnsignedIntVariant::Hexadecimal(Case::Lowercase, Prefix::No) => {
+                format!("{x:x}")
+            }
+            UnsignedIntVariant::Hexadecimal(Case::Lowercase, Prefix::Yes) => {
+                if x == 0 {
+                    "0".to_string()
+                } else {
+                    format!("{x:#x}")
+                }
+            }
+            UnsignedIntVariant::Hexadecimal(Case::Uppercase, Prefix::No) => {
+                format!("{x:X}")
+            }
+            UnsignedIntVariant::Hexadecimal(Case::Uppercase, Prefix::Yes) => {
+                if x == 0 {
+                    "0".to_string()
+                } else {
+                    format!("{x:#X}")
+                }
+            }
+        };
+
+        if self.precision > s.len() {
+            s = format!("{:0width$}", s, width = self.precision);
+        }
+
+        match self.alignment {
+            NumberAlignment::Left => write!(writer, "{s:<width$}", width = self.width),
+            NumberAlignment::RightSpace => write!(writer, "{s:>width$}", width = self.width),
+            NumberAlignment::RightZero => write!(writer, "{s:0>width$}", width = self.width),
+        }
+    }
+
+    fn try_from_spec(s: Spec) -> Result<Self, FormatError> {
+        let Spec::UnsignedInt {
+            variant,
+            width,
+            precision,
+            alignment,
+        } = s
+        else {
+            return Err(FormatError::WrongSpecType);
+        };
+
+        let width = match width {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+        };
+
+        let precision = match precision {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+        };
+
+        Ok(Self {
+            width,
+            precision,
+            variant,
+            alignment,
+        })
+    }
+}
+
+pub struct Float {
+    pub variant: FloatVariant,
+    pub case: Case,
+    pub force_decimal: ForceDecimal,
+    pub width: usize,
+    pub positive_sign: PositiveSign,
+    pub alignment: NumberAlignment,
+    pub precision: usize,
+}
+
+impl Default for Float {
+    fn default() -> Self {
+        Self {
+            variant: FloatVariant::Decimal,
+            case: Case::Lowercase,
+            force_decimal: ForceDecimal::No,
+            width: 0,
+            positive_sign: PositiveSign::None,
+            alignment: NumberAlignment::Left,
+            precision: 6,
+        }
+    }
+}
+
+impl Formatter for Float {
+    type Input = f64;
+
+    fn fmt(&self, mut writer: impl Write, x: Self::Input) -> std::io::Result<()> {
+        if x.is_sign_positive() {
+            match self.positive_sign {
+                PositiveSign::None => Ok(()),
+                PositiveSign::Plus => write!(writer, "+"),
+                PositiveSign::Space => write!(writer, " "),
+            }?;
+        }
+
+        let s = if x.is_finite() {
+            match self.variant {
+                FloatVariant::Decimal => {
+                    format_float_decimal(x, self.precision, self.force_decimal)
+                }
+                FloatVariant::Scientific => {
+                    format_float_scientific(x, self.precision, self.case, self.force_decimal)
+                }
+                FloatVariant::Shortest => {
+                    format_float_shortest(x, self.precision, self.case, self.force_decimal)
+                }
+                FloatVariant::Hexadecimal => {
+                    format_float_hexadecimal(x, self.precision, self.case, self.force_decimal)
+                }
+            }
+        } else {
+            format_float_non_finite(x, self.case)
+        };
+
+        match self.alignment {
+            NumberAlignment::Left => write!(writer, "{s:<width$}", width = self.width),
+            NumberAlignment::RightSpace => write!(writer, "{s:>width$}", width = self.width),
+            NumberAlignment::RightZero => write!(writer, "{s:0>width$}", width = self.width),
+        }
+    }
+
+    fn try_from_spec(s: Spec) -> Result<Self, FormatError>
+    where
+        Self: Sized,
+    {
+        let Spec::Float {
+            variant,
+            case,
+            force_decimal,
+            width,
+            positive_sign,
+            alignment,
+            precision,
+        } = s
+        else {
+            return Err(FormatError::WrongSpecType);
+        };
+
+        let width = match width {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+        };
+
+        let precision = match precision {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => {
+                if matches!(variant, FloatVariant::Shortest) {
+                    6
+                } else {
+                    0
+                }
+            }
+            Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+        };
+
+        Ok(Self {
+            variant,
+            case,
+            force_decimal,
+            width,
+            positive_sign,
+            alignment,
+            precision,
+        })
+    }
+}
+
+fn format_float_non_finite(f: f64, case: Case) -> String {
+    debug_assert!(!f.is_finite());
+    let mut s = format!("{f}");
+    if case == Case::Uppercase {
+        s.make_ascii_uppercase();
+    }
+    s
+}
+
+fn format_float_decimal(f: f64, precision: usize, force_decimal: ForceDecimal) -> String {
+    if precision == 0 && force_decimal == ForceDecimal::Yes {
+        format!("{f:.0}.")
+    } else {
+        format!("{f:.*}", precision)
+    }
+}
+
+fn format_float_scientific(
+    f: f64,
+    precision: usize,
+    case: Case,
+    force_decimal: ForceDecimal,
+) -> String {
+    if f == 0.0 {
+        return if force_decimal == ForceDecimal::Yes && precision == 0 {
+            "0.e+00".into()
+        } else {
+            format!("{:.*}e+00", precision, 0.0)
+        };
+    }
+
+    let mut exponent: i32 = f.log10().floor() as i32;
+    let mut normalized = f / 10.0_f64.powi(exponent);
+
+    // If the normalized value will be rounded to a value greater than 10
+    // we need to correct.
+    if (normalized * 10_f64.powi(precision as i32)).round() / 10_f64.powi(precision as i32) >= 10.0
+    {
+        normalized /= 10.0;
+        exponent += 1;
+    }
+
+    let additional_dot = if precision == 0 && ForceDecimal::Yes == force_decimal {
+        "."
+    } else {
+        ""
+    };
+
+    let exp_char = match case {
+        Case::Lowercase => 'e',
+        Case::Uppercase => 'E',
+    };
+
+    format!(
+        "{normalized:.*}{additional_dot}{exp_char}{exponent:+03}",
+        precision
+    )
+}
+
+fn format_float_shortest(
+    f: f64,
+    precision: usize,
+    case: Case,
+    force_decimal: ForceDecimal,
+) -> String {
+    // Precision here is about how many digits should be displayed
+    // instead of how many digits for the fractional part, this means that if
+    // we pass this to rust's format string, it's always gonna be one less.
+    let precision = precision.saturating_sub(1);
+
+    if f == 0.0 {
+        return match (force_decimal, precision) {
+            (ForceDecimal::Yes, 0) => "0.".into(),
+            (ForceDecimal::Yes, _) => {
+                format!("{:.*}", precision, 0.0)
+            }
+            (ForceDecimal::No, _) => "0".into(),
+        };
+    }
+
+    let mut exponent = f.log10().floor() as i32;
+    if f != 0.0 && exponent <= -4 || exponent > precision as i32 {
+        // Scientific-ish notation (with a few differences)
+        let mut normalized = f / 10.0_f64.powi(exponent);
+
+        // If the normalized value will be rounded to a value greater than 10
+        // we need to correct.
+        if (normalized * 10_f64.powi(precision as i32)).round() / 10_f64.powi(precision as i32)
+            >= 10.0
+        {
+            normalized /= 10.0;
+            exponent += 1;
+        }
+
+        let additional_dot = if precision == 0 && ForceDecimal::Yes == force_decimal {
+            "."
+        } else {
+            ""
+        };
+
+        let mut normalized = format!("{normalized:.*}", precision);
+
+        if force_decimal == ForceDecimal::No {
+            strip_fractional_zeroes_and_dot(&mut normalized);
+        }
+
+        let exp_char = match case {
+            Case::Lowercase => 'e',
+            Case::Uppercase => 'E',
+        };
+
+        format!("{normalized}{additional_dot}{exp_char}{exponent:+03}")
+    } else {
+        // Decimal-ish notation with a few differences:
+        //  - The precision works differently and specifies the total number
+        //    of digits instead of the digits in the fractional part.
+        //  - If we don't force the decimal, `.` and trailing `0` in the fractional part
+        //    are trimmed.
+        let decimal_places = (precision as i32 - exponent) as usize;
+        let mut formatted = if decimal_places == 0 && force_decimal == ForceDecimal::Yes {
+            format!("{f:.0}.")
+        } else {
+            format!("{f:.*}", decimal_places)
+        };
+
+        if force_decimal == ForceDecimal::No {
+            strip_fractional_zeroes_and_dot(&mut formatted);
+        }
+
+        formatted
+    }
+}
+
+fn format_float_hexadecimal(
+    f: f64,
+    precision: usize,
+    case: Case,
+    force_decimal: ForceDecimal,
+) -> String {
+    let (first_digit, mantissa, exponent) = if f == 0.0 {
+        (0, 0, 0)
+    } else {
+        let bits = f.to_bits();
+        let exponent_bits = ((bits >> 52) & 0x7fff) as i64;
+        let exponent = exponent_bits - 1023;
+        let mantissa = bits & 0xf_ffff_ffff_ffff;
+        (1, mantissa, exponent)
+    };
+
+    let mut s = match (precision, force_decimal) {
+        (0, ForceDecimal::No) => format!("0x{first_digit}p{exponent:+x}"),
+        (0, ForceDecimal::Yes) => format!("0x{first_digit}.p{exponent:+x}"),
+        _ => format!("0x{first_digit}.{mantissa:0>13x}p{exponent:+x}"),
+    };
+
+    if case == Case::Uppercase {
+        s.make_ascii_uppercase();
+    }
+
+    s
+}
+
+fn strip_fractional_zeroes_and_dot(s: &mut String) {
+    let mut trim_to = s.len();
+    for (pos, c) in s.char_indices().rev() {
+        if pos + c.len_utf8() == trim_to && (c == '0' || c == '.') {
+            trim_to = pos;
+        }
+        if c == '.' {
+            s.truncate(trim_to);
+            break;
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::format::num_format::{Case, ForceDecimal};
+
+    #[test]
+    fn unsigned_octal() {
+        use super::{Formatter, NumberAlignment, Prefix, UnsignedInt, UnsignedIntVariant};
+        let f = |x| {
+            let mut s = Vec::new();
+            UnsignedInt {
+                variant: UnsignedIntVariant::Octal(Prefix::Yes),
+                width: 0,
+                precision: 0,
+                alignment: NumberAlignment::Left,
+            }
+            .fmt(&mut s, x)
+            .unwrap();
+            String::from_utf8(s).unwrap()
+        };
+
+        assert_eq!(f(0), "0");
+        assert_eq!(f(5), "05");
+        assert_eq!(f(8), "010");
+    }
+
+    #[test]
+    fn decimal_float() {
+        use super::format_float_decimal;
+        let f = |x| format_float_decimal(x, 6, ForceDecimal::No);
+        assert_eq!(f(0.0), "0.000000");
+        assert_eq!(f(1.0), "1.000000");
+        assert_eq!(f(100.0), "100.000000");
+        assert_eq!(f(123456.789), "123456.789000");
+        assert_eq!(f(12.3456789), "12.345679");
+        assert_eq!(f(1000000.0), "1000000.000000");
+        assert_eq!(f(99999999.0), "99999999.000000");
+        assert_eq!(f(1.9999995), "1.999999");
+        assert_eq!(f(1.9999996), "2.000000");
+    }
+
+    #[test]
+    fn scientific_float() {
+        use super::format_float_scientific;
+        let f = |x| format_float_scientific(x, 6, Case::Lowercase, ForceDecimal::No);
+        assert_eq!(f(0.0), "0.000000e+00");
+        assert_eq!(f(1.0), "1.000000e+00");
+        assert_eq!(f(100.0), "1.000000e+02");
+        assert_eq!(f(123456.789), "1.234568e+05");
+        assert_eq!(f(12.3456789), "1.234568e+01");
+        assert_eq!(f(1000000.0), "1.000000e+06");
+        assert_eq!(f(99999999.0), "1.000000e+08");
+    }
+
+    #[test]
+    fn scientific_float_zero_precision() {
+        use super::format_float_scientific;
+
+        let f = |x| format_float_scientific(x, 0, Case::Lowercase, ForceDecimal::No);
+        assert_eq!(f(0.0), "0e+00");
+        assert_eq!(f(1.0), "1e+00");
+        assert_eq!(f(100.0), "1e+02");
+        assert_eq!(f(123456.789), "1e+05");
+        assert_eq!(f(12.3456789), "1e+01");
+        assert_eq!(f(1000000.0), "1e+06");
+        assert_eq!(f(99999999.0), "1e+08");
+
+        let f = |x| format_float_scientific(x, 0, Case::Lowercase, ForceDecimal::Yes);
+        assert_eq!(f(0.0), "0.e+00");
+        assert_eq!(f(1.0), "1.e+00");
+        assert_eq!(f(100.0), "1.e+02");
+        assert_eq!(f(123456.789), "1.e+05");
+        assert_eq!(f(12.3456789), "1.e+01");
+        assert_eq!(f(1000000.0), "1.e+06");
+        assert_eq!(f(99999999.0), "1.e+08");
+    }
+
+    #[test]
+    fn shortest_float() {
+        use super::format_float_shortest;
+        let f = |x| format_float_shortest(x, 6, Case::Lowercase, ForceDecimal::No);
+        assert_eq!(f(0.0), "0");
+        assert_eq!(f(1.0), "1");
+        assert_eq!(f(100.0), "100");
+        assert_eq!(f(123456.789), "123457");
+        assert_eq!(f(12.3456789), "12.3457");
+        assert_eq!(f(1000000.0), "1e+06");
+        assert_eq!(f(99999999.0), "1e+08");
+    }
+
+    #[test]
+    fn shortest_float_force_decimal() {
+        use super::format_float_shortest;
+        let f = |x| format_float_shortest(x, 6, Case::Lowercase, ForceDecimal::Yes);
+        assert_eq!(f(0.0), "0.00000");
+        assert_eq!(f(1.0), "1.00000");
+        assert_eq!(f(100.0), "100.000");
+        assert_eq!(f(123456.789), "123457.");
+        assert_eq!(f(12.3456789), "12.3457");
+        assert_eq!(f(1000000.0), "1.00000e+06");
+        assert_eq!(f(99999999.0), "1.00000e+08");
+    }
+
+    #[test]
+    fn shortest_float_force_decimal_zero_precision() {
+        use super::format_float_shortest;
+        let f = |x| format_float_shortest(x, 0, Case::Lowercase, ForceDecimal::No);
+        assert_eq!(f(0.0), "0");
+        assert_eq!(f(1.0), "1");
+        assert_eq!(f(100.0), "1e+02");
+        assert_eq!(f(123456.789), "1e+05");
+        assert_eq!(f(12.3456789), "1e+01");
+        assert_eq!(f(1000000.0), "1e+06");
+        assert_eq!(f(99999999.0), "1e+08");
+
+        let f = |x| format_float_shortest(x, 0, Case::Lowercase, ForceDecimal::Yes);
+        assert_eq!(f(0.0), "0.");
+        assert_eq!(f(1.0), "1.");
+        assert_eq!(f(100.0), "1.e+02");
+        assert_eq!(f(123456.789), "1.e+05");
+        assert_eq!(f(12.3456789), "1.e+01");
+        assert_eq!(f(1000000.0), "1.e+06");
+        assert_eq!(f(99999999.0), "1.e+08");
+    }
+
+    #[test]
+    fn strip_insignificant_end() {
+        use super::strip_fractional_zeroes_and_dot;
+        let f = |s| {
+            let mut s = String::from(s);
+            strip_fractional_zeroes_and_dot(&mut s);
+            s
+        };
+        assert_eq!(&f("1000"), "1000");
+        assert_eq!(&f("1000."), "1000");
+        assert_eq!(&f("1000.02030"), "1000.0203");
+        assert_eq!(&f("1000.00000"), "1000");
+    }
+}
diff --git a/src/uucore/src/lib/features/format/num_parser.rs b/src/uucore/src/lib/features/format/num_parser.rs
new file mode 100644
index 00000000000..0d65651d7e9
--- /dev/null
+++ b/src/uucore/src/lib/features/format/num_parser.rs
@@ -0,0 +1,378 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Utilities for parsing numbers in various formats
+
+// spell-checker:ignore powf copysign prec inity
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum Base {
+    Binary = 2,
+    Octal = 8,
+    Decimal = 10,
+    Hexadecimal = 16,
+}
+
+impl Base {
+    pub fn digit(&self, c: char) -> Option<u64> {
+        fn from_decimal(c: char) -> u64 {
+            u64::from(c) - u64::from('0')
+        }
+        match self {
+            Self::Binary => ('0'..='1').contains(&c).then(|| from_decimal(c)),
+            Self::Octal => ('0'..='7').contains(&c).then(|| from_decimal(c)),
+            Self::Decimal => c.is_ascii_digit().then(|| from_decimal(c)),
+            Self::Hexadecimal => match c.to_ascii_lowercase() {
+                '0'..='9' => Some(from_decimal(c)),
+                c @ 'a'..='f' => Some(u64::from(c) - u64::from('a') + 10),
+                _ => None,
+            },
+        }
+    }
+}
+
+/// Type returned if a number could not be parsed in its entirety
+#[derive(Debug, PartialEq)]
+pub enum ParseError<'a, T> {
+    /// The input as a whole makes no sense
+    NotNumeric,
+    /// The beginning of the input made sense and has been parsed,
+    /// while the remaining doesn't.
+    PartialMatch(T, &'a str),
+    /// The integral part has overflowed the requested type, or
+    /// has overflowed the `u64` internal storage when parsing the
+    /// integral part of a floating point number.
+    Overflow,
+}
+
+impl<'a, T> ParseError<'a, T> {
+    fn map<U>(self, f: impl FnOnce(T, &'a str) -> ParseError<'a, U>) -> ParseError<'a, U> {
+        match self {
+            Self::NotNumeric => ParseError::NotNumeric,
+            Self::Overflow => ParseError::Overflow,
+            Self::PartialMatch(v, s) => f(v, s),
+        }
+    }
+}
+
+/// A number parser for binary, octal, decimal, hexadecimal and single characters.
+///
+/// Internally, in order to get the maximum possible precision and cover the full
+/// range of u64 and i64 without losing precision for f64, the returned number is
+/// decomposed into:
+///   - A `base` value
+///   - A `neg` sign bit
+///   - A `integral` positive part
+///   - A `fractional` positive part
+///   - A `precision` representing the number of digits in the fractional part
+///
+/// If the fractional part cannot be represented on a `u64`, parsing continues
+/// silently by ignoring non-significant digits.
+pub struct ParsedNumber {
+    base: Base,
+    negative: bool,
+    integral: u64,
+    fractional: u64,
+    precision: usize,
+}
+
+impl ParsedNumber {
+    fn into_i64(self) -> Option<i64> {
+        if self.negative {
+            i64::try_from(-i128::from(self.integral)).ok()
+        } else {
+            i64::try_from(self.integral).ok()
+        }
+    }
+
+    /// Parse a number as i64. No fractional part is allowed.
+    pub fn parse_i64(input: &str) -> Result<i64, ParseError<'_, i64>> {
+        match Self::parse(input, true) {
+            Ok(v) => v.into_i64().ok_or(ParseError::Overflow),
+            Err(e) => Err(e.map(|v, rest| {
+                v.into_i64()
+                    .map(|v| ParseError::PartialMatch(v, rest))
+                    .unwrap_or(ParseError::Overflow)
+            })),
+        }
+    }
+
+    /// Parse a number as u64. No fractional part is allowed.
+    pub fn parse_u64(input: &str) -> Result<u64, ParseError<'_, u64>> {
+        match Self::parse(input, true) {
+            Ok(v) | Err(ParseError::PartialMatch(v, _)) if v.negative => {
+                Err(ParseError::NotNumeric)
+            }
+            Ok(v) => Ok(v.integral),
+            Err(e) => Err(e.map(|v, rest| ParseError::PartialMatch(v.integral, rest))),
+        }
+    }
+
+    fn into_f64(self) -> f64 {
+        let n = self.integral as f64
+            + (self.fractional as f64) / (self.base as u8 as f64).powf(self.precision as f64);
+        if self.negative {
+            -n
+        } else {
+            n
+        }
+    }
+
+    /// Parse a number as f64
+    pub fn parse_f64(input: &str) -> Result<f64, ParseError<'_, f64>> {
+        match Self::parse(input, false) {
+            Ok(v) => Ok(v.into_f64()),
+            Err(ParseError::NotNumeric) => Self::parse_f64_special_values(input),
+            Err(e) => Err(e.map(|v, rest| ParseError::PartialMatch(v.into_f64(), rest))),
+        }
+    }
+
+    fn parse_f64_special_values(input: &str) -> Result<f64, ParseError<'_, f64>> {
+        let (sign, rest) = if let Some(input) = input.strip_prefix('-') {
+            (-1.0, input)
+        } else {
+            (1.0, input)
+        };
+        let prefix = rest
+            .chars()
+            .take(3)
+            .map(|c| c.to_ascii_lowercase())
+            .collect::<String>();
+        let special = match prefix.as_str() {
+            "inf" => f64::INFINITY,
+            "nan" => f64::NAN,
+            _ => return Err(ParseError::NotNumeric),
+        }
+        .copysign(sign);
+        if rest.len() == 3 {
+            Ok(special)
+        } else {
+            Err(ParseError::PartialMatch(special, &rest[3..]))
+        }
+    }
+
+    #[allow(clippy::cognitive_complexity)]
+    fn parse(input: &str, integral_only: bool) -> Result<Self, ParseError<'_, Self>> {
+        // Parse the "'" prefix separately
+        if let Some(rest) = input.strip_prefix('\'') {
+            let mut chars = rest.char_indices().fuse();
+            let v = chars.next().map(|(_, c)| Self {
+                base: Base::Decimal,
+                negative: false,
+                integral: u64::from(c),
+                fractional: 0,
+                precision: 0,
+            });
+            return match (v, chars.next()) {
+                (Some(v), None) => Ok(v),
+                (Some(v), Some((i, _))) => Err(ParseError::PartialMatch(v, &rest[i..])),
+                (None, _) => Err(ParseError::NotNumeric),
+            };
+        }
+
+        // Initial minus sign
+        let (negative, unsigned) = if let Some(input) = input.strip_prefix('-') {
+            (true, input)
+        } else {
+            (false, input)
+        };
+
+        // Parse an optional base prefix ("0b" / "0B" / "0" / "0x" / "0X"). "0" is octal unless a
+        // fractional part is allowed in which case it is an insignificant leading 0. A "0" prefix
+        // will not be consumed in case the parsable string contains only "0": the leading extra "0"
+        // will have no influence on the result.
+        let (base, rest) = if let Some(rest) = unsigned.strip_prefix('0') {
+            if let Some(rest) = rest.strip_prefix(['b', 'B']) {
+                (Base::Binary, rest)
+            } else if let Some(rest) = rest.strip_prefix(['x', 'X']) {
+                (Base::Hexadecimal, rest)
+            } else if integral_only {
+                (Base::Octal, unsigned)
+            } else {
+                (Base::Decimal, unsigned)
+            }
+        } else {
+            (Base::Decimal, unsigned)
+        };
+        if rest.is_empty() {
+            return Err(ParseError::NotNumeric);
+        }
+
+        // Parse the integral part of the number
+        let mut chars = rest.chars().enumerate().fuse().peekable();
+        let mut integral = 0u64;
+        while let Some(d) = chars.peek().and_then(|&(_, c)| base.digit(c)) {
+            chars.next();
+            integral = integral
+                .checked_mul(base as u64)
+                .and_then(|n| n.checked_add(d))
+                .ok_or(ParseError::Overflow)?;
+        }
+
+        // Parse the fractional part of the number if there can be one and the input contains
+        // a '.' decimal separator.
+        let (mut fractional, mut precision) = (0u64, 0);
+        if matches!(chars.peek(), Some(&(_, '.')))
+            && matches!(base, Base::Decimal | Base::Hexadecimal)
+            && !integral_only
+        {
+            chars.next();
+            let mut ended = false;
+            while let Some(d) = chars.peek().and_then(|&(_, c)| base.digit(c)) {
+                chars.next();
+                if !ended {
+                    if let Some(f) = fractional
+                        .checked_mul(base as u64)
+                        .and_then(|n| n.checked_add(d))
+                    {
+                        (fractional, precision) = (f, precision + 1);
+                    } else {
+                        ended = true;
+                    }
+                }
+            }
+        }
+
+        // If nothing has been parsed, declare the parsing unsuccessful
+        if let Some((0, _)) = chars.peek() {
+            return Err(ParseError::NotNumeric);
+        }
+
+        // Return what has been parsed so far. It there are extra characters, mark the
+        // parsing as a partial match.
+        let parsed = Self {
+            base,
+            negative,
+            integral,
+            fractional,
+            precision,
+        };
+        if let Some((first_unparsed, _)) = chars.next() {
+            Err(ParseError::PartialMatch(parsed, &rest[first_unparsed..]))
+        } else {
+            Ok(parsed)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{ParseError, ParsedNumber};
+
+    #[test]
+    fn test_decimal_u64() {
+        assert_eq!(Ok(123), ParsedNumber::parse_u64("123"));
+        assert_eq!(
+            Ok(u64::MAX),
+            ParsedNumber::parse_u64(&format!("{}", u64::MAX))
+        );
+        assert!(matches!(
+            ParsedNumber::parse_u64("-123"),
+            Err(ParseError::NotNumeric)
+        ));
+        assert!(matches!(
+            ParsedNumber::parse_u64(""),
+            Err(ParseError::NotNumeric)
+        ));
+        assert!(matches!(
+            ParsedNumber::parse_u64("123.15"),
+            Err(ParseError::PartialMatch(123, ".15"))
+        ));
+    }
+
+    #[test]
+    fn test_decimal_i64() {
+        assert_eq!(Ok(123), ParsedNumber::parse_i64("123"));
+        assert_eq!(Ok(-123), ParsedNumber::parse_i64("-123"));
+        assert!(matches!(
+            ParsedNumber::parse_i64("--123"),
+            Err(ParseError::NotNumeric)
+        ));
+        assert_eq!(
+            Ok(i64::MAX),
+            ParsedNumber::parse_i64(&format!("{}", i64::MAX))
+        );
+        assert_eq!(
+            Ok(i64::MIN),
+            ParsedNumber::parse_i64(&format!("{}", i64::MIN))
+        );
+        assert!(matches!(
+            ParsedNumber::parse_i64(&format!("{}", u64::MAX)),
+            Err(ParseError::Overflow)
+        ));
+        assert!(matches!(
+            ParsedNumber::parse_i64(&format!("{}", i64::MAX as u64 + 1)),
+            Err(ParseError::Overflow)
+        ));
+    }
+
+    #[test]
+    fn test_decimal_f64() {
+        assert_eq!(Ok(123.0), ParsedNumber::parse_f64("123"));
+        assert_eq!(Ok(-123.0), ParsedNumber::parse_f64("-123"));
+        assert_eq!(Ok(123.0), ParsedNumber::parse_f64("123."));
+        assert_eq!(Ok(-123.0), ParsedNumber::parse_f64("-123."));
+        assert_eq!(Ok(123.0), ParsedNumber::parse_f64("123.0"));
+        assert_eq!(Ok(-123.0), ParsedNumber::parse_f64("-123.0"));
+        assert_eq!(Ok(123.15), ParsedNumber::parse_f64("123.15"));
+        assert_eq!(Ok(-123.15), ParsedNumber::parse_f64("-123.15"));
+        assert_eq!(Ok(0.15), ParsedNumber::parse_f64(".15"));
+        assert_eq!(Ok(-0.15), ParsedNumber::parse_f64("-.15"));
+        assert_eq!(
+            Ok(0.15),
+            ParsedNumber::parse_f64(".150000000000000000000000000231313")
+        );
+        assert!(matches!(ParsedNumber::parse_f64("1.2.3"),
+                         Err(ParseError::PartialMatch(f, ".3")) if f == 1.2));
+        assert_eq!(Ok(f64::INFINITY), ParsedNumber::parse_f64("inf"));
+        assert_eq!(Ok(f64::NEG_INFINITY), ParsedNumber::parse_f64("-inf"));
+        assert!(ParsedNumber::parse_f64("NaN").unwrap().is_nan());
+        assert!(ParsedNumber::parse_f64("NaN").unwrap().is_sign_positive());
+        assert!(ParsedNumber::parse_f64("-NaN").unwrap().is_nan());
+        assert!(ParsedNumber::parse_f64("-NaN").unwrap().is_sign_negative());
+        assert!(matches!(ParsedNumber::parse_f64("-infinity"),
+                         Err(ParseError::PartialMatch(f, "inity")) if f == f64::NEG_INFINITY));
+        assert!(ParsedNumber::parse_f64(&format!("{}", u64::MAX)).is_ok());
+        assert!(ParsedNumber::parse_f64(&format!("{}", i64::MIN)).is_ok());
+    }
+
+    #[test]
+    fn test_hexadecimal() {
+        assert_eq!(Ok(0x123), ParsedNumber::parse_u64("0x123"));
+        assert_eq!(Ok(0x123), ParsedNumber::parse_u64("0X123"));
+        assert_eq!(Ok(0xfe), ParsedNumber::parse_u64("0xfE"));
+        assert_eq!(Ok(-0x123), ParsedNumber::parse_i64("-0x123"));
+
+        assert_eq!(Ok(0.5), ParsedNumber::parse_f64("0x.8"));
+        assert_eq!(Ok(0.0625), ParsedNumber::parse_f64("0x.1"));
+        assert_eq!(Ok(15.0078125), ParsedNumber::parse_f64("0xf.02"));
+    }
+
+    #[test]
+    fn test_octal() {
+        assert_eq!(Ok(0), ParsedNumber::parse_u64("0"));
+        assert_eq!(Ok(0o123), ParsedNumber::parse_u64("0123"));
+        assert_eq!(Ok(0o123), ParsedNumber::parse_u64("00123"));
+        assert_eq!(Ok(0), ParsedNumber::parse_u64("00"));
+        assert!(matches!(
+            ParsedNumber::parse_u64("008"),
+            Err(ParseError::PartialMatch(0, "8"))
+        ));
+        assert!(matches!(
+            ParsedNumber::parse_u64("08"),
+            Err(ParseError::PartialMatch(0, "8"))
+        ));
+        assert!(matches!(
+            ParsedNumber::parse_u64("0."),
+            Err(ParseError::PartialMatch(0, "."))
+        ));
+    }
+
+    #[test]
+    fn test_binary() {
+        assert_eq!(Ok(0b1011), ParsedNumber::parse_u64("0b1011"));
+        assert_eq!(Ok(0b1011), ParsedNumber::parse_u64("0B1011"));
+    }
+}
diff --git a/src/uucore/src/lib/features/format/spec.rs b/src/uucore/src/lib/features/format/spec.rs
new file mode 100644
index 00000000000..7c0d0236764
--- /dev/null
+++ b/src/uucore/src/lib/features/format/spec.rs
@@ -0,0 +1,462 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (vars) intmax ptrdiff
+
+use crate::quoting_style::{escape_name, QuotingStyle};
+
+use super::{
+    num_format::{
+        self, Case, FloatVariant, ForceDecimal, Formatter, NumberAlignment, PositiveSign, Prefix,
+        UnsignedIntVariant,
+    },
+    parse_escape_only, ArgumentIter, FormatChar, FormatError,
+};
+use std::{fmt::Display, io::Write, ops::ControlFlow};
+
+/// A parsed specification for formatting a value
+///
+/// This might require more than one argument to resolve width or precision
+/// values that are given as `*`.
+#[derive(Debug)]
+pub enum Spec {
+    Char {
+        width: Option<CanAsterisk<usize>>,
+        align_left: bool,
+    },
+    String {
+        precision: Option<CanAsterisk<usize>>,
+        width: Option<CanAsterisk<usize>>,
+        align_left: bool,
+    },
+    EscapedString,
+    QuotedString,
+    SignedInt {
+        width: Option<CanAsterisk<usize>>,
+        precision: Option<CanAsterisk<usize>>,
+        positive_sign: PositiveSign,
+        alignment: NumberAlignment,
+    },
+    UnsignedInt {
+        variant: UnsignedIntVariant,
+        width: Option<CanAsterisk<usize>>,
+        precision: Option<CanAsterisk<usize>>,
+        alignment: NumberAlignment,
+    },
+    Float {
+        variant: FloatVariant,
+        case: Case,
+        force_decimal: ForceDecimal,
+        width: Option<CanAsterisk<usize>>,
+        positive_sign: PositiveSign,
+        alignment: NumberAlignment,
+        precision: Option<CanAsterisk<usize>>,
+    },
+}
+
+/// Precision and width specified might use an asterisk to indicate that they are
+/// determined by an argument.
+#[derive(Clone, Copy, Debug)]
+pub enum CanAsterisk<T> {
+    Fixed(T),
+    Asterisk,
+}
+
+/// Size of the expected type (ignored)
+///
+/// We ignore this parameter entirely, but we do parse it.
+/// It could be used in the future if the need arises.
+enum Length {
+    /// signed/unsigned char ("hh")
+    Char,
+    /// signed/unsigned short int ("h")
+    Short,
+    /// signed/unsigned long int ("l")
+    Long,
+    /// signed/unsigned long long int ("ll")
+    LongLong,
+    /// intmax_t ("j")
+    IntMaxT,
+    /// size_t ("z")
+    SizeT,
+    /// ptrdiff_t ("t")
+    PtfDiffT,
+    /// long double ("L")
+    LongDouble,
+}
+
+impl Spec {
+    pub fn parse<'a>(rest: &mut &'a [u8]) -> Result<Self, &'a [u8]> {
+        // Based on the C++ reference, the spec format looks like:
+        //
+        //   %[flags][width][.precision][length]specifier
+        //
+        // However, we have already parsed the '%'.
+        let mut index = 0;
+        let start = *rest;
+
+        let mut minus = false;
+        let mut plus = false;
+        let mut space = false;
+        let mut hash = false;
+        let mut zero = false;
+
+        while let Some(x) = rest.get(index) {
+            match x {
+                b'-' => minus = true,
+                b'+' => plus = true,
+                b' ' => space = true,
+                b'#' => hash = true,
+                b'0' => zero = true,
+                _ => break,
+            }
+            index += 1;
+        }
+
+        let alignment = match (minus, zero) {
+            (true, _) => NumberAlignment::Left,
+            (false, true) => NumberAlignment::RightZero,
+            (false, false) => NumberAlignment::RightSpace,
+        };
+
+        let positive_sign = match (plus, space) {
+            (true, _) => PositiveSign::Plus,
+            (false, true) => PositiveSign::Space,
+            (false, false) => PositiveSign::None,
+        };
+
+        let width = eat_asterisk_or_number(rest, &mut index);
+
+        let precision = if let Some(b'.') = rest.get(index) {
+            index += 1;
+            Some(eat_asterisk_or_number(rest, &mut index).unwrap_or(CanAsterisk::Fixed(0)))
+        } else {
+            None
+        };
+
+        // We ignore the length. It's not really relevant to printf
+        let _ = Self::parse_length(rest, &mut index);
+
+        let Some(type_spec) = rest.get(index) else {
+            return Err(&start[..index]);
+        };
+        index += 1;
+        *rest = &start[index..];
+
+        Ok(match type_spec {
+            // GNU accepts minus, plus and space even though they are not used
+            b'c' => {
+                if hash || precision.is_some() {
+                    return Err(&start[..index]);
+                }
+                Self::Char {
+                    width,
+                    align_left: minus,
+                }
+            }
+            b's' => {
+                if hash {
+                    return Err(&start[..index]);
+                }
+                Self::String {
+                    precision,
+                    width,
+                    align_left: minus,
+                }
+            }
+            b'b' => {
+                if hash || minus || plus || space || width.is_some() || precision.is_some() {
+                    return Err(&start[..index]);
+                }
+                Self::EscapedString
+            }
+            b'q' => {
+                if hash || minus || plus || space || width.is_some() || precision.is_some() {
+                    return Err(&start[..index]);
+                }
+                Self::QuotedString
+            }
+            b'd' | b'i' => {
+                if hash {
+                    return Err(&start[..index]);
+                }
+                Self::SignedInt {
+                    width,
+                    precision,
+                    alignment,
+                    positive_sign,
+                }
+            }
+            c @ (b'u' | b'o' | b'x' | b'X') => {
+                // Normal unsigned integer cannot have a prefix
+                if *c == b'u' && hash {
+                    return Err(&start[..index]);
+                }
+                let prefix = match hash {
+                    false => Prefix::No,
+                    true => Prefix::Yes,
+                };
+                let variant = match c {
+                    b'u' => UnsignedIntVariant::Decimal,
+                    b'o' => UnsignedIntVariant::Octal(prefix),
+                    b'x' => UnsignedIntVariant::Hexadecimal(Case::Lowercase, prefix),
+                    b'X' => UnsignedIntVariant::Hexadecimal(Case::Uppercase, prefix),
+                    _ => unreachable!(),
+                };
+                Self::UnsignedInt {
+                    variant,
+                    precision,
+                    width,
+                    alignment,
+                }
+            }
+            c @ (b'f' | b'F' | b'e' | b'E' | b'g' | b'G' | b'a' | b'A') => Self::Float {
+                width,
+                precision,
+                variant: match c {
+                    b'f' | b'F' => FloatVariant::Decimal,
+                    b'e' | b'E' => FloatVariant::Scientific,
+                    b'g' | b'G' => FloatVariant::Shortest,
+                    b'a' | b'A' => FloatVariant::Hexadecimal,
+                    _ => unreachable!(),
+                },
+                force_decimal: match hash {
+                    false => ForceDecimal::No,
+                    true => ForceDecimal::Yes,
+                },
+                case: match c.is_ascii_uppercase() {
+                    false => Case::Lowercase,
+                    true => Case::Uppercase,
+                },
+                alignment,
+                positive_sign,
+            },
+            _ => return Err(&start[..index]),
+        })
+    }
+
+    fn parse_length(rest: &mut &[u8], index: &mut usize) -> Option<Length> {
+        // Parse 0..N length options, keep the last one
+        // Even though it is just ignored. We might want to use it later and we
+        // should parse those characters.
+        //
+        // TODO: This needs to be configurable: `seq` accepts only one length
+        //       param
+        let mut length = None;
+        loop {
+            let new_length = rest.get(*index).and_then(|c| {
+                Some(match c {
+                    b'h' => {
+                        if let Some(b'h') = rest.get(*index + 1) {
+                            *index += 1;
+                            Length::Char
+                        } else {
+                            Length::Short
+                        }
+                    }
+                    b'l' => {
+                        if let Some(b'l') = rest.get(*index + 1) {
+                            *index += 1;
+                            Length::Long
+                        } else {
+                            Length::LongLong
+                        }
+                    }
+                    b'j' => Length::IntMaxT,
+                    b'z' => Length::SizeT,
+                    b't' => Length::PtfDiffT,
+                    b'L' => Length::LongDouble,
+                    _ => return None,
+                })
+            });
+            if new_length.is_some() {
+                *index += 1;
+                length = new_length;
+            } else {
+                break;
+            }
+        }
+        length
+    }
+
+    pub fn write<'a>(
+        &self,
+        mut writer: impl Write,
+        mut args: impl ArgumentIter<'a>,
+    ) -> Result<(), FormatError> {
+        match self {
+            Self::Char { width, align_left } => {
+                let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+                write_padded(writer, args.get_char(), width, false, *align_left)
+            }
+            Self::String {
+                width,
+                align_left,
+                precision,
+            } => {
+                let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+
+                // GNU does do this truncation on a byte level, see for instance:
+                //     printf "%.1s" 🙃
+                //     > �
+                // For now, we let printf panic when we truncate within a code point.
+                // TODO: We need to not use Rust's formatting for aligning the output,
+                // so that we can just write bytes to stdout without panicking.
+                let precision = resolve_asterisk(*precision, &mut args)?;
+                let s = args.get_str();
+                let truncated = match precision {
+                    Some(p) if p < s.len() => &s[..p],
+                    _ => s,
+                };
+                write_padded(writer, truncated, width, false, *align_left)
+            }
+            Self::EscapedString => {
+                let s = args.get_str();
+                let mut parsed = Vec::new();
+                for c in parse_escape_only(s.as_bytes()) {
+                    match c.write(&mut parsed)? {
+                        ControlFlow::Continue(()) => {}
+                        ControlFlow::Break(()) => {
+                            // TODO: This should break the _entire execution_ of printf
+                            break;
+                        }
+                    };
+                }
+                writer.write_all(&parsed).map_err(FormatError::IoError)
+            }
+            Self::QuotedString => {
+                let s = args.get_str();
+                writer
+                    .write_all(
+                        escape_name(
+                            s.as_ref(),
+                            &QuotingStyle::Shell {
+                                escape: true,
+                                always_quote: false,
+                                show_control: false,
+                            },
+                        )
+                        .as_bytes(),
+                    )
+                    .map_err(FormatError::IoError)
+            }
+            Self::SignedInt {
+                width,
+                precision,
+                positive_sign,
+                alignment,
+            } => {
+                let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+                let precision = resolve_asterisk(*precision, &mut args)?.unwrap_or(0);
+                let i = args.get_i64();
+
+                num_format::SignedInt {
+                    width,
+                    precision,
+                    positive_sign: *positive_sign,
+                    alignment: *alignment,
+                }
+                .fmt(writer, i)
+                .map_err(FormatError::IoError)
+            }
+            Self::UnsignedInt {
+                variant,
+                width,
+                precision,
+                alignment,
+            } => {
+                let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+                let precision = resolve_asterisk(*precision, &mut args)?.unwrap_or(0);
+                let i = args.get_u64();
+
+                num_format::UnsignedInt {
+                    variant: *variant,
+                    precision,
+                    width,
+                    alignment: *alignment,
+                }
+                .fmt(writer, i)
+                .map_err(FormatError::IoError)
+            }
+            Self::Float {
+                variant,
+                case,
+                force_decimal,
+                width,
+                positive_sign,
+                alignment,
+                precision,
+            } => {
+                let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+                let precision = resolve_asterisk(*precision, &mut args)?.unwrap_or(6);
+                let f = args.get_f64();
+
+                num_format::Float {
+                    width,
+                    precision,
+                    variant: *variant,
+                    case: *case,
+                    force_decimal: *force_decimal,
+                    positive_sign: *positive_sign,
+                    alignment: *alignment,
+                }
+                .fmt(writer, f)
+                .map_err(FormatError::IoError)
+            }
+        }
+    }
+}
+
+fn resolve_asterisk<'a>(
+    option: Option<CanAsterisk<usize>>,
+    mut args: impl ArgumentIter<'a>,
+) -> Result<Option<usize>, FormatError> {
+    Ok(match option {
+        None => None,
+        Some(CanAsterisk::Asterisk) => Some(usize::try_from(args.get_u64()).ok().unwrap_or(0)),
+        Some(CanAsterisk::Fixed(w)) => Some(w),
+    })
+}
+
+fn write_padded(
+    mut writer: impl Write,
+    text: impl Display,
+    width: usize,
+    pad_zero: bool,
+    left: bool,
+) -> Result<(), FormatError> {
+    match (left, pad_zero) {
+        (false, false) => write!(writer, "{text: >width$}"),
+        (false, true) => write!(writer, "{text:0>width$}"),
+        // 0 is ignored if we pad left.
+        (true, _) => write!(writer, "{text: <width$}"),
+    }
+    .map_err(FormatError::IoError)
+}
+
+fn eat_asterisk_or_number(rest: &mut &[u8], index: &mut usize) -> Option<CanAsterisk<usize>> {
+    if let Some(b'*') = rest.get(*index) {
+        *index += 1;
+        Some(CanAsterisk::Asterisk)
+    } else {
+        eat_number(rest, index).map(CanAsterisk::Fixed)
+    }
+}
+
+fn eat_number(rest: &mut &[u8], index: &mut usize) -> Option<usize> {
+    match rest[*index..].iter().position(|b| !b.is_ascii_digit()) {
+        None | Some(0) => None,
+        Some(i) => {
+            // TODO: This might need to handle errors better
+            // For example in case of overflow.
+            let parsed = std::str::from_utf8(&rest[*index..(*index + i)])
+                .unwrap()
+                .parse()
+                .unwrap();
+            *index += i;
+            Some(parsed)
+        }
+    }
+}
diff --git a/src/uucore/src/lib/features/fs.rs b/src/uucore/src/lib/features/fs.rs
index f8593dfede5..3b9170bc309 100644
--- a/src/uucore/src/lib/features/fs.rs
+++ b/src/uucore/src/lib/features/fs.rs
@@ -115,10 +115,13 @@ impl FileInformation {
             not(target_os = "android"),
             not(target_os = "freebsd"),
             not(target_os = "netbsd"),
+            not(target_os = "openbsd"),
             not(target_os = "illumos"),
             not(target_os = "solaris"),
             not(target_arch = "aarch64"),
             not(target_arch = "riscv64"),
+            not(target_arch = "loongarch64"),
+            not(target_arch = "sparc64"),
             target_pointer_width = "64"
         ))]
         return self.0.st_nlink;
@@ -129,10 +132,13 @@ impl FileInformation {
                 target_os = "android",
                 target_os = "freebsd",
                 target_os = "netbsd",
+                target_os = "openbsd",
                 target_os = "illumos",
                 target_os = "solaris",
                 target_arch = "aarch64",
                 target_arch = "riscv64",
+                target_arch = "loongarch64",
+                target_arch = "sparc64",
                 not(target_pointer_width = "64")
             )
         ))]
@@ -710,6 +716,33 @@ pub fn are_hardlinks_or_one_way_symlink_to_same_file(source: &Path, target: &Pat
     source_metadata.ino() == target_metadata.ino() && source_metadata.dev() == target_metadata.dev()
 }
 
+/// Returns true if the passed `path` ends with a path terminator.
+///
+/// This function examines the last character of the path to determine
+/// if it is a directory separator. It supports both Unix-style (`/`)
+/// and Windows-style (`\`) separators.
+///
+/// # Arguments
+///
+/// * `path` - A reference to the path to be checked.
+#[cfg(unix)]
+pub fn path_ends_with_terminator(path: &Path) -> bool {
+    use std::os::unix::prelude::OsStrExt;
+    path.as_os_str()
+        .as_bytes()
+        .last()
+        .map_or(false, |&byte| byte == b'/' || byte == b'\\')
+}
+
+#[cfg(windows)]
+pub fn path_ends_with_terminator(path: &Path) -> bool {
+    use std::os::windows::prelude::OsStrExt;
+    path.as_os_str()
+        .encode_wide()
+        .last()
+        .map_or(false, |wide| wide == b'/'.into() || wide == b'\\'.into())
+}
+
 #[cfg(test)]
 mod tests {
     // Note this useful idiom: importing names from outer (for mod tests) scope.
@@ -874,7 +907,7 @@ mod tests {
         let path1 = temp_file.path();
         let path2 = temp_file.path();
 
-        assert!(are_hardlinks_to_same_file(&path1, &path2));
+        assert!(are_hardlinks_to_same_file(path1, path2));
     }
 
     #[cfg(unix)]
@@ -889,7 +922,7 @@ mod tests {
         let path1 = temp_file1.path();
         let path2 = temp_file2.path();
 
-        assert!(!are_hardlinks_to_same_file(&path1, &path2));
+        assert!(!are_hardlinks_to_same_file(path1, path2));
     }
 
     #[cfg(unix)]
@@ -900,9 +933,9 @@ mod tests {
         let path1 = temp_file.path();
 
         let path2 = temp_file.path().with_extension("hardlink");
-        fs::hard_link(&path1, &path2).unwrap();
+        fs::hard_link(path1, &path2).unwrap();
 
-        assert!(are_hardlinks_to_same_file(&path1, &path2));
+        assert!(are_hardlinks_to_same_file(path1, &path2));
     }
 
     #[cfg(unix)]
@@ -917,4 +950,24 @@ mod tests {
         assert_eq!(get_file_display(S_IFSOCK | 0o600), 's');
         assert_eq!(get_file_display(0o777), '?');
     }
+
+    #[test]
+    fn test_path_ends_with_terminator() {
+        // Path ends with a forward slash
+        assert!(path_ends_with_terminator(Path::new("/some/path/")));
+
+        // Path ends with a backslash
+        assert!(path_ends_with_terminator(Path::new("C:\\some\\path\\")));
+
+        // Path does not end with a terminator
+        assert!(!path_ends_with_terminator(Path::new("/some/path")));
+        assert!(!path_ends_with_terminator(Path::new("C:\\some\\path")));
+
+        // Empty path
+        assert!(!path_ends_with_terminator(Path::new("")));
+
+        // Root path
+        assert!(path_ends_with_terminator(Path::new("/")));
+        assert!(path_ends_with_terminator(Path::new("C:\\")));
+    }
 }
diff --git a/src/uucore/src/lib/features/fsext.rs b/src/uucore/src/lib/features/fsext.rs
index 8b1c42de6d1..d02d74babbc 100644
--- a/src/uucore/src/lib/features/fsext.rs
+++ b/src/uucore/src/lib/features/fsext.rs
@@ -10,44 +10,41 @@
 use time::macros::format_description;
 use time::UtcOffset;
 
-pub use crate::*; // import macros from `../../macros.rs`
-
 #[cfg(any(target_os = "linux", target_os = "android"))]
 const LINUX_MTAB: &str = "/etc/mtab";
 #[cfg(any(target_os = "linux", target_os = "android"))]
 const LINUX_MOUNTINFO: &str = "/proc/self/mountinfo";
+#[cfg(unix)]
 static MOUNT_OPT_BIND: &str = "bind";
 #[cfg(windows)]
 const MAX_PATH: usize = 266;
-#[cfg(not(unix))]
+#[cfg(windows)]
 static EXIT_ERR: i32 = 1;
 
+#[cfg(any(
+    windows,
+    target_os = "freebsd",
+    target_vendor = "apple",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+use crate::crash;
+#[cfg(windows)]
+use crate::show_warning;
+
 #[cfg(windows)]
 use std::ffi::OsStr;
 #[cfg(windows)]
 use std::os::windows::ffi::OsStrExt;
 #[cfg(windows)]
-use windows_sys::Win32::Foundation::{ERROR_NO_MORE_FILES, INVALID_HANDLE_VALUE};
-#[cfg(windows)]
-use windows_sys::Win32::Storage::FileSystem::{
-    FindFirstVolumeW, FindNextVolumeW, FindVolumeClose, GetDiskFreeSpaceW, GetDriveTypeW,
-    GetVolumeInformationW, GetVolumePathNamesForVolumeNameW, QueryDosDeviceW,
+use windows_sys::Win32::{
+    Foundation::{ERROR_NO_MORE_FILES, INVALID_HANDLE_VALUE},
+    Storage::FileSystem::{
+        FindFirstVolumeW, FindNextVolumeW, FindVolumeClose, GetDiskFreeSpaceW, GetDriveTypeW,
+        GetVolumeInformationW, GetVolumePathNamesForVolumeNameW, QueryDosDeviceW,
+    },
+    System::WindowsProgramming::DRIVE_REMOTE,
 };
-#[cfg(windows)]
-use windows_sys::Win32::System::WindowsProgramming::DRIVE_REMOTE;
-
-// Warning: the pointer has to be used *immediately* or the Vec
-// it points to will be dropped!
-#[cfg(windows)]
-macro_rules! String2LPWSTR {
-    ($str: expr) => {
-        OsStr::new(&$str)
-            .encode_wide()
-            .chain(Some(0))
-            .collect::<Vec<u16>>()
-            .as_ptr()
-    };
-}
 
 #[cfg(windows)]
 #[allow(non_snake_case)]
@@ -56,29 +53,28 @@ fn LPWSTR2String(buf: &[u16]) -> String {
     String::from_utf16(&buf[..len]).unwrap()
 }
 
+#[cfg(windows)]
+fn to_nul_terminated_wide_string(s: impl AsRef<OsStr>) -> Vec<u16> {
+    s.as_ref()
+        .encode_wide()
+        .chain(Some(0))
+        .collect::<Vec<u16>>()
+}
+
 #[cfg(unix)]
 use libc::{
     mode_t, strerror, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK,
 };
 use std::borrow::Cow;
-use std::convert::{AsRef, From};
-#[cfg(any(
-    target_vendor = "apple",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "linux",
-    target_os = "android",
-    target_os = "illumos",
-    target_os = "solaris",
-))]
+use std::convert::From;
+#[cfg(unix)]
 use std::ffi::CStr;
-#[cfg(not(windows))]
+#[cfg(unix)]
 use std::ffi::CString;
 use std::io::Error as IOError;
 #[cfg(unix)]
 use std::mem;
-#[cfg(not(unix))]
+#[cfg(windows)]
 use std::path::Path;
 use std::time::UNIX_EPOCH;
 
@@ -106,7 +102,6 @@ pub use libc::statvfs as StatFs;
     target_vendor = "apple",
     target_os = "freebsd",
     target_os = "openbsd",
-    target_os = "redox"
 ))]
 pub use libc::statfs as statfs_fn;
 #[cfg(any(
@@ -114,7 +109,8 @@ pub use libc::statfs as statfs_fn;
     target_os = "bitrig",
     target_os = "illumos",
     target_os = "solaris",
-    target_os = "dragonfly"
+    target_os = "dragonfly",
+    target_os = "redox"
 ))]
 pub use libc::statvfs as statfs_fn;
 
@@ -144,63 +140,27 @@ impl BirthTime for Metadata {
 
 #[derive(Debug, Clone)]
 pub struct MountInfo {
-    // it stores `volume_name` in windows platform and `dev_id` in unix platform
+    /// Stores `volume_name` in windows platform and `dev_id` in unix platform
     pub dev_id: String,
     pub dev_name: String,
     pub fs_type: String,
-    pub mount_dir: String,
-    pub mount_option: String, // we only care "bind" option
     pub mount_root: String,
+    pub mount_dir: String,
+    /// We only care whether this field contains "bind"
+    pub mount_option: String,
     pub remote: bool,
     pub dummy: bool,
 }
 
 impl MountInfo {
-    fn set_missing_fields(&mut self) {
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::MetadataExt;
-            // We want to keep the dev_id on Windows
-            // but set dev_id
-            if let Ok(stat) = std::fs::metadata(&self.mount_dir) {
-                // Why do we cast this to i32?
-                self.dev_id = (stat.dev() as i32).to_string();
-            } else {
-                self.dev_id = String::new();
-            }
-        }
-        // set MountInfo::dummy
-        // spell-checker:disable
-        match self.fs_type.as_ref() {
-            "autofs" | "proc" | "subfs"
-            /* for Linux 2.6/3.x */
-            | "debugfs" | "devpts" | "fusectl" | "mqueue" | "rpc_pipefs" | "sysfs"
-            /* FreeBSD, Linux 2.4 */
-            | "devfs"
-            /* for NetBSD 3.0 */
-            | "kernfs"
-            /* for Irix 6.5 */
-            | "ignore" => self.dummy = true,
-            _ => self.dummy = self.fs_type == "none"
-                && !self.mount_option.contains(MOUNT_OPT_BIND)
-        }
-        // spell-checker:enable
-        // set MountInfo::remote
-        #[cfg(windows)]
-        {
-            self.remote = DRIVE_REMOTE == unsafe { GetDriveTypeW(String2LPWSTR!(self.mount_root)) };
-        }
-        #[cfg(unix)]
-        {
-            self.remote = self.dev_name.find(':').is_some()
-                || (self.dev_name.starts_with("//") && self.fs_type == "smbfs"
-                    || self.fs_type == "cifs")
-                || self.dev_name == "-hosts";
-        }
-    }
-
     #[cfg(any(target_os = "linux", target_os = "android"))]
     fn new(file_name: &str, raw: &[&str]) -> Option<Self> {
+        let dev_name;
+        let fs_type;
+        let mount_root;
+        let mount_dir;
+        let mount_option;
+
         match file_name {
             // spell-checker:ignore (word) noatime
             // Format: 36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue
@@ -210,36 +170,38 @@ impl MountInfo {
                 let after_fields = raw[FIELDS_OFFSET..].iter().position(|c| *c == "-").unwrap()
                     + FIELDS_OFFSET
                     + 1;
-                let mut m = Self {
-                    dev_id: String::new(),
-                    dev_name: raw[after_fields + 1].to_string(),
-                    fs_type: raw[after_fields].to_string(),
-                    mount_root: raw[3].to_string(),
-                    mount_dir: raw[4].to_string(),
-                    mount_option: raw[5].to_string(),
-                    remote: false,
-                    dummy: false,
-                };
-                m.set_missing_fields();
-                Some(m)
+                dev_name = raw[after_fields + 1].to_string();
+                fs_type = raw[after_fields].to_string();
+                mount_root = raw[3].to_string();
+                mount_dir = raw[4].to_string();
+                mount_option = raw[5].to_string();
             }
             LINUX_MTAB => {
-                let mut m = Self {
-                    dev_id: String::new(),
-                    dev_name: raw[0].to_string(),
-                    fs_type: raw[2].to_string(),
-                    mount_root: String::new(),
-                    mount_dir: raw[1].to_string(),
-                    mount_option: raw[3].to_string(),
-                    remote: false,
-                    dummy: false,
-                };
-                m.set_missing_fields();
-                Some(m)
+                dev_name = raw[0].to_string();
+                fs_type = raw[2].to_string();
+                mount_root = String::new();
+                mount_dir = raw[1].to_string();
+                mount_option = raw[3].to_string();
             }
-            _ => None,
-        }
+            _ => return None,
+        };
+
+        let dev_id = mount_dev_id(&mount_dir);
+        let dummy = is_dummy_filesystem(&fs_type, &mount_option);
+        let remote = is_remote_filesystem(&dev_name, &fs_type);
+
+        Some(Self {
+            dev_id,
+            dev_name,
+            fs_type,
+            mount_dir,
+            mount_option,
+            mount_root,
+            remote,
+            dummy,
+        })
     }
+
     #[cfg(windows)]
     fn new(mut volume_name: String) -> Option<Self> {
         let mut dev_name_buf = [0u16; MAX_PATH];
@@ -261,8 +223,9 @@ impl MountInfo {
 
         let mut mount_root_buf = [0u16; MAX_PATH];
         let success = unsafe {
+            let volume_name = to_nul_terminated_wide_string(&volume_name);
             GetVolumePathNamesForVolumeNameW(
-                String2LPWSTR!(volume_name),
+                volume_name.as_ptr(),
                 mount_root_buf.as_mut_ptr(),
                 mount_root_buf.len() as u32,
                 ptr::null_mut(),
@@ -276,8 +239,9 @@ impl MountInfo {
 
         let mut fs_type_buf = [0u16; MAX_PATH];
         let success = unsafe {
+            let mount_root = to_nul_terminated_wide_string(&mount_root);
             GetVolumeInformationW(
-                String2LPWSTR!(mount_root),
+                mount_root.as_ptr(),
                 ptr::null_mut(),
                 0,
                 ptr::null_mut(),
@@ -292,18 +256,21 @@ impl MountInfo {
         } else {
             Some(LPWSTR2String(&fs_type_buf))
         };
-        let mut mn_info = Self {
+        let remote = DRIVE_REMOTE
+            == unsafe {
+                let mount_root = to_nul_terminated_wide_string(&mount_root);
+                GetDriveTypeW(mount_root.as_ptr())
+            };
+        Some(Self {
             dev_id: volume_name,
             dev_name,
             fs_type: fs_type.unwrap_or_default(),
             mount_root,
             mount_dir: String::new(),
             mount_option: String::new(),
-            remote: false,
+            remote,
             dummy: false,
-        };
-        mn_info.set_missing_fields();
-        Some(mn_info)
+        })
     }
 }
 
@@ -315,33 +282,77 @@ impl MountInfo {
 ))]
 impl From<StatFs> for MountInfo {
     fn from(statfs: StatFs) -> Self {
-        let mut info = Self {
-            dev_id: String::new(),
-            dev_name: unsafe {
-                // spell-checker:disable-next-line
-                CStr::from_ptr(&statfs.f_mntfromname[0])
-                    .to_string_lossy()
-                    .into_owned()
-            },
-            fs_type: unsafe {
-                // spell-checker:disable-next-line
-                CStr::from_ptr(&statfs.f_fstypename[0])
-                    .to_string_lossy()
-                    .into_owned()
-            },
-            mount_dir: unsafe {
-                // spell-checker:disable-next-line
-                CStr::from_ptr(&statfs.f_mntonname[0])
-                    .to_string_lossy()
-                    .into_owned()
-            },
+        let dev_name = unsafe {
+            // spell-checker:disable-next-line
+            CStr::from_ptr(&statfs.f_mntfromname[0])
+                .to_string_lossy()
+                .into_owned()
+        };
+        let fs_type = unsafe {
+            // spell-checker:disable-next-line
+            CStr::from_ptr(&statfs.f_fstypename[0])
+                .to_string_lossy()
+                .into_owned()
+        };
+        let mount_dir = unsafe {
+            // spell-checker:disable-next-line
+            CStr::from_ptr(&statfs.f_mntonname[0])
+                .to_string_lossy()
+                .into_owned()
+        };
+
+        let dev_id = mount_dev_id(&mount_dir);
+        let dummy = is_dummy_filesystem(&fs_type, "");
+        let remote = is_remote_filesystem(&dev_name, &fs_type);
+
+        Self {
+            dev_id,
+            dev_name,
+            fs_type,
+            mount_dir,
             mount_root: String::new(),
             mount_option: String::new(),
-            remote: false,
-            dummy: false,
-        };
-        info.set_missing_fields();
-        info
+            remote,
+            dummy,
+        }
+    }
+}
+
+#[cfg(unix)]
+fn is_dummy_filesystem(fs_type: &str, mount_option: &str) -> bool {
+    // spell-checker:disable
+    match fs_type {
+        "autofs" | "proc" | "subfs"
+        // for Linux 2.6/3.x
+        | "debugfs" | "devpts" | "fusectl" | "mqueue" | "rpc_pipefs" | "sysfs"
+        // FreeBSD, Linux 2.4
+        | "devfs"
+        // for NetBSD 3.0
+        | "kernfs"
+        // for Irix 6.5
+        | "ignore" => true,
+        _ => fs_type == "none"
+            && !mount_option.contains(MOUNT_OPT_BIND)
+    }
+    // spell-checker:enable
+}
+
+#[cfg(unix)]
+fn is_remote_filesystem(dev_name: &str, fs_type: &str) -> bool {
+    dev_name.find(':').is_some()
+        || (dev_name.starts_with("//") && fs_type == "smbfs" || fs_type == "cifs")
+        || dev_name == "-hosts"
+}
+
+#[cfg(unix)]
+fn mount_dev_id(mount_dir: &str) -> String {
+    use std::os::unix::fs::MetadataExt;
+
+    if let Ok(stat) = std::fs::metadata(mount_dir) {
+        // Why do we cast this to i32?
+        (stat.dev() as i32).to_string()
+    } else {
+        String::new()
     }
 }
 
@@ -497,7 +508,10 @@ impl FsUsage {
     #[cfg(unix)]
     pub fn new(statvfs: StatFs) -> Self {
         {
-            #[cfg(all(not(target_os = "freebsd"), target_pointer_width = "64"))]
+            #[cfg(all(
+                not(any(target_os = "freebsd", target_os = "openbsd")),
+                target_pointer_width = "64"
+            ))]
             return Self {
                 blocksize: statvfs.f_bsize as u64, // or `statvfs.f_frsize` ?
                 blocks: statvfs.f_blocks,
@@ -507,7 +521,10 @@ impl FsUsage {
                 files: statvfs.f_files,
                 ffree: statvfs.f_ffree,
             };
-            #[cfg(all(not(target_os = "freebsd"), not(target_pointer_width = "64")))]
+            #[cfg(all(
+                not(any(target_os = "freebsd", target_os = "openbsd")),
+                not(target_pointer_width = "64")
+            ))]
             return Self {
                 blocksize: statvfs.f_bsize as u64, // or `statvfs.f_frsize` ?
                 blocks: statvfs.f_blocks.into(),
@@ -530,15 +547,29 @@ impl FsUsage {
                 files: statvfs.f_files,
                 ffree: statvfs.f_ffree.try_into().unwrap(),
             };
+            #[cfg(target_os = "openbsd")]
+            return Self {
+                blocksize: statvfs.f_bsize.into(),
+                blocks: statvfs.f_blocks,
+                bfree: statvfs.f_bfree,
+                bavail: statvfs.f_bavail.try_into().unwrap(),
+                bavail_top_bit_set: ((std::convert::TryInto::<u64>::try_into(statvfs.f_bavail)
+                    .unwrap())
+                    & (1u64.rotate_right(1)))
+                    != 0,
+                files: statvfs.f_files,
+                ffree: statvfs.f_ffree,
+            };
         }
     }
-    #[cfg(not(unix))]
+    #[cfg(windows)]
     pub fn new(path: &Path) -> Self {
         let mut root_path = [0u16; MAX_PATH];
         let success = unsafe {
+            let path = to_nul_terminated_wide_string(path);
             GetVolumePathNamesForVolumeNameW(
                 //path_utf8.as_ptr(),
-                String2LPWSTR!(path.as_os_str()),
+                path.as_ptr(),
                 root_path.as_mut_ptr(),
                 root_path.len() as u32,
                 ptr::null_mut(),
@@ -558,8 +589,9 @@ impl FsUsage {
         let mut total_number_of_clusters = 0;
 
         let success = unsafe {
+            let path = to_nul_terminated_wide_string(path);
             GetDiskFreeSpaceW(
-                String2LPWSTR!(path.as_os_str()),
+                path.as_ptr(),
                 &mut sectors_per_cluster,
                 &mut bytes_per_sector,
                 &mut number_of_free_clusters,
@@ -617,8 +649,10 @@ impl FsMeta for StatFs {
             not(target_vendor = "apple"),
             not(target_os = "android"),
             not(target_os = "freebsd"),
+            not(target_os = "openbsd"),
             not(target_os = "illumos"),
             not(target_os = "solaris"),
+            not(target_os = "redox"),
             not(target_arch = "s390x"),
             target_pointer_width = "64"
         ))]
@@ -626,10 +660,12 @@ impl FsMeta for StatFs {
         #[cfg(all(
             not(target_env = "musl"),
             not(target_os = "freebsd"),
+            not(target_os = "redox"),
             any(
                 target_arch = "s390x",
                 target_vendor = "apple",
                 target_os = "android",
+                target_os = "openbsd",
                 not(target_pointer_width = "64")
             )
         ))]
@@ -638,7 +674,8 @@ impl FsMeta for StatFs {
             target_env = "musl",
             target_os = "freebsd",
             target_os = "illumos",
-            target_os = "solaris"
+            target_os = "solaris",
+            target_os = "redox"
         ))]
         return self.f_bsize.try_into().unwrap();
     }
@@ -655,11 +692,19 @@ impl FsMeta for StatFs {
         return self.f_bfree.into();
     }
     fn avail_blocks(&self) -> u64 {
-        #[cfg(all(not(target_os = "freebsd"), target_pointer_width = "64"))]
+        #[cfg(all(
+            not(target_os = "freebsd"),
+            not(target_os = "openbsd"),
+            target_pointer_width = "64"
+        ))]
         return self.f_bavail;
-        #[cfg(all(not(target_os = "freebsd"), not(target_pointer_width = "64")))]
+        #[cfg(all(
+            not(target_os = "freebsd"),
+            not(target_os = "openbsd"),
+            not(target_pointer_width = "64")
+        ))]
         return self.f_bavail.into();
-        #[cfg(target_os = "freebsd")]
+        #[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
         return self.f_bavail.try_into().unwrap();
     }
     fn total_file_nodes(&self) -> u64 {
@@ -846,6 +891,7 @@ pub fn pretty_time(sec: i64, nsec: i64) -> String {
     // the date was set
     let local_offset = match UtcOffset::local_offset_at(tm) {
         Ok(lo) => lo,
+        Err(_) if cfg!(target_os = "redox") => UtcOffset::UTC,
         Err(e) => {
             panic!("error: {e}");
         }
diff --git a/src/uucore/src/lib/features/fsxattr.rs b/src/uucore/src/lib/features/fsxattr.rs
new file mode 100644
index 00000000000..3cb00edc0cb
--- /dev/null
+++ b/src/uucore/src/lib/features/fsxattr.rs
@@ -0,0 +1,154 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore getxattr
+
+//! Set of functions to manage xattr on files and dirs
+use std::collections::HashMap;
+use std::ffi::OsString;
+use std::path::Path;
+
+/// Copies extended attributes (xattrs) from one file or directory to another.
+///
+/// # Arguments
+///
+/// * `source` - A reference to the source path.
+/// * `dest` - A reference to the destination path.
+///
+/// # Returns
+///
+/// A result indicating success or failure.
+pub fn copy_xattrs<P: AsRef<Path>>(source: P, dest: P) -> std::io::Result<()> {
+    for attr_name in xattr::list(&source)? {
+        if let Some(value) = xattr::get(&source, &attr_name)? {
+            xattr::set(&dest, &attr_name, &value)?;
+        }
+    }
+    Ok(())
+}
+
+/// Retrieves the extended attributes (xattrs) of a given file or directory.
+///
+/// # Arguments
+///
+/// * `source` - A reference to the path of the file or directory.
+///
+/// # Returns
+///
+/// A result containing a HashMap of attributes names and values, or an error.
+pub fn retrieve_xattrs<P: AsRef<Path>>(source: P) -> std::io::Result<HashMap<OsString, Vec<u8>>> {
+    let mut attrs = HashMap::new();
+    for attr_name in xattr::list(&source)? {
+        if let Some(value) = xattr::get(&source, &attr_name)? {
+            attrs.insert(attr_name, value);
+        }
+    }
+    Ok(attrs)
+}
+
+/// Applies extended attributes (xattrs) to a given file or directory.
+///
+/// # Arguments
+///
+/// * `dest` - A reference to the path of the file or directory.
+/// * `xattrs` - A HashMap containing attribute names and their corresponding values.
+///
+/// # Returns
+///
+/// A result indicating success or failure.
+pub fn apply_xattrs<P: AsRef<Path>>(
+    dest: P,
+    xattrs: HashMap<OsString, Vec<u8>>,
+) -> std::io::Result<()> {
+    for (attr, value) in xattrs {
+        xattr::set(&dest, &attr, &value)?;
+    }
+    Ok(())
+}
+
+/// Checks if a file has an Access Control List (ACL) based on its extended attributes.
+///
+/// # Arguments
+///
+/// * `file` - A reference to the path of the file.
+///
+/// # Returns
+///
+/// `true` if the file has extended attributes (indicating an ACL), `false` otherwise.
+pub fn has_acl<P: AsRef<Path>>(file: P) -> bool {
+    // don't use exacl here, it is doing more getxattr call then needed
+    match xattr::list(file) {
+        Ok(acl) => {
+            // if we have extra attributes, we have an acl
+            acl.count() > 0
+        }
+        Err(_) => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::File;
+    use tempfile::tempdir;
+
+    #[test]
+    fn test_copy_xattrs() {
+        let temp_dir = tempdir().unwrap();
+        let source_path = temp_dir.path().join("source.txt");
+        let dest_path = temp_dir.path().join("dest.txt");
+
+        File::create(&source_path).unwrap();
+        File::create(&dest_path).unwrap();
+
+        let test_attr = "user.test";
+        let test_value = b"test value";
+        xattr::set(&source_path, test_attr, test_value).unwrap();
+
+        copy_xattrs(&source_path, &dest_path).unwrap();
+
+        let copied_value = xattr::get(&dest_path, test_attr).unwrap().unwrap();
+        assert_eq!(copied_value, test_value);
+    }
+
+    #[test]
+    fn test_apply_and_retrieve_xattrs() {
+        let temp_dir = tempdir().unwrap();
+        let file_path = temp_dir.path().join("test_file.txt");
+
+        File::create(&file_path).unwrap();
+
+        let mut test_xattrs = HashMap::new();
+        let test_attr = "user.test_attr";
+        let test_value = b"test value";
+        test_xattrs.insert(OsString::from(test_attr), test_value.to_vec());
+        apply_xattrs(&file_path, test_xattrs).unwrap();
+
+        let retrieved_xattrs = retrieve_xattrs(&file_path).unwrap();
+        assert!(retrieved_xattrs.contains_key(OsString::from(test_attr).as_os_str()));
+        assert_eq!(
+            retrieved_xattrs
+                .get(OsString::from(test_attr).as_os_str())
+                .unwrap(),
+            test_value
+        );
+    }
+
+    #[test]
+    fn test_file_has_acl() {
+        let temp_dir = tempdir().unwrap();
+        let file_path = temp_dir.path().join("test_file.txt");
+
+        File::create(&file_path).unwrap();
+
+        assert!(!has_acl(&file_path));
+
+        let test_attr = "user.test_acl";
+        let test_value = b"test value";
+        xattr::set(&file_path, test_attr, test_value).unwrap();
+
+        assert!(has_acl(&file_path));
+    }
+}
diff --git a/src/uucore/src/lib/features/memo.rs b/src/uucore/src/lib/features/memo.rs
deleted file mode 100644
index 0603b01c51c..00000000000
--- a/src/uucore/src/lib/features/memo.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-//! Main entry point for our implementation of printf.
-//!
-//! The [`printf`] and [`sprintf`] closely match the behavior of the
-//! corresponding C functions: the former renders a formatted string
-//! to stdout, the latter renders to a new [`String`] object.
-use crate::display::Quotable;
-use crate::error::{UResult, USimpleError};
-use crate::features::tokenize::sub::SubParser;
-use crate::features::tokenize::token::Token;
-use crate::features::tokenize::unescaped_text::UnescapedText;
-use crate::show_warning;
-use itertools::put_back_n;
-use std::io::{stdout, Cursor, Write};
-use std::iter::Peekable;
-use std::slice::Iter;
-
-/// Memo runner of printf
-/// Takes a format string and arguments
-/// 1. tokenize format string into tokens, consuming
-/// any subst. arguments along the way.
-/// 2. feeds remaining arguments into function
-/// that prints tokens.
-struct Memo {
-    tokens: Vec<Token>,
-}
-
-fn warn_excess_args(first_arg: &str) {
-    show_warning!(
-        "ignoring excess arguments, starting with {}",
-        first_arg.quote()
-    );
-}
-
-impl Memo {
-    fn new<W>(
-        writer: &mut W,
-        pf_string: &str,
-        pf_args_it: &mut Peekable<Iter<String>>,
-    ) -> UResult<Self>
-    where
-        W: Write,
-    {
-        let mut pm = Self { tokens: Vec::new() };
-        let mut it = put_back_n(pf_string.chars());
-        let mut has_sub = false;
-        loop {
-            if let Some(x) = UnescapedText::from_it_core(writer, &mut it, false) {
-                pm.tokens.push(x);
-            }
-            if let Some(x) = SubParser::from_it(writer, &mut it, pf_args_it)? {
-                if !has_sub {
-                    has_sub = true;
-                }
-                pm.tokens.push(x);
-            }
-            if let Some(x) = it.next() {
-                it.put_back(x);
-            } else {
-                break;
-            }
-        }
-        if !has_sub {
-            let mut drain = false;
-            if let Some(first_arg) = pf_args_it.peek() {
-                warn_excess_args(first_arg);
-                drain = true;
-            }
-            if drain {
-                loop {
-                    // drain remaining args;
-                    if pf_args_it.next().is_none() {
-                        break;
-                    }
-                }
-            }
-        }
-        Ok(pm)
-    }
-    fn apply<W>(&self, writer: &mut W, pf_args_it: &mut Peekable<Iter<String>>)
-    where
-        W: Write,
-    {
-        for tkn in &self.tokens {
-            tkn.write(writer, pf_args_it);
-        }
-    }
-    fn run_all<W>(writer: &mut W, pf_string: &str, pf_args: &[String]) -> UResult<()>
-    where
-        W: Write,
-    {
-        let mut arg_it = pf_args.iter().peekable();
-        let pm = Self::new(writer, pf_string, &mut arg_it)?;
-        loop {
-            if arg_it.peek().is_none() {
-                return Ok(());
-            }
-            pm.apply(writer, &mut arg_it);
-        }
-    }
-}
-
-/// Write a formatted string to stdout.
-///
-/// `format_string` contains the template and `args` contains the
-/// arguments to render into the template.
-///
-/// See also [`sprintf`], which creates a new formatted [`String`].
-///
-/// # Examples
-///
-/// ```rust
-/// use uucore::memo::printf;
-///
-/// printf("hello %s", &["world".to_string()]).unwrap();
-/// // prints "hello world"
-/// ```
-pub fn printf(format_string: &str, args: &[String]) -> UResult<()> {
-    let mut writer = stdout();
-    Memo::run_all(&mut writer, format_string, args)
-}
-
-/// Create a new formatted string.
-///
-/// `format_string` contains the template and `args` contains the
-/// arguments to render into the template.
-///
-/// See also [`printf`], which prints to stdout.
-///
-/// # Examples
-///
-/// ```rust
-/// use uucore::memo::sprintf;
-///
-/// let s = sprintf("hello %s", &["world".to_string()]).unwrap();
-/// assert_eq!(s, "hello world".to_string());
-/// ```
-pub fn sprintf(format_string: &str, args: &[String]) -> UResult<String> {
-    let mut writer = Cursor::new(vec![]);
-    Memo::run_all(&mut writer, format_string, args)?;
-    let buf = writer.into_inner();
-    match String::from_utf8(buf) {
-        Ok(s) => Ok(s),
-        Err(e) => Err(USimpleError::new(
-            1,
-            format!("failed to parse formatted string as UTF-8: {e}"),
-        )),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::memo::sprintf;
-
-    #[test]
-    fn test_sprintf_smoke() {
-        assert_eq!(sprintf("", &[]).unwrap(), "".to_string());
-    }
-
-    #[test]
-    fn test_sprintf_no_args() {
-        assert_eq!(
-            sprintf("hello world", &[]).unwrap(),
-            "hello world".to_string()
-        );
-    }
-
-    #[test]
-    fn test_sprintf_string() {
-        assert_eq!(
-            sprintf("hello %s", &["world".to_string()]).unwrap(),
-            "hello world".to_string()
-        );
-    }
-}
diff --git a/src/uucore/src/lib/features/mode.rs b/src/uucore/src/lib/features/mode.rs
index 147624891bd..c2da380bf0f 100644
--- a/src/uucore/src/lib/features/mode.rs
+++ b/src/uucore/src/lib/features/mode.rs
@@ -137,6 +137,7 @@ fn parse_change(mode: &str, fperm: u32, considering_dir: bool) -> (u32, usize) {
     (srwx, pos)
 }
 
+#[allow(clippy::unnecessary_cast)]
 pub fn parse_mode(mode: &str) -> Result<mode_t, String> {
     #[cfg(all(
         not(target_os = "freebsd"),
@@ -148,9 +149,9 @@ pub fn parse_mode(mode: &str) -> Result<mode_t, String> {
     let fperm = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) as u32;
 
     let result = if mode.chars().any(|c| c.is_ascii_digit()) {
-        parse_numeric(fperm, mode, true)
+        parse_numeric(fperm as u32, mode, true)
     } else {
-        parse_symbolic(fperm, mode, get_umask(), true)
+        parse_symbolic(fperm as u32, mode, get_umask(), true)
     };
     result.map(|mode| mode as mode_t)
 }
@@ -168,11 +169,17 @@ pub fn get_umask() -> u32 {
     #[cfg(all(
         not(target_os = "freebsd"),
         not(target_vendor = "apple"),
-        not(target_os = "android")
+        not(target_os = "android"),
+        not(target_os = "redox")
     ))]
     return mask;
-    #[cfg(any(target_os = "freebsd", target_vendor = "apple", target_os = "android"))]
-    return mask.into();
+    #[cfg(any(
+        target_os = "freebsd",
+        target_vendor = "apple",
+        target_os = "android",
+        target_os = "redox"
+    ))]
+    return mask as u32;
 }
 
 // Iterate 'args' and delete the first occurrence
diff --git a/src/uucore/src/lib/features/signals.rs b/src/uucore/src/lib/features/signals.rs
index 2e8c26a4598..0c3f968d975 100644
--- a/src/uucore/src/lib/features/signals.rs
+++ b/src/uucore/src/lib/features/signals.rs
@@ -3,7 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (vars/api) fcntl setrlimit setitimer rubout pollable occured sysconf
+// spell-checker:ignore (vars/api) fcntl setrlimit setitimer rubout pollable sysconf
 // spell-checker:ignore (vars/signals) ABRT ALRM CHLD SEGV SIGABRT SIGALRM SIGBUS SIGCHLD SIGCONT SIGEMT SIGFPE SIGHUP SIGILL SIGINFO SIGINT SIGIO SIGIOT SIGKILL SIGPIPE SIGPROF SIGPWR SIGQUIT SIGSEGV SIGSTOP SIGSYS SIGTERM SIGTRAP SIGTSTP SIGTHR SIGTTIN SIGTTOU SIGURG SIGUSR SIGVTALRM SIGWINCH SIGXCPU SIGXFSZ STKFLT PWR THR TSTP TTIN TTOU VTALRM XCPU XFSZ SIGCLD SIGPOLL SIGWAITING SIGAIOCANCEL SIGLWP SIGFREEZE SIGTHAW SIGCANCEL SIGLOST SIGXRES SIGJVM SIGRTMIN SIGRT SIGRTMAX AIOCANCEL XRES RTMIN RTMAX
 #[cfg(unix)]
 use nix::errno::Errno;
@@ -27,7 +27,7 @@ Linux Programmer's Manual
 
 */
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "redox"))]
 pub static ALL_SIGNALS: [&str; 32] = [
     "EXIT", "HUP", "INT", "QUIT", "ILL", "TRAP", "ABRT", "BUS", "FPE", "KILL", "USR1", "SEGV",
     "USR2", "PIPE", "ALRM", "TERM", "STKFLT", "CHLD", "CONT", "STOP", "TSTP", "TTIN", "TTOU",
@@ -207,7 +207,7 @@ pub static ALL_SIGNALS: [&str; 33] = [
      SIGPWR       19      power-fail restart
      SIGWINCH     20      window size change
      SIGURG       21      urgent socket condition
-     SIGPOLL      22      pollable event occured
+     SIGPOLL      22      pollable event occurred
      SIGIO        SIGPOLL socket I/O possible (SIGPOLL alias)
      SIGSTOP      23      stop (cannot be caught or ignored)
      SIGTSTP      24      user stop requested from tty
diff --git a/src/uucore/src/lib/features/sum.rs b/src/uucore/src/lib/features/sum.rs
index e079d7a30e3..3a8bb55d59b 100644
--- a/src/uucore/src/lib/features/sum.rs
+++ b/src/uucore/src/lib/features/sum.rs
@@ -484,22 +484,23 @@ mod tests {
     fn test_crlf_across_blocks() {
         use std::io::Write;
 
-        use crate::digest::Digest;
-        use crate::digest::DigestWriter;
+        use super::Digest;
+        use super::DigestWriter;
+        use super::Md5;
 
         // Writing "\r" in one call to `write()`, and then "\n" in another.
-        let mut digest = Box::new(md5::Md5::new()) as Box<dyn Digest>;
+        let mut digest = Box::new(Md5::new()) as Box<dyn Digest>;
         let mut writer_crlf = DigestWriter::new(&mut digest, false);
         writer_crlf.write_all(&[b'\r']).unwrap();
         writer_crlf.write_all(&[b'\n']).unwrap();
-        writer_crlf.hash_finalize();
+        writer_crlf.finalize();
         let result_crlf = digest.result_str();
 
         // We expect "\r\n" to be replaced with "\n" in text mode on Windows.
-        let mut digest = Box::new(md5::Md5::new()) as Box<dyn Digest>;
+        let mut digest = Box::new(Md5::new()) as Box<dyn Digest>;
         let mut writer_lf = DigestWriter::new(&mut digest, false);
         writer_lf.write_all(&[b'\n']).unwrap();
-        writer_lf.hash_finalize();
+        writer_lf.finalize();
         let result_lf = digest.result_str();
 
         assert_eq!(result_crlf, result_lf);
diff --git a/src/uucore/src/lib/features/tokenize/mod.rs b/src/uucore/src/lib/features/tokenize/mod.rs
deleted file mode 100644
index 49611bbca5e..00000000000
--- a/src/uucore/src/lib/features/tokenize/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-#[allow(clippy::module_inception)]
-mod num_format;
-pub mod sub;
-pub mod token;
-pub mod unescaped_text;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/format_field.rs b/src/uucore/src/lib/features/tokenize/num_format/format_field.rs
deleted file mode 100644
index bd57b0ecdaf..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/format_field.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-//! Primitives used by Sub Tokenizer
-//! and num_format modules
-#[derive(Clone)]
-pub enum FieldType {
-    Strf,
-    Floatf,
-    CninetyNineHexFloatf,
-    Scif,
-    Decf,
-    Intf,
-    Charf,
-}
-
-// a Sub Tokens' fields are stored
-// as a single object so they can be more simply
-// passed by ref to num_format in a Sub method
-#[derive(Clone)]
-pub struct FormatField<'a> {
-    pub min_width: Option<isize>,
-    pub second_field: Option<u32>,
-    pub field_char: &'a char,
-    pub field_type: &'a FieldType,
-    pub orig: &'a String,
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatter.rs b/src/uucore/src/lib/features/tokenize/num_format/formatter.rs
deleted file mode 100644
index 2a3fd1013eb..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatter.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-//! Primitives used by num_format and sub_modules.
-//! never dealt with above (e.g. Sub Tokenizer never uses these)
-
-use crate::{display::Quotable, show_error};
-use itertools::{put_back_n, PutBackN};
-use std::str::Chars;
-
-use super::format_field::FormatField;
-
-// contains the rough ingredients to final
-// output for a number, organized together
-// to allow for easy generalization of output manipulation
-// (e.g. max number of digits after decimal)
-#[derive(Default)]
-pub struct FormatPrimitive {
-    pub prefix: Option<String>,
-    pub pre_decimal: Option<String>,
-    pub post_decimal: Option<String>,
-    pub suffix: Option<String>,
-}
-
-#[derive(Clone, PartialEq, Eq)]
-pub enum Base {
-    Ten = 10,
-    Hex = 16,
-    Octal = 8,
-}
-
-// information from the beginning of a numeric argument
-// the precedes the beginning of a numeric value
-pub struct InitialPrefix {
-    pub radix_in: Base,
-    pub sign: i8,
-    pub offset: usize,
-}
-
-pub trait Formatter {
-    //  return a FormatPrimitive for
-    // particular field char(s), given the argument
-    // string and prefix information (sign, radix)
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        in_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive>;
-    // return a string from a FormatPrimitive,
-    // given information about the field
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String;
-}
-pub fn get_it_at(offset: usize, str_in: &str) -> PutBackN<Chars> {
-    put_back_n(str_in[offset..].chars())
-}
-
-// TODO: put this somewhere better
-pub fn warn_incomplete_conv(pf_arg: &str) {
-    // important: keep println here not print
-    show_error!("{}: value not completely converted", pf_arg.maybe_quote());
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs
deleted file mode 100644
index 7c041fec8c0..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) arrnum arr_num mult basenum bufferval refd vals arrfloat conv intermed addl
-
-pub fn arrnum_int_mult(arr_num: &[u8], basenum: u8, base_ten_int_fact: u8) -> Vec<u8> {
-    let mut carry: u16 = 0;
-    let mut rem: u16;
-    let mut new_amount: u16;
-    let fact: u16 = u16::from(base_ten_int_fact);
-    let base: u16 = u16::from(basenum);
-
-    let mut ret_rev: Vec<u8> = Vec::new();
-    let mut it = arr_num.iter().rev();
-    loop {
-        let i = it.next();
-        match i {
-            Some(u) => {
-                new_amount = (u16::from(*u) * fact) + carry;
-                rem = new_amount % base;
-                carry = (new_amount - rem) / base;
-                ret_rev.push(rem as u8);
-            }
-            None => {
-                while carry != 0 {
-                    rem = carry % base;
-                    carry = (carry - rem) / base;
-                    ret_rev.push(rem as u8);
-                }
-                break;
-            }
-        }
-    }
-    let ret: Vec<u8> = ret_rev.into_iter().rev().collect();
-    ret
-}
-
-#[allow(dead_code)]
-pub struct Remainder<'a> {
-    pub position: usize,
-    pub replace: Vec<u8>,
-    pub arr_num: &'a Vec<u8>,
-}
-
-#[allow(dead_code)]
-pub struct DivOut<'a> {
-    pub quotient: u8,
-    pub remainder: Remainder<'a>,
-}
-
-#[allow(dead_code)]
-pub fn arrnum_int_div_step<'a>(
-    rem_in: &'a Remainder,
-    radix_in: u8,
-    base_ten_int_divisor: u8,
-    after_decimal: bool,
-) -> DivOut<'a> {
-    let mut rem_out = Remainder {
-        position: rem_in.position,
-        replace: Vec::new(),
-        arr_num: rem_in.arr_num,
-    };
-
-    let mut bufferval: u16 = 0;
-    let base: u16 = u16::from(radix_in);
-    let divisor: u16 = u16::from(base_ten_int_divisor);
-    let mut traversed = 0;
-
-    let mut quotient = 0;
-    let refd_vals = &rem_in.arr_num[rem_in.position + rem_in.replace.len()..];
-    let mut it_replace = rem_in.replace.iter();
-    let mut it_f = refd_vals.iter();
-    loop {
-        let u = match it_replace.next() {
-            Some(u_rep) => u16::from(*u_rep),
-            None => match it_f.next() {
-                Some(u_orig) => u16::from(*u_orig),
-                None => {
-                    if !after_decimal {
-                        break;
-                    }
-                    0
-                }
-            },
-        };
-        traversed += 1;
-        bufferval += u;
-        if bufferval > divisor {
-            while bufferval >= divisor {
-                quotient += 1;
-                bufferval -= divisor;
-            }
-            rem_out.replace = if bufferval == 0 {
-                Vec::new()
-            } else {
-                let remainder_as_arrnum = unsigned_to_arrnum(bufferval);
-                base_conv_vec(&remainder_as_arrnum, 10, radix_in)
-            };
-            rem_out.position += 1 + (traversed - rem_out.replace.len());
-            break;
-        } else {
-            bufferval *= base;
-        }
-    }
-    DivOut {
-        quotient,
-        remainder: rem_out,
-    }
-}
-pub fn arrnum_int_add(arrnum: &[u8], basenum: u8, base_ten_int_term: u8) -> Vec<u8> {
-    let mut carry: u16 = u16::from(base_ten_int_term);
-    let mut rem: u16;
-    let mut new_amount: u16;
-    let base: u16 = u16::from(basenum);
-
-    let mut ret_rev: Vec<u8> = Vec::new();
-    let mut it = arrnum.iter().rev();
-    loop {
-        let i = it.next();
-        match i {
-            Some(u) => {
-                new_amount = u16::from(*u) + carry;
-                rem = new_amount % base;
-                carry = (new_amount - rem) / base;
-                ret_rev.push(rem as u8);
-            }
-            None => {
-                while carry != 0 {
-                    rem = carry % base;
-                    carry = (carry - rem) / base;
-                    ret_rev.push(rem as u8);
-                }
-                break;
-            }
-        }
-    }
-    let ret: Vec<u8> = ret_rev.into_iter().rev().collect();
-    ret
-}
-
-pub fn base_conv_vec(src: &[u8], radix_src: u8, radix_dest: u8) -> Vec<u8> {
-    let mut result = vec![0];
-    for i in src {
-        result = arrnum_int_mult(&result, radix_dest, radix_src);
-        result = arrnum_int_add(&result, radix_dest, *i);
-    }
-    result
-}
-
-#[allow(dead_code)]
-pub fn unsigned_to_arrnum(src: u16) -> Vec<u8> {
-    let mut result: Vec<u8> = Vec::new();
-    let mut src_tmp: u16 = src;
-    while src_tmp > 0 {
-        result.push((src_tmp % 10) as u8);
-        src_tmp /= 10;
-    }
-    result.reverse();
-    result
-}
-
-// temporary needs-improvement-function
-pub fn base_conv_float(src: &[u8], radix_src: u8, _radix_dest: u8) -> f64 {
-    // it would require a lot of addl code
-    // to implement this for arbitrary string input.
-    // until then, the below operates as an outline
-    // of how it would work.
-    let mut factor: f64 = 1_f64;
-    let radix_src_float: f64 = f64::from(radix_src);
-    let mut r: f64 = 0_f64;
-    for (i, u) in src.iter().enumerate() {
-        if i > 15 {
-            break;
-        }
-        factor /= radix_src_float;
-        r += factor * f64::from(*u);
-    }
-    r
-}
-
-pub fn str_to_arrnum(src: &str, radix_def_src: &dyn RadixDef) -> Vec<u8> {
-    let mut intermed_in: Vec<u8> = Vec::new();
-    for c in src.chars() {
-        #[allow(clippy::single_match)]
-        match radix_def_src.parse_char(c) {
-            Some(u) => {
-                intermed_in.push(u);
-            }
-            None => {} //todo err msg on incorrect
-        }
-    }
-    intermed_in
-}
-
-pub fn arrnum_to_str(src: &[u8], radix_def_dest: &dyn RadixDef) -> String {
-    let mut str_out = String::new();
-    for u in src {
-        #[allow(clippy::single_match)]
-        match radix_def_dest.format_u8(*u) {
-            Some(c) => {
-                str_out.push(c);
-            }
-            None => {} //todo
-        }
-    }
-    str_out
-}
-
-pub fn base_conv_str(
-    src: &str,
-    radix_def_src: &dyn RadixDef,
-    radix_def_dest: &dyn RadixDef,
-) -> String {
-    let intermed_in: Vec<u8> = str_to_arrnum(src, radix_def_src);
-    let intermed_out = base_conv_vec(
-        &intermed_in,
-        radix_def_src.get_max(),
-        radix_def_dest.get_max(),
-    );
-    arrnum_to_str(&intermed_out, radix_def_dest)
-}
-
-pub trait RadixDef {
-    fn get_max(&self) -> u8;
-    fn parse_char(&self, x: char) -> Option<u8>;
-    fn format_u8(&self, x: u8) -> Option<char>;
-}
-pub struct RadixTen;
-
-const ZERO_ASC: u8 = b'0';
-const UPPER_A_ASC: u8 = b'A';
-const LOWER_A_ASC: u8 = b'a';
-
-impl RadixDef for RadixTen {
-    fn get_max(&self) -> u8 {
-        10
-    }
-    fn parse_char(&self, c: char) -> Option<u8> {
-        match c {
-            '0'..='9' => Some(c as u8 - ZERO_ASC),
-            _ => None,
-        }
-    }
-    fn format_u8(&self, u: u8) -> Option<char> {
-        match u {
-            0..=9 => Some((ZERO_ASC + u) as char),
-            _ => None,
-        }
-    }
-}
-pub struct RadixHex;
-impl RadixDef for RadixHex {
-    fn get_max(&self) -> u8 {
-        16
-    }
-    fn parse_char(&self, c: char) -> Option<u8> {
-        match c {
-            '0'..='9' => Some(c as u8 - ZERO_ASC),
-            'A'..='F' => Some(c as u8 + 10 - UPPER_A_ASC),
-            'a'..='f' => Some(c as u8 + 10 - LOWER_A_ASC),
-            _ => None,
-        }
-    }
-    fn format_u8(&self, u: u8) -> Option<char> {
-        match u {
-            0..=9 => Some((ZERO_ASC + u) as char),
-            10..=15 => Some((UPPER_A_ASC + (u - 10)) as char),
-            _ => None,
-        }
-    }
-}
-
-mod tests;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs
deleted file mode 100644
index bf3747e1881..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) arrnum mult
-
-#[cfg(test)]
-use super::*;
-
-#[test]
-fn test_arrnum_int_mult() {
-    // (in base 10) 12 * 4 = 48
-    let factor: Vec<u8> = vec![1, 2];
-    let base_num = 10;
-    let base_ten_int_fact: u8 = 4;
-    let should_output: Vec<u8> = vec![4, 8];
-
-    let product = arrnum_int_mult(&factor, base_num, base_ten_int_fact);
-    assert!(product == should_output);
-}
-
-#[test]
-fn test_arrnum_int_non_base_10() {
-    // (in base 3)
-    // 5 * 4 = 20
-    let factor: Vec<u8> = vec![1, 2];
-    let base_num = 3;
-    let base_ten_int_fact: u8 = 4;
-    let should_output: Vec<u8> = vec![2, 0, 2];
-
-    let product = arrnum_int_mult(&factor, base_num, base_ten_int_fact);
-    assert!(product == should_output);
-}
-
-#[test]
-fn test_arrnum_int_div_short_circuit() {
-    // (
-    let arrnum: Vec<u8> = vec![5, 5, 5, 5, 0];
-    let base_num = 10;
-    let base_ten_int_divisor: u8 = 41;
-    let remainder_passed_in = Remainder {
-        position: 1,
-        replace: vec![1, 3],
-        arr_num: &arrnum,
-    };
-
-    // the "replace" should mean the number being divided
-    // is 1350, the first time you can get 41 to go into
-    // 1350, its at 135, where you can get a quotient of
-    // 3 and a remainder of 12;
-
-    let quotient_should_be: u8 = 3;
-    let remainder_position_should_be: usize = 3;
-    let remainder_replace_should_be = vec![1, 2];
-
-    let result = arrnum_int_div_step(&remainder_passed_in, base_num, base_ten_int_divisor, false);
-    assert!(quotient_should_be == result.quotient);
-    assert!(remainder_position_should_be == result.remainder.position);
-    assert!(remainder_replace_should_be == result.remainder.replace);
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs
deleted file mode 100644
index 91a854f261e..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-//! formatter for %a %F C99 Hex-floating-point subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::base_conv;
-use super::base_conv::RadixDef;
-use super::float_common::{primitive_to_str_common, FloatAnalysis};
-
-#[derive(Default)]
-pub struct CninetyNineHexFloatf {
-    #[allow(dead_code)]
-    as_num: f64,
-}
-impl CninetyNineHexFloatf {
-    pub fn new() -> Self {
-        Self::default()
-    }
-}
-
-impl Formatter for CninetyNineHexFloatf {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let second_field = field.second_field.unwrap_or(6) + 1;
-        let analysis = FloatAnalysis::analyze(
-            str_in,
-            initial_prefix,
-            Some(second_field as usize),
-            None,
-            true,
-        );
-        let f = get_primitive_hex(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            *field.field_char == 'A',
-        );
-        Some(f)
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        primitive_to_str_common(prim, &field)
-    }
-}
-
-// c99 hex has unique requirements of all floating point subs in pretty much every part of building a primitive, from prefix and suffix to need for base conversion (in all other cases if you don't have decimal you must have decimal, here it's the other way around)
-
-// on the todo list is to have a trait for get_primitive that is implemented by each float formatter and can override a default. when that happens we can take the parts of get_primitive_dec specific to dec and spin them out to their own functions that can be overridden.
-fn get_primitive_hex(
-    initial_prefix: &InitialPrefix,
-    _str_in: &str,
-    _analysis: &FloatAnalysis,
-    _last_dec_place: usize,
-    capitalized: bool,
-) -> FormatPrimitive {
-    let prefix = Some(String::from(if initial_prefix.sign == -1 {
-        "-0x"
-    } else {
-        "0x"
-    }));
-
-    // TODO actual conversion, make sure to get back mantissa.
-    // for hex to hex, it's really just a matter of moving the
-    // decimal point and calculating the mantissa by its initial
-    // position and its moves, with every position counting for
-    // the addition or subtraction of 4 (2**4, because 4 bits in a hex digit)
-    // to the exponent.
-    // decimal's going to be a little more complicated. correct simulation
-    // of glibc will require after-decimal division to a specified precision.
-    // the difficult part of this (arrnum_int_div_step) is already implemented.
-
-    // the hex float name may be a bit misleading in terms of how to go about the
-    // conversion. The best way to do it is to just convert the float number
-    // directly to base 2 and then at the end translate back to hex.
-    let mantissa = 0;
-    let suffix = Some({
-        let ind = if capitalized { "P" } else { "p" };
-        if mantissa >= 0 {
-            format!("{ind}+{mantissa}")
-        } else {
-            format!("{ind}{mantissa}")
-        }
-    });
-    FormatPrimitive {
-        prefix,
-        suffix,
-        ..Default::default()
-    }
-}
-
-#[allow(dead_code)]
-fn to_hex(src: &str, before_decimal: bool) -> String {
-    let radix_ten = base_conv::RadixTen;
-    let radix_hex = base_conv::RadixHex;
-    if before_decimal {
-        base_conv::base_conv_str(src, &radix_ten, &radix_hex)
-    } else {
-        let as_arrnum_ten = base_conv::str_to_arrnum(src, &radix_ten);
-        let s = format!(
-            "{}",
-            base_conv::base_conv_float(&as_arrnum_ten, radix_ten.get_max(), radix_hex.get_max())
-        );
-        if s.len() > 2 {
-            String::from(&s[2..])
-        } else {
-            // zero
-            s
-        }
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs
deleted file mode 100644
index 35b981b4fba..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-//! formatter for %g %G decimal subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::float_common::{get_primitive_dec, primitive_to_str_common, FloatAnalysis};
-
-const SIGNIFICANT_FIGURES: usize = 6;
-
-// Parse a numeric string as the nearest integer with a given significance.
-// This is a helper function for round().
-// Examples:
-//  round_to_significance("456", 1) == 500
-//  round_to_significance("456", 2) == 460
-//  round_to_significance("456", 9) == 456
-fn round_to_significance(input: &str, significant_figures: usize) -> u32 {
-    if significant_figures < input.len() {
-        // If the input has too many digits, use a float intermediary
-        // to round it before converting to an integer. Otherwise,
-        // converting straight to integer will truncate.
-        // There might be a cleaner way to do this...
-        let digits = &input[..significant_figures + 1];
-        let float_representation = digits.parse::<f32>().unwrap();
-        (float_representation / 10.0).round() as u32
-    } else {
-        input.parse::<u32>().unwrap_or(0)
-    }
-}
-
-// Removing trailing zeroes, expressing the result as an integer where
-// possible. This is a helper function for round().
-fn truncate(mut format: FormatPrimitive) -> FormatPrimitive {
-    if let Some(ref post_dec) = format.post_decimal {
-        let trimmed = post_dec.trim_end_matches('0');
-
-        if trimmed.is_empty() {
-            // If there are no nonzero digits after the decimal point,
-            // use integer formatting by clearing post_decimal and suffix.
-            format.post_decimal = Some(String::new());
-            if format.suffix == Some("e+00".into()) {
-                format.suffix = Some(String::new());
-            }
-        } else if trimmed.len() != post_dec.len() {
-            // Otherwise, update the format to remove only the trailing
-            // zeroes (e.g. "4.50" becomes "4.5", not "4"). If there were
-            // no trailing zeroes, do nothing.
-            format.post_decimal = Some(trimmed.to_owned());
-        }
-    }
-    format
-}
-
-// Round a format to six significant figures and remove trailing zeroes.
-fn round(mut format: FormatPrimitive) -> FormatPrimitive {
-    let mut significant_digits_remaining = SIGNIFICANT_FIGURES;
-
-    // First, take as many significant digits as possible from pre_decimal,
-    if format.pre_decimal.is_some() {
-        let input = format.pre_decimal.as_ref().unwrap();
-        let rounded = round_to_significance(input, significant_digits_remaining);
-        let mut rounded_str = rounded.to_string();
-        significant_digits_remaining -= rounded_str.len();
-
-        // If the pre_decimal has exactly enough significant digits,
-        // round the input to the nearest integer. If the first
-        // post_decimal digit is 5 or higher, round up by incrementing
-        // the pre_decimal number. Otherwise, use the pre_decimal as-is.
-        if significant_digits_remaining == 0 {
-            if let Some(digits) = &format.post_decimal {
-                if digits.chars().next().unwrap_or('0') >= '5' {
-                    let rounded = rounded + 1;
-                    rounded_str = rounded.to_string();
-                }
-            }
-        }
-        format.pre_decimal = Some(rounded_str);
-    }
-
-    // If no significant digits remain, or there's no post_decimal to
-    // round, return the rounded pre_decimal value with no post_decimal.
-    // Otherwise, round the post_decimal to the remaining significance.
-    if significant_digits_remaining == 0 {
-        format.post_decimal = Some(String::new());
-    } else if let Some(input) = format.post_decimal {
-        let leading_zeroes = input.len() - input.trim_start_matches('0').len();
-        let digits = &input[leading_zeroes..];
-
-        // In the post_decimal, leading zeroes are significant. "01.0010"
-        // has one significant digit in pre_decimal, and 3 from post_decimal.
-        let mut post_decimal_str = String::with_capacity(significant_digits_remaining);
-        for _ in 0..leading_zeroes {
-            post_decimal_str.push('0');
-        }
-
-        if leading_zeroes < significant_digits_remaining {
-            // After significant leading zeroes, round the remaining digits
-            // to any remaining significance.
-            let rounded = round_to_significance(digits, significant_digits_remaining);
-            post_decimal_str.push_str(&rounded.to_string());
-        } else if leading_zeroes == significant_digits_remaining
-            && digits.chars().next().unwrap_or('0') >= '5'
-        {
-            // If necessary, round up the post_decimal ("1.000009" should
-            // round to 1.00001, instead of truncating after the last
-            // significant leading zero).
-            post_decimal_str.pop();
-            post_decimal_str.push('1');
-        } else {
-            // If the rounded post_decimal is entirely zeroes, discard
-            // it and use integer formatting instead.
-            post_decimal_str = String::new();
-        }
-
-        format.post_decimal = Some(post_decimal_str);
-    }
-    truncate(format)
-}
-
-// Given an exponent used in scientific notation, return whether the
-// number is small enough to be expressed as a decimal instead. "Small
-// enough" is based only on the number's magnitude, not the length of
-// any string representation.
-fn should_represent_as_decimal(suffix: &Option<String>) -> bool {
-    match suffix {
-        Some(exponent) => {
-            if exponent.chars().nth(1) == Some('-') {
-                exponent < &"e-05".into()
-            } else {
-                exponent < &"e+06".into()
-            }
-        }
-        None => true,
-    }
-}
-
-pub struct Decf;
-
-impl Decf {
-    pub fn new() -> Self {
-        Self
-    }
-}
-impl Formatter for Decf {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let second_field = field.second_field.unwrap_or(6) + 1;
-        // default to scif interpretation so as to not truncate input vals
-        // (that would be displayed in scif) based on relation to decimal place
-        let analysis = FloatAnalysis::analyze(
-            str_in,
-            initial_prefix,
-            Some(second_field as usize + 1),
-            None,
-            false,
-        );
-        let mut f_dec = get_primitive_dec(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            Some(*field.field_char == 'G'),
-        );
-
-        if should_represent_as_decimal(&f_dec.suffix) {
-            // Use decimal formatting instead of scientific notation
-            // if the input's magnitude is small.
-            f_dec = get_primitive_dec(
-                initial_prefix,
-                &str_in[initial_prefix.offset..],
-                &analysis,
-                second_field as usize,
-                None,
-            );
-        }
-
-        Some(round(f_dec))
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        primitive_to_str_common(prim, &field)
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
deleted file mode 100644
index 1cf25b32f1e..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
+++ /dev/null
@@ -1,381 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-use super::super::format_field::FormatField;
-use super::super::formatter::{
-    get_it_at, warn_incomplete_conv, Base, FormatPrimitive, InitialPrefix,
-};
-use super::base_conv;
-use super::base_conv::RadixDef;
-
-// if the memory, copy, and comparison cost of chars
-//  becomes an issue, we can always operate in vec<u8> here
-//  rather than just at de_hex
-
-pub struct FloatAnalysis {
-    pub len_important: usize,
-    // none means no decimal point.
-    pub decimal_pos: Option<usize>,
-    pub follow: Option<char>,
-}
-fn has_enough_digits(
-    hex_input: bool,
-    hex_output: bool,
-    string_position: usize,
-    starting_position: usize,
-    limit: usize,
-) -> bool {
-    // -1s are for rounding
-    if hex_output {
-        if hex_input {
-            (string_position - 1) - starting_position >= limit
-        } else {
-            false //undecidable without converting
-        }
-    } else if hex_input {
-        (((string_position - 1) - starting_position) * 9) / 8 >= limit
-    } else {
-        (string_position - 1) - starting_position >= limit
-    }
-}
-
-impl FloatAnalysis {
-    #[allow(clippy::cognitive_complexity)]
-    pub fn analyze(
-        str_in: &str,
-        initial_prefix: &InitialPrefix,
-        max_sd_opt: Option<usize>,
-        max_after_dec_opt: Option<usize>,
-        hex_output: bool,
-    ) -> Self {
-        // this fn assumes
-        // the input string
-        // has no leading spaces or 0s
-        let str_it = get_it_at(initial_prefix.offset, str_in);
-        let mut ret = Self {
-            len_important: 0,
-            decimal_pos: None,
-            follow: None,
-        };
-        let hex_input = match initial_prefix.radix_in {
-            Base::Hex => true,
-            Base::Ten => false,
-            Base::Octal => {
-                panic!("this should never happen: floats should never receive octal input");
-            }
-        };
-        let mut i = 0;
-        let mut pos_before_first_nonzero_after_decimal: Option<usize> = None;
-        for c in str_it {
-            match c {
-                e @ ('0'..='9' | 'A'..='F' | 'a'..='f') => {
-                    if !hex_input {
-                        match e {
-                            '0'..='9' => {}
-                            _ => {
-                                warn_incomplete_conv(str_in);
-                                break;
-                            }
-                        }
-                    }
-                    if ret.decimal_pos.is_some()
-                        && pos_before_first_nonzero_after_decimal.is_none()
-                        && e != '0'
-                    {
-                        pos_before_first_nonzero_after_decimal = Some(i - 1);
-                    }
-                    if let Some(max_sd) = max_sd_opt {
-                        if i == max_sd {
-                            // follow is used in cases of %g
-                            // where the character right after the last
-                            // sd is considered is rounded affecting
-                            // the previous digit in 1/2 of instances
-                            ret.follow = Some(e);
-                        } else if ret.decimal_pos.is_some() && i > max_sd {
-                            break;
-                        }
-                    }
-                    if let Some(max_after_dec) = max_after_dec_opt {
-                        if let Some(p) = ret.decimal_pos {
-                            if has_enough_digits(hex_input, hex_output, i, p, max_after_dec) {
-                                break;
-                            }
-                        }
-                    } else if let Some(max_sd) = max_sd_opt {
-                        if let Some(p) = pos_before_first_nonzero_after_decimal {
-                            if has_enough_digits(hex_input, hex_output, i, p, max_sd) {
-                                break;
-                            }
-                        }
-                    }
-                }
-                '.' => {
-                    if ret.decimal_pos.is_none() {
-                        ret.decimal_pos = Some(i);
-                    } else {
-                        warn_incomplete_conv(str_in);
-                        break;
-                    }
-                }
-                _ => {
-                    warn_incomplete_conv(str_in);
-                    break;
-                }
-            };
-            i += 1;
-        }
-        ret.len_important = i;
-        ret
-    }
-}
-
-fn de_hex(src: &str, before_decimal: bool) -> String {
-    let radix_ten = base_conv::RadixTen;
-    let radix_hex = base_conv::RadixHex;
-    if before_decimal {
-        base_conv::base_conv_str(src, &radix_hex, &radix_ten)
-    } else {
-        let as_arrnum_hex = base_conv::str_to_arrnum(src, &radix_hex);
-        let s = format!(
-            "{}",
-            base_conv::base_conv_float(&as_arrnum_hex, radix_hex.get_max(), radix_ten.get_max())
-        );
-        if s.len() > 2 {
-            String::from(&s[2..])
-        } else {
-            // zero
-            s
-        }
-    }
-}
-
-// takes a string in,
-// truncates to a position,
-// bumps the last digit up one,
-// and if the digit was nine
-// propagate to the next, etc.
-// If before the decimal and the most
-// significant digit is a 9, it becomes a 1
-fn _round_str_from(in_str: &str, position: usize, before_dec: bool) -> (String, bool) {
-    let mut it = in_str[0..position].chars();
-    let mut rev = String::new();
-    let mut i = position;
-    let mut finished_in_dec = false;
-    while let Some(c) = it.next_back() {
-        i -= 1;
-        match c {
-            '9' => {
-                // If we're before the decimal
-                // and on the most significant digit,
-                // round 9 to 1, else to 0.
-                if before_dec && i == 0 {
-                    rev.push('1');
-                } else {
-                    rev.push('0');
-                }
-            }
-            e => {
-                rev.push(((e as u8) + 1) as char);
-                finished_in_dec = true;
-                break;
-            }
-        }
-    }
-    let mut fwd = String::from(&in_str[0..i]);
-    for ch in rev.chars().rev() {
-        fwd.push(ch);
-    }
-    (fwd, finished_in_dec)
-}
-
-fn round_terminal_digit(
-    before_dec: String,
-    after_dec: String,
-    position: usize,
-) -> (String, String, bool) {
-    if position < after_dec.len() {
-        let digit_at_pos: char;
-        {
-            digit_at_pos = after_dec[position..=position].chars().next().expect("");
-        }
-        if let '5'..='9' = digit_at_pos {
-            let (new_after_dec, finished_in_dec) = _round_str_from(&after_dec, position, false);
-            if finished_in_dec {
-                return (before_dec, new_after_dec, false);
-            } else {
-                let (new_before_dec, _) = _round_str_from(&before_dec, before_dec.len(), true);
-                let mut dec_place_chg = false;
-                let mut before_dec_chars = new_before_dec.chars();
-                if before_dec_chars.next() == Some('1') && before_dec_chars.all(|c| c == '0') {
-                    // If the first digit is a one and remaining are zeros, we have
-                    // rounded to a new decimal place, so the decimal place must be updated.
-                    // Only update decimal place if the before decimal != 0
-                    dec_place_chg = before_dec != "0";
-                }
-                return (new_before_dec, new_after_dec, dec_place_chg);
-            }
-            // TODO
-        }
-    }
-    (before_dec, after_dec, false)
-}
-
-#[allow(clippy::cognitive_complexity)]
-pub fn get_primitive_dec(
-    initial_prefix: &InitialPrefix,
-    str_in: &str,
-    analysis: &FloatAnalysis,
-    last_dec_place: usize,
-    sci_mode: Option<bool>,
-) -> FormatPrimitive {
-    let mut f = FormatPrimitive::default();
-
-    // add negative sign section
-    if initial_prefix.sign == -1 {
-        f.prefix = Some(String::from("-"));
-    }
-
-    // assign the digits before and after the decimal points
-    // to separate slices. If no digits after decimal point,
-    // assign 0
-    let (mut first_segment_raw, second_segment_raw) = match analysis.decimal_pos {
-        Some(pos) => (&str_in[..pos], &str_in[pos + 1..]),
-        None => (str_in, "0"),
-    };
-    if first_segment_raw.is_empty() {
-        first_segment_raw = "0";
-    }
-    // convert to string, de_hexifying if input is in hex   // spell-checker:disable-line
-    let (first_segment, second_segment) = match initial_prefix.radix_in {
-        Base::Hex => (
-            de_hex(first_segment_raw, true),
-            de_hex(second_segment_raw, false),
-        ),
-        _ => (
-            String::from(first_segment_raw),
-            String::from(second_segment_raw),
-        ),
-    };
-    let (pre_dec_unrounded, post_dec_unrounded, mut mantissa) = if sci_mode.is_some() {
-        if first_segment.len() > 1 {
-            let mut post_dec = String::from(&first_segment[1..]);
-            post_dec.push_str(&second_segment);
-            (
-                String::from(&first_segment[0..1]),
-                post_dec,
-                first_segment.len() as isize - 1,
-            )
-        } else {
-            match first_segment
-                .chars()
-                .next()
-                .expect("float_common: no chars in first segment.")
-            {
-                '0' => {
-                    let it = second_segment.chars().enumerate();
-                    let mut m: isize = 0;
-                    let mut pre = String::from("0");
-                    let mut post = String::from("0");
-                    for (i, c) in it {
-                        match c {
-                            '0' => {}
-                            _ => {
-                                m = -((i as isize) + 1);
-                                pre = String::from(&second_segment[i..=i]);
-                                post = String::from(&second_segment[i + 1..]);
-                                break;
-                            }
-                        }
-                    }
-                    (pre, post, m)
-                }
-                _ => (first_segment, second_segment, 0),
-            }
-        }
-    } else {
-        (first_segment, second_segment, 0)
-    };
-
-    let (pre_dec_draft, post_dec_draft, dec_place_chg) =
-        round_terminal_digit(pre_dec_unrounded, post_dec_unrounded, last_dec_place - 1);
-    f.post_decimal = Some(post_dec_draft);
-    if let Some(capitalized) = sci_mode {
-        let si_ind = if capitalized { 'E' } else { 'e' };
-        // Increase the mantissa if we're adding a decimal place
-        if dec_place_chg {
-            mantissa += 1;
-        }
-        f.suffix = Some(if mantissa >= 0 {
-            format!("{si_ind}+{mantissa:02}")
-        } else {
-            // negative sign is considered in format!s
-            // leading zeroes
-            format!("{si_ind}{mantissa:03}")
-        });
-        f.pre_decimal = Some(pre_dec_draft);
-    } else if dec_place_chg {
-        // We've rounded up to a new decimal place so append 0
-        f.pre_decimal = Some(pre_dec_draft + "0");
-    } else {
-        f.pre_decimal = Some(pre_dec_draft);
-    }
-
-    f
-}
-
-pub fn primitive_to_str_common(prim: &FormatPrimitive, field: &FormatField) -> String {
-    let mut final_str = String::new();
-    if let Some(ref prefix) = prim.prefix {
-        final_str.push_str(prefix);
-    }
-    match prim.pre_decimal {
-        Some(ref pre_decimal) => {
-            final_str.push_str(pre_decimal);
-        }
-        None => {
-            panic!(
-                "error, format primitives provided to int, will, incidentally under correct \
-                 behavior, always have a pre_dec value."
-            );
-        }
-    }
-    let decimal_places = field.second_field.unwrap_or(6);
-    match prim.post_decimal {
-        Some(ref post_decimal) => {
-            if !post_decimal.is_empty() && decimal_places > 0 {
-                final_str.push('.');
-                let len_avail = post_decimal.len() as u32;
-
-                if decimal_places >= len_avail {
-                    // println!("dec {}, len avail {}", decimal_places, len_avail);
-                    final_str.push_str(post_decimal);
-
-                    if *field.field_char != 'g' && *field.field_char != 'G' {
-                        let diff = decimal_places - len_avail;
-                        for _ in 0..diff {
-                            final_str.push('0');
-                        }
-                    }
-                } else {
-                    // println!("printing to only {}", decimal_places);
-                    final_str.push_str(&post_decimal[0..decimal_places as usize]);
-                }
-            }
-        }
-        None => {
-            panic!(
-                "error, format primitives provided to int, will, incidentally under correct \
-                 behavior, always have a pre_dec value."
-            );
-        }
-    }
-    if let Some(ref suffix) = prim.suffix {
-        final_str.push_str(suffix);
-    }
-
-    final_str
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs
deleted file mode 100644
index 59f2cb4085e..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-//! formatter for %f %F common-notation floating-point subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::float_common::{get_primitive_dec, primitive_to_str_common, FloatAnalysis};
-
-#[derive(Default)]
-pub struct Floatf;
-impl Floatf {
-    pub fn new() -> Self {
-        Self
-    }
-}
-impl Formatter for Floatf {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let second_field = field.second_field.unwrap_or(6) + 1;
-        let analysis = FloatAnalysis::analyze(
-            str_in,
-            initial_prefix,
-            None,
-            Some(second_field as usize),
-            false,
-        );
-        let f = get_primitive_dec(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            None,
-        );
-        Some(f)
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        primitive_to_str_common(prim, &field)
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
deleted file mode 100644
index 11070113c26..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
+++ /dev/null
@@ -1,286 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-//! formatter for unsigned and signed int subs
-//! unsigned int: %X %x (hex u64) %o (octal u64) %u (base ten u64)
-//! signed int: %i %d (both base ten i64)
-use super::super::format_field::FormatField;
-use super::super::formatter::{
-    get_it_at, warn_incomplete_conv, Base, FormatPrimitive, Formatter, InitialPrefix,
-};
-use std::i64;
-use std::u64;
-
-#[derive(Default)]
-pub struct Intf {
-    _a: u32,
-}
-
-// see the Intf::analyze() function below
-struct IntAnalysis {
-    check_past_max: bool,
-    past_max: bool,
-    is_zero: bool,
-    len_digits: u8,
-}
-
-impl Intf {
-    pub fn new() -> Self {
-        Self::default()
-    }
-    // take a ref to argument string, and basic information
-    // about prefix (offset, radix, sign), and analyze string
-    // to gain the IntAnalysis information above
-    // check_past_max: true if the number *may* be above max,
-    //   but we don't know either way. One of several reasons
-    //   we may have to parse as int.
-    // past_max: true if the object is past max, false if not
-    //  in the future we should probably combine these into an
-    //  Option<bool>
-    // is_zero: true if number is zero, false otherwise
-    // len_digits: length of digits used to create the int
-    //   important, for example, if we run into a non-valid character
-    #[allow(clippy::cognitive_complexity)]
-    fn analyze(str_in: &str, signed_out: bool, initial_prefix: &InitialPrefix) -> IntAnalysis {
-        // the maximum number of digits we could conceivably
-        // have before the decimal point without exceeding the
-        // max
-        let mut str_it = get_it_at(initial_prefix.offset, str_in);
-        let max_sd_in = if signed_out {
-            match initial_prefix.radix_in {
-                Base::Ten => 19,
-                Base::Octal => 21,
-                Base::Hex => 16,
-            }
-        } else {
-            match initial_prefix.radix_in {
-                Base::Ten => 20,
-                Base::Octal => 22,
-                Base::Hex => 16,
-            }
-        };
-        let mut ret = IntAnalysis {
-            check_past_max: false,
-            past_max: false,
-            is_zero: false,
-            len_digits: 0,
-        };
-
-        // todo turn this to a while let now that we know
-        // no special behavior on EOI break
-        loop {
-            let c_opt = str_it.next();
-            if let Some(c) = c_opt {
-                match c {
-                    '0'..='9' | 'a'..='f' | 'A'..='F' => {
-                        if ret.len_digits == 0 && c == '0' {
-                            ret.is_zero = true;
-                        } else if ret.is_zero {
-                            ret.is_zero = false;
-                        }
-                        ret.len_digits += 1;
-                        if ret.len_digits == max_sd_in {
-                            if let Some(next_ch) = str_it.next() {
-                                match next_ch {
-                                    '0'..='9' => {
-                                        ret.past_max = true;
-                                    }
-                                    _ => {
-                                        // force conversion
-                                        // to check if its above max.
-                                        // todo: spin out convert
-                                        // into fn, call it here to try
-                                        // read val, on Ok()
-                                        // save val for reuse later
-                                        // that way on same-base in and out
-                                        // we don't needlessly convert int
-                                        // to str, we can just copy it over.
-                                        ret.check_past_max = true;
-                                        str_it.put_back(next_ch);
-                                    }
-                                }
-                                if ret.past_max {
-                                    break;
-                                }
-                            } else {
-                                ret.check_past_max = true;
-                            }
-                        }
-                    }
-                    _ => {
-                        warn_incomplete_conv(str_in);
-                        break;
-                    }
-                }
-            } else {
-                // breaks on EOL
-                break;
-            }
-        }
-        ret
-    }
-    // get a FormatPrimitive of the maximum value for the field char
-    //  and given sign
-    fn get_max(field_char: char, sign: i8) -> FormatPrimitive {
-        let mut fmt_primitive = FormatPrimitive::default();
-        fmt_primitive.pre_decimal = Some(String::from(match field_char {
-            'd' | 'i' => match sign {
-                1 => "9223372036854775807",
-                _ => {
-                    fmt_primitive.prefix = Some(String::from("-"));
-                    "9223372036854775808"
-                }
-            },
-            'x' | 'X' => "ffffffffffffffff",
-            'o' => "1777777777777777777777",
-            /* 'u' | */ _ => "18446744073709551615",
-        }));
-        fmt_primitive
-    }
-    // conv_from_segment contract:
-    // 1. takes
-    // - a string that begins with a non-zero digit, and proceeds
-    //  with zero or more following digits until the end of the string
-    // - a radix to interpret those digits as
-    // - a char that communicates:
-    //     whether to interpret+output the string as an i64 or u64
-    //     what radix to write the parsed number as.
-    // 2. parses it as a rust integral type
-    // 3. outputs FormatPrimitive with:
-    // - if the string falls within bounds:
-    //   number parsed and written in the correct radix
-    // - if the string falls outside bounds:
-    //   for i64 output, the int minimum or int max (depending on sign)
-    //   for u64 output, the u64 max in the output radix
-    fn conv_from_segment(
-        segment: &str,
-        radix_in: Base,
-        field_char: char,
-        sign: i8,
-    ) -> FormatPrimitive {
-        match field_char {
-            'i' | 'd' => match i64::from_str_radix(segment, radix_in as u32) {
-                Ok(i) => {
-                    let mut fmt_prim = FormatPrimitive::default();
-                    if sign == -1 {
-                        fmt_prim.prefix = Some(String::from("-"));
-                    }
-                    fmt_prim.pre_decimal = Some(format!("{i}"));
-                    fmt_prim
-                }
-                Err(_) => Self::get_max(field_char, sign),
-            },
-            _ => match u64::from_str_radix(segment, radix_in as u32) {
-                Ok(u) => {
-                    let mut fmt_prim = FormatPrimitive::default();
-                    let u_f = if sign == -1 { u64::MAX - (u - 1) } else { u };
-                    fmt_prim.pre_decimal = Some(match field_char {
-                        'X' => format!("{u_f:X}"),
-                        'x' => format!("{u_f:x}"),
-                        'o' => format!("{u_f:o}"),
-                        _ => format!("{u_f}"),
-                    });
-                    fmt_prim
-                }
-                Err(_) => Self::get_max(field_char, sign),
-            },
-        }
-    }
-}
-impl Formatter for Intf {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let begin = initial_prefix.offset;
-
-        // get information about the string. see Intf::Analyze
-        // def above.
-        let convert_hints = Self::analyze(
-            str_in,
-            *field.field_char == 'i' || *field.field_char == 'd',
-            initial_prefix,
-        );
-        // We always will have a format primitive to return
-        Some(if convert_hints.len_digits == 0 || convert_hints.is_zero {
-            // if non-digit or end is reached before a non-zero digit
-            FormatPrimitive {
-                pre_decimal: Some(String::from("0")),
-                ..Default::default()
-            }
-        } else if !convert_hints.past_max {
-            // if the number is or may be below the bounds limit
-            let radix_out = match *field.field_char {
-                'd' | 'i' | 'u' => Base::Ten,
-                'x' | 'X' => Base::Hex,
-                /* 'o' | */ _ => Base::Octal,
-            };
-            let radix_mismatch = !radix_out.eq(&initial_prefix.radix_in);
-            let decrease_from_max: bool = initial_prefix.sign == -1 && *field.field_char != 'i';
-            let end = begin + convert_hints.len_digits as usize;
-
-            // convert to int if any one of these is true:
-            // - number of digits in int indicates it may be past max
-            // - we're subtracting from the max
-            // - we're converting the base
-            if convert_hints.check_past_max || decrease_from_max || radix_mismatch {
-                // radix of in and out is the same.
-                let segment = String::from(&str_in[begin..end]);
-                Self::conv_from_segment(
-                    &segment,
-                    initial_prefix.radix_in.clone(),
-                    *field.field_char,
-                    initial_prefix.sign,
-                )
-            } else {
-                // otherwise just do a straight string copy.
-                let mut fmt_prim = FormatPrimitive::default();
-
-                // this is here and not earlier because
-                // zero doesn't get a sign, and conv_from_segment
-                // creates its format primitive separately
-                if initial_prefix.sign == -1 && *field.field_char == 'i' {
-                    fmt_prim.prefix = Some(String::from("-"));
-                }
-                fmt_prim.pre_decimal = Some(String::from(&str_in[begin..end]));
-                fmt_prim
-            }
-        } else {
-            Self::get_max(*field.field_char, initial_prefix.sign)
-        })
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        let mut final_str: String = String::new();
-        if let Some(ref prefix) = prim.prefix {
-            final_str.push_str(prefix);
-        }
-        // integral second fields is zero-padded minimum-width
-        // which gets handled before general minimum-width
-        match prim.pre_decimal {
-            Some(ref pre_decimal) => {
-                if let Some(min) = field.second_field {
-                    let mut i = min;
-                    let len = pre_decimal.len() as u32;
-                    while i > len {
-                        final_str.push('0');
-                        i -= 1;
-                    }
-                }
-                final_str.push_str(pre_decimal);
-            }
-            None => {
-                panic!(
-                    "error, format primitives provided to int, will, incidentally under \
-                     correct behavior, always have a pre_dec value."
-                );
-            }
-        }
-        final_str
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs
deleted file mode 100644
index 95908917153..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
-
-mod base_conv;
-pub mod cninetyninehexfloatf;
-pub mod decf;
-mod float_common;
-pub mod floatf;
-pub mod intf;
-pub mod scif;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs
deleted file mode 100644
index a0dfa86c1c1..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
-
-//! formatter for %e %E scientific notation subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::float_common::{get_primitive_dec, primitive_to_str_common, FloatAnalysis};
-
-#[derive(Default)]
-pub struct Scif;
-
-impl Scif {
-    pub fn new() -> Self {
-        Self
-    }
-}
-impl Formatter for Scif {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let second_field = field.second_field.unwrap_or(6) + 1;
-        let analysis = FloatAnalysis::analyze(
-            str_in,
-            initial_prefix,
-            Some(second_field as usize + 1),
-            None,
-            false,
-        );
-        let f = get_primitive_dec(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            Some(*field.field_char == 'E'),
-        );
-        Some(f)
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        primitive_to_str_common(prim, &field)
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/mod.rs
deleted file mode 100644
index d2ce686ff37..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/mod.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-pub mod format_field;
-mod formatter;
-mod formatters;
-pub mod num_format;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/num_format.rs b/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
deleted file mode 100644
index e9b676a8078..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
-
-//! handles creating printed output for numeric substitutions
-
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-use std::env;
-use std::vec::Vec;
-
-use crate::display::Quotable;
-use crate::{show_error, show_warning};
-
-use super::format_field::{FieldType, FormatField};
-use super::formatter::{Base, FormatPrimitive, Formatter, InitialPrefix};
-use super::formatters::cninetyninehexfloatf::CninetyNineHexFloatf;
-use super::formatters::decf::Decf;
-use super::formatters::floatf::Floatf;
-use super::formatters::intf::Intf;
-use super::formatters::scif::Scif;
-
-pub fn warn_expected_numeric(pf_arg: &str) {
-    // important: keep println here not print
-    show_error!("{}: expected a numeric value", pf_arg.maybe_quote());
-}
-
-// when character constant arguments have excess characters
-// issue a warning when POSIXLY_CORRECT is not set
-fn warn_char_constant_ign(remaining_bytes: &[u8]) {
-    match env::var("POSIXLY_CORRECT") {
-        Ok(_) => {}
-        Err(e) => {
-            if let env::VarError::NotPresent = e {
-                show_warning!(
-                    "{:?}: character(s) following character \
-                     constant have been ignored",
-                    remaining_bytes
-                );
-            }
-        }
-    }
-}
-
-// this function looks at the first few
-// characters of an argument and returns a value if we can learn
-// a value from that (e.g. no argument? return 0, char constant? ret value)
-fn get_provided(str_in_opt: Option<&String>) -> Option<u8> {
-    const C_S_QUOTE: u8 = 39;
-    const C_D_QUOTE: u8 = 34;
-    match str_in_opt {
-        Some(str_in) => {
-            let mut byte_it = str_in.bytes();
-            if let Some(ch) = byte_it.next() {
-                match ch {
-                    C_S_QUOTE | C_D_QUOTE => {
-                        Some(match byte_it.next() {
-                            Some(second_byte) => {
-                                let mut ignored: Vec<u8> = Vec::new();
-                                for cont in byte_it {
-                                    ignored.push(cont);
-                                }
-                                if !ignored.is_empty() {
-                                    warn_char_constant_ign(&ignored);
-                                }
-                                second_byte
-                            }
-                            // no byte after quote
-                            None => {
-                                let so_far = (ch as char).to_string();
-                                warn_expected_numeric(&so_far);
-                                0_u8
-                            }
-                        })
-                    }
-                    // first byte is not quote
-                    _ => None, // no first byte
-                }
-            } else {
-                Some(0_u8)
-            }
-        }
-        None => Some(0),
-    }
-}
-
-// takes a string and returns
-// a sign,
-// a base,
-// and an offset for index after all
-//  initial spacing, sign, base prefix, and leading zeroes
-#[allow(clippy::cognitive_complexity)]
-fn get_initial_prefix(str_in: &str, field_type: &FieldType) -> InitialPrefix {
-    let mut str_it = str_in.chars();
-    let mut ret = InitialPrefix {
-        radix_in: Base::Ten,
-        sign: 1,
-        offset: 0,
-    };
-    let mut top_char = str_it.next();
-    // skip spaces and ensure top_char is the first non-space char
-    // (or None if none exists)
-    while let Some(' ') = top_char {
-        ret.offset += 1;
-        top_char = str_it.next();
-    }
-    // parse sign
-    match top_char {
-        Some('+') => {
-            ret.offset += 1;
-            top_char = str_it.next();
-        }
-        Some('-') => {
-            ret.sign = -1;
-            ret.offset += 1;
-            top_char = str_it.next();
-        }
-        _ => {}
-    }
-    // we want to exit with offset being
-    // the index of the first non-zero
-    // digit before the decimal point or
-    // if there is none, the zero before the
-    // decimal point, or, if there is none,
-    // the decimal point.
-
-    // while we are determining the offset
-    // we will ensure as a convention
-    // the offset is always on the first character
-    // that we are yet unsure if it is the
-    // final offset. If the zero could be before
-    // a decimal point we don't move past the zero.
-    let mut is_hex = false;
-    if Some('0') == top_char {
-        if let Some(base) = str_it.next() {
-            // lead zeroes can only exist in
-            // octal and hex base
-            let mut do_clean_lead_zeroes = false;
-            match base {
-                'x' | 'X' => {
-                    is_hex = true;
-                    ret.offset += 2;
-                    ret.radix_in = Base::Hex;
-                    do_clean_lead_zeroes = true;
-                }
-                e @ '0'..='9' => {
-                    ret.offset += 1;
-                    if let FieldType::Intf = *field_type {
-                        ret.radix_in = Base::Octal;
-                    }
-                    if e == '0' {
-                        do_clean_lead_zeroes = true;
-                    }
-                }
-                _ => {}
-            }
-            if do_clean_lead_zeroes {
-                let mut first = true;
-                for ch_zero in str_it {
-                    // see notes on offset above:
-                    // this is why the offset for octal and decimal numbers
-                    // that reach this branch is 1 even though
-                    // they have already eaten the characters '00'
-                    // this is also why when hex encounters its
-                    // first zero it does not move its offset
-                    // forward because it does not know for sure
-                    // that it's current offset (of that zero)
-                    // is not the final offset,
-                    // whereas at that point octal knows its
-                    // current offset is not the final offset.
-                    match ch_zero {
-                        '0' => {
-                            if !(is_hex && first) {
-                                ret.offset += 1;
-                            }
-                        }
-                        // if decimal, keep last zero if one exists
-                        // (it's possible for last zero to
-                        // not exist at this branch if we're in hex input)
-                        '.' => break,
-                        // other digit, etc.
-                        _ => {
-                            if !(is_hex && first) {
-                                ret.offset += 1;
-                            }
-                            break;
-                        }
-                    }
-                    if first {
-                        first = false;
-                    }
-                }
-            }
-        }
-    }
-    ret
-}
-
-// this is the function a Sub's print will delegate to
-// if it is a numeric field, passing the field details
-// and an iterator to the argument
-pub fn num_format(field: &FormatField, in_str_opt: Option<&String>) -> Option<String> {
-    let field_char = field.field_char;
-
-    // num format mainly operates by further delegating to one of
-    // several Formatter structs depending on the field
-    // see formatter.rs for more details
-
-    // to do switch to static dispatch
-    let formatter: Box<dyn Formatter> = match *field.field_type {
-        FieldType::Intf => Box::new(Intf::new()),
-        FieldType::Floatf => Box::new(Floatf::new()),
-        FieldType::CninetyNineHexFloatf => Box::new(CninetyNineHexFloatf::new()),
-        FieldType::Scif => Box::new(Scif::new()),
-        FieldType::Decf => Box::new(Decf::new()),
-        _ => {
-            panic!("asked to do num format with non-num field type");
-        }
-    };
-    let prim_opt=
-        // if we can get an assumed value from looking at the first
-        // few characters, use that value to create the FormatPrimitive
-        if let Some(provided_num) = get_provided(in_str_opt) {
-            let mut tmp = FormatPrimitive::default();
-            match field_char {
-                'u' | 'i' | 'd' => {
-                    tmp.pre_decimal = Some(
-                        format!("{provided_num}"));
-                },
-                'x' | 'X' => {
-                    tmp.pre_decimal = Some(
-                        format!("{provided_num:x}"));
-                },
-                'o' => {
-                    tmp.pre_decimal = Some(
-                        format!("{provided_num:o}"));
-                },
-                'e' | 'E' | 'g' | 'G' => {
-                    let as_str = format!("{provided_num}");
-                    let initial_prefix = get_initial_prefix(
-                        &as_str,
-                        field.field_type
-                    );
-                    tmp=formatter.get_primitive(field, &initial_prefix, &as_str)
-                        .expect("err during default provided num");
-                },
-                _ => {
-                    tmp.pre_decimal = Some(
-                        format!("{provided_num}"));
-                    tmp.post_decimal = Some(String::from("0"));
-                }
-            }
-            Some(tmp)
-        } else {
-            // otherwise we'll interpret the argument as a number
-            // using the appropriate Formatter
-            let in_str = in_str_opt.expect(
-                "please send the devs this message:
-                \n get_provided is failing to ret as Some(0) on no str ");
-            // first get information about the beginning of the
-            // numeric argument that would be useful for
-            // any formatter (int or float)
-            let initial_prefix = get_initial_prefix(
-                in_str,
-                field.field_type
-            );
-            // then get the FormatPrimitive from the Formatter
-            formatter.get_primitive(field, &initial_prefix, in_str)
-        };
-    // if we have a formatPrimitive, print its results
-    // according to the field-char appropriate Formatter
-    prim_opt.map(|prim| formatter.primitive_to_str(&prim, field.clone()))
-}
diff --git a/src/uucore/src/lib/features/tokenize/sub.rs b/src/uucore/src/lib/features/tokenize/sub.rs
deleted file mode 100644
index 0ae966fc332..00000000000
--- a/src/uucore/src/lib/features/tokenize/sub.rs
+++ /dev/null
@@ -1,463 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-//! Sub is a token that represents a
-//! segment of the format string that is a substitution
-//! it is created by Sub's implementation of the Tokenizer trait
-//! Subs which have numeric field chars make use of the num_format
-//! submodule
-use crate::error::{UError, UResult};
-use crate::quoting_style::{escape_name, QuotingStyle};
-use itertools::{put_back_n, PutBackN};
-use std::error::Error;
-use std::fmt::Display;
-use std::io::Write;
-use std::iter::Peekable;
-use std::process::exit;
-use std::slice::Iter;
-use std::str::Chars;
-
-use super::num_format::format_field::{FieldType, FormatField};
-use super::num_format::num_format;
-use super::token;
-use super::unescaped_text::UnescapedText;
-
-const EXIT_ERR: i32 = 1;
-
-#[derive(Debug)]
-pub enum SubError {
-    InvalidSpec(String),
-}
-
-impl Display for SubError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            Self::InvalidSpec(s) => write!(f, "%{s}: invalid conversion specification"),
-        }
-    }
-}
-
-impl Error for SubError {}
-
-impl UError for SubError {}
-
-fn convert_asterisk_arg_int(asterisk_arg: &str) -> isize {
-    // this is a costly way to parse the
-    // args used for asterisk values into integers
-    // from various bases. Actually doing it correctly
-    // (going through the pipeline to intf, but returning
-    // the integer instead of writing it to string and then
-    // back) is on the refactoring TODO
-    let field_type = FieldType::Intf;
-    let field_char = 'i';
-    let field_info = FormatField {
-        min_width: Some(0),
-        second_field: Some(0),
-        orig: &asterisk_arg.to_string(),
-        field_type: &field_type,
-        field_char: &field_char,
-    };
-    num_format::num_format(&field_info, Some(&asterisk_arg.to_string()))
-        .unwrap()
-        .parse::<isize>()
-        .unwrap()
-}
-
-pub enum CanAsterisk<T> {
-    Fixed(T),
-    Asterisk,
-}
-
-// Sub is a tokenizer which creates tokens
-// for substitution segments of a format string
-pub struct Sub {
-    min_width: CanAsterisk<Option<isize>>,
-    second_field: CanAsterisk<Option<u32>>,
-    field_char: char,
-    field_type: FieldType,
-    orig: String,
-    prefix_char: char,
-}
-impl Sub {
-    pub fn new(
-        min_width: CanAsterisk<Option<isize>>,
-        second_field: CanAsterisk<Option<u32>>,
-        field_char: char,
-        orig: String,
-        prefix_char: char,
-    ) -> Self {
-        // for more dry printing, field characters are grouped
-        // in initialization of token.
-        let field_type = match field_char {
-            's' | 'b' | 'q' => FieldType::Strf,
-            'd' | 'i' | 'u' | 'o' | 'x' | 'X' => FieldType::Intf,
-            'f' | 'F' => FieldType::Floatf,
-            'a' | 'A' => FieldType::CninetyNineHexFloatf,
-            'e' | 'E' => FieldType::Scif,
-            'g' | 'G' => FieldType::Decf,
-            'c' => FieldType::Charf,
-            _ => {
-                // should be unreachable.
-                println!("Invalid field type");
-                exit(EXIT_ERR);
-            }
-        };
-        Self {
-            min_width,
-            second_field,
-            field_char,
-            field_type,
-            orig,
-            prefix_char,
-        }
-    }
-}
-
-#[derive(Default)]
-pub(crate) struct SubParser {
-    min_width_tmp: Option<String>,
-    min_width_is_asterisk: bool,
-    past_decimal: bool,
-    second_field_tmp: Option<String>,
-    second_field_is_asterisk: bool,
-    specifiers_found: bool,
-    field_char: Option<char>,
-    text_so_far: String,
-}
-
-impl SubParser {
-    fn new() -> Self {
-        Self::default()
-    }
-    pub(crate) fn from_it<W>(
-        writer: &mut W,
-        it: &mut PutBackN<Chars>,
-        args: &mut Peekable<Iter<String>>,
-    ) -> UResult<Option<token::Token>>
-    where
-        W: Write,
-    {
-        let mut parser = Self::new();
-        if parser.sub_vals_retrieved(it)? {
-            let t = Self::build_token(parser);
-            t.write(writer, args);
-            Ok(Some(t))
-        } else {
-            Ok(None)
-        }
-    }
-    fn build_token(parser: Self) -> token::Token {
-        // not a self method so as to allow move of sub-parser vals.
-        // return new Sub struct as token
-        let prefix_char = match &parser.min_width_tmp {
-            Some(width) if width.starts_with('0') => '0',
-            _ => ' ',
-        };
-
-        token::Token::Sub(Sub::new(
-            if parser.min_width_is_asterisk {
-                CanAsterisk::Asterisk
-            } else {
-                CanAsterisk::Fixed(
-                    parser
-                        .min_width_tmp
-                        .map(|x| x.parse::<isize>().unwrap_or(1)),
-                )
-            },
-            if parser.second_field_is_asterisk {
-                CanAsterisk::Asterisk
-            } else {
-                CanAsterisk::Fixed(parser.second_field_tmp.map(|x| x.parse::<u32>().unwrap()))
-            },
-            parser.field_char.unwrap(),
-            parser.text_so_far,
-            prefix_char,
-        ))
-    }
-    #[allow(clippy::cognitive_complexity)]
-    fn sub_vals_retrieved(&mut self, it: &mut PutBackN<Chars>) -> UResult<bool> {
-        if !Self::successfully_eat_prefix(it, &mut self.text_so_far)? {
-            return Ok(false);
-        }
-        // this fn in particular is much longer than it needs to be
-        // .could get a lot
-        // of code savings just by cleaning it up. shouldn't use a regex
-        // though, as we want to mimic the original behavior of printing
-        // the field as interpreted up until the error in the field.
-
-        let mut legal_fields = [
-            // 'a', 'A', //c99 hex float implementation not yet complete
-            'b', 'c', 'd', 'e', 'E', 'f', 'F', 'g', 'G', 'i', 'o', 'q', 's', 'u', 'x', 'X',
-        ];
-        let mut specifiers = ['h', 'j', 'l', 'L', 't', 'z'];
-        legal_fields.sort_unstable();
-        specifiers.sort_unstable();
-
-        // divide substitution from %([0-9]+)?(.[0-9+])?([a-zA-Z])
-        // into min_width, second_field, field_char
-        for ch in it {
-            self.text_so_far.push(ch);
-            match ch {
-                '-' | '*' | '0'..='9' => {
-                    if self.past_decimal {
-                        // second field should never have a
-                        // negative value
-                        if self.second_field_is_asterisk || ch == '-' || self.specifiers_found {
-                            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-                        }
-                        if self.second_field_tmp.is_none() {
-                            self.second_field_tmp = Some(String::new());
-                        }
-                        match self.second_field_tmp.as_mut() {
-                            Some(x) => {
-                                if ch == '*' && !x.is_empty() {
-                                    return Err(
-                                        SubError::InvalidSpec(self.text_so_far.clone()).into()
-                                    );
-                                }
-                                if ch == '*' {
-                                    self.second_field_is_asterisk = true;
-                                }
-                                x.push(ch);
-                            }
-                            None => {
-                                panic!("should be unreachable");
-                            }
-                        }
-                    } else {
-                        if self.min_width_is_asterisk || self.specifiers_found {
-                            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-                        }
-                        if self.min_width_tmp.is_none() {
-                            self.min_width_tmp = Some(String::new());
-                        }
-                        match self.min_width_tmp.as_mut() {
-                            Some(x) => {
-                                if (ch == '-' || ch == '*') && !x.is_empty() {
-                                    return Err(
-                                        SubError::InvalidSpec(self.text_so_far.clone()).into()
-                                    );
-                                }
-                                if ch == '*' {
-                                    self.min_width_is_asterisk = true;
-                                }
-                                x.push(ch);
-                            }
-                            None => {
-                                panic!("should be unreachable");
-                            }
-                        }
-                    }
-                }
-                '.' => {
-                    if self.past_decimal {
-                        return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-                    } else {
-                        self.past_decimal = true;
-                    }
-                }
-                x if legal_fields.binary_search(&x).is_ok() => {
-                    self.field_char = Some(ch);
-                    break;
-                }
-                x if specifiers.binary_search(&x).is_ok() => {
-                    if !self.past_decimal {
-                        self.past_decimal = true;
-                    }
-                    if !self.specifiers_found {
-                        self.specifiers_found = true;
-                    }
-                }
-                _ => {
-                    return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-                }
-            }
-        }
-        if self.field_char.is_none() {
-            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-        }
-        let field_char_retrieved = self.field_char.unwrap();
-        if self.past_decimal && self.second_field_tmp.is_none() {
-            self.second_field_tmp = Some(String::from("0"));
-        }
-        self.validate_field_params(field_char_retrieved)?;
-        // if the dot is provided without a second field
-        // printf interprets it as 0.
-        if let Some(x) = self.second_field_tmp.as_mut() {
-            if x.is_empty() {
-                self.min_width_tmp = Some(String::from("0"));
-            }
-        }
-
-        Ok(true)
-    }
-    fn successfully_eat_prefix(
-        it: &mut PutBackN<Chars>,
-        text_so_far: &mut String,
-    ) -> UResult<bool> {
-        // get next two chars,
-        // if they're '%%' we're not tokenizing it
-        // else put chars back
-        let preface = it.next();
-        let n_ch = it.next();
-        if preface == Some('%') && n_ch != Some('%') {
-            match n_ch {
-                Some(x) => {
-                    it.put_back(x);
-                    Ok(true)
-                }
-                None => {
-                    text_so_far.push('%');
-                    Err(SubError::InvalidSpec(text_so_far.clone()).into())
-                }
-            }
-        } else {
-            if let Some(x) = n_ch {
-                it.put_back(x);
-            };
-            if let Some(x) = preface {
-                it.put_back(x);
-            };
-            Ok(false)
-        }
-    }
-    fn validate_field_params(&self, field_char: char) -> UResult<()> {
-        // check for illegal combinations here when possible vs
-        // on each application so we check less per application
-        // to do: move these checks to Sub::new
-        if (field_char == 's' && self.min_width_tmp == Some(String::from("0")))
-            || (field_char == 'c'
-                && (self.min_width_tmp == Some(String::from("0")) || self.past_decimal))
-            || ((field_char == 'b' || field_char == 'q')
-                && (self.min_width_tmp.is_some()
-                    || self.past_decimal
-                    || self.second_field_tmp.is_some()))
-        {
-            // invalid string substitution
-            // to do: include information about an invalid
-            // string substitution
-            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-        }
-        Ok(())
-    }
-}
-
-impl Sub {
-    #[allow(clippy::cognitive_complexity)]
-    pub(crate) fn write<W>(&self, writer: &mut W, pf_args_it: &mut Peekable<Iter<String>>)
-    where
-        W: Write,
-    {
-        let field = FormatField {
-            min_width: match self.min_width {
-                CanAsterisk::Fixed(x) => x,
-                CanAsterisk::Asterisk => {
-                    match pf_args_it.next() {
-                        // temporary, use intf.rs instead
-                        Some(x) => Some(convert_asterisk_arg_int(x)),
-                        None => Some(0),
-                    }
-                }
-            },
-            second_field: match self.second_field {
-                CanAsterisk::Fixed(x) => x,
-                CanAsterisk::Asterisk => {
-                    match pf_args_it.next() {
-                        // temporary, use intf.rs instead
-                        Some(x) => {
-                            let result = convert_asterisk_arg_int(x);
-                            if result < 0 {
-                                None
-                            } else {
-                                Some(result as u32)
-                            }
-                        }
-                        None => Some(0),
-                    }
-                }
-            },
-            field_char: &self.field_char,
-            field_type: &self.field_type,
-            orig: &self.orig,
-        };
-        let pf_arg = pf_args_it.next();
-
-        // minimum width is handled independently of actual
-        // field char
-        let pre_min_width_opt: Option<String> = match *field.field_type {
-            // if %s just return arg
-            // if %b use UnescapedText module's unescape-fn
-            // if %c return first char of arg
-            // if %q return arg which non-printable characters are escaped
-            FieldType::Strf | FieldType::Charf => {
-                match pf_arg {
-                    Some(arg_string) => {
-                        match *field.field_char {
-                            's' => Some(match field.second_field {
-                                Some(max) => String::from(&arg_string[..max as usize]),
-                                None => arg_string.clone(),
-                            }),
-                            'b' => {
-                                let mut a_it = put_back_n(arg_string.chars());
-                                UnescapedText::from_it_core(writer, &mut a_it, true);
-                                None
-                            }
-                            'q' => Some(escape_name(
-                                arg_string.as_ref(),
-                                &QuotingStyle::Shell {
-                                    escape: true,
-                                    always_quote: false,
-                                    show_control: false,
-                                },
-                            )),
-                            // get opt<char> of first val
-                            // and map it to opt<String>
-                            'c' => arg_string.chars().next().map(|x| x.to_string()),
-                            _ => unreachable!(),
-                        }
-                    }
-                    None => None,
-                }
-            }
-            _ => {
-                // non string/char fields are delegated to num_format
-                num_format::num_format(&field, pf_arg)
-            }
-        };
-        if let Some(pre_min_width) = pre_min_width_opt {
-            // if have a string, print it, ensuring minimum width is met.
-            write!(
-                writer,
-                "{}",
-                match field.min_width {
-                    Some(min_width) => {
-                        let diff: isize = min_width.abs() - pre_min_width.len() as isize;
-                        if diff > 0 {
-                            let mut final_str = String::new();
-                            // definitely more efficient ways
-                            //  to do this.
-                            let pad_before = min_width > 0;
-                            if !pad_before {
-                                final_str.push_str(&pre_min_width);
-                            }
-                            for _ in 0..diff {
-                                final_str.push(self.prefix_char);
-                            }
-                            if pad_before {
-                                final_str.push_str(&pre_min_width);
-                            }
-                            final_str
-                        } else {
-                            pre_min_width
-                        }
-                    }
-                    None => pre_min_width,
-                }
-            )
-            .ok();
-        }
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/token.rs b/src/uucore/src/lib/features/tokenize/token.rs
deleted file mode 100644
index c4f7bd6accc..00000000000
--- a/src/uucore/src/lib/features/tokenize/token.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-//! Traits and enums dealing with Tokenization of printf Format String
-use std::io::Write;
-use std::iter::Peekable;
-use std::slice::Iter;
-
-use crate::features::tokenize::sub::Sub;
-use crate::features::tokenize::unescaped_text::UnescapedText;
-
-// A token object is an object that can print the expected output
-// of a contiguous segment of the format string, and
-// requires at most 1 argument
-pub enum Token {
-    Sub(Sub),
-    UnescapedText(UnescapedText),
-}
-
-impl Token {
-    pub(crate) fn write<W>(&self, writer: &mut W, args: &mut Peekable<Iter<String>>)
-    where
-        W: Write,
-    {
-        match self {
-            Self::Sub(sub) => sub.write(writer, args),
-            Self::UnescapedText(unescaped_text) => unescaped_text.write(writer),
-        }
-    }
-}
-
-// A tokenizer object is an object that takes an iterator
-// at a position in a format string, and sees whether
-// it can return a token of a type it knows how to produce
-// if so, return the token, move the iterator past the
-// format string text the token represents, and if an
-// argument is used move the argument iter forward one
-
-// creating token of a format string segment should also cause
-// printing of that token's value. Essentially tokenizing
-// a whole format string will print the format string and consume
-// a number of arguments equal to the number of argument-using tokens
diff --git a/src/uucore/src/lib/features/tokenize/unescaped_text.rs b/src/uucore/src/lib/features/tokenize/unescaped_text.rs
deleted file mode 100644
index 8ec6fd57618..00000000000
--- a/src/uucore/src/lib/features/tokenize/unescaped_text.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-//! UnescapedText is a tokenizer impl
-//! for tokenizing character literals,
-//! and escaped character literals (of allowed escapes),
-//! into an unescaped text byte array
-
-// spell-checker:ignore (ToDO) retval hexchars octals printf's bvec vals coreutil addchar eval bytecode bslice
-
-use itertools::PutBackN;
-use std::char::from_u32;
-use std::io::Write;
-use std::process::exit;
-use std::str::Chars;
-
-use super::token;
-
-const EXIT_OK: i32 = 0;
-const EXIT_ERR: i32 = 1;
-
-// by default stdout only flushes
-// to console when a newline is passed.
-macro_rules! write_and_flush {
-    ($writer:expr, $($args:tt)+) => ({
-        write!($writer, "{}", $($args)+).ok();
-        $writer.flush().ok();
-    })
-}
-
-fn flush_bytes<W>(writer: &mut W, bslice: &[u8])
-where
-    W: Write,
-{
-    writer.write_all(bslice).ok();
-    writer.flush().ok();
-}
-
-#[derive(Default)]
-pub struct UnescapedText(Vec<u8>);
-impl UnescapedText {
-    fn new() -> Self {
-        Self::default()
-    }
-    // take an iterator to the format string
-    // consume between min and max chars
-    // and return it as a base-X number
-    fn base_to_u32(min_chars: u8, max_chars: u8, base: u32, it: &mut PutBackN<Chars>) -> u32 {
-        let mut retval: u32 = 0;
-        let mut found = 0;
-        while found < max_chars {
-            // if end of input break
-            let nc = it.next();
-            match nc {
-                Some(digit) => {
-                    // if end of hexchars break
-                    match digit.to_digit(base) {
-                        Some(d) => {
-                            found += 1;
-                            retval *= base;
-                            retval += d;
-                        }
-                        None => {
-                            it.put_back(digit);
-                            break;
-                        }
-                    }
-                }
-                None => {
-                    break;
-                }
-            }
-        }
-        if found < min_chars {
-            // only ever expected for hex
-            println!("missing hexadecimal number in escape"); //todo stderr
-            exit(EXIT_ERR);
-        }
-        retval
-    }
-    // validates against valid
-    // IEC 10646 vals - these values
-    // are pinned against the more popular
-    // printf so as to not disrupt when
-    // dropped-in as a replacement.
-    fn validate_iec(val: u32, eight_word: bool) {
-        let mut preface = 'u';
-        let leading_zeros = if eight_word {
-            preface = 'U';
-            8
-        } else {
-            4
-        };
-        let err_msg = format!("invalid universal character name {preface}{val:0leading_zeros$x}");
-        if (val < 159 && (val != 36 && val != 64 && val != 96)) || (val > 55296 && val < 57343) {
-            println!("{err_msg}"); //todo stderr
-            exit(EXIT_ERR);
-        }
-    }
-    // pass an iterator that succeeds an '/',
-    // and process the remaining character
-    // adding the unescaped bytes
-    // to the passed byte_vec
-    // in subs_mode change octal behavior
-    fn handle_escaped<W>(
-        writer: &mut W,
-        byte_vec: &mut Vec<u8>,
-        it: &mut PutBackN<Chars>,
-        subs_mode: bool,
-    ) where
-        W: Write,
-    {
-        let ch = it.next().unwrap_or('\\');
-        match ch {
-            '0'..='9' | 'x' => {
-                let min_len = 1;
-                let mut max_len = 2;
-                let mut base = 16;
-                let ignore = false;
-                match ch {
-                    'x' => {}
-                    e @ '0'..='9' => {
-                        max_len = 3;
-                        base = 8;
-                        // in practice, gnu coreutils printf
-                        // interprets octals without a
-                        // leading zero in %b
-                        // but it only skips leading zeros
-                        // in %b mode.
-                        // if we ever want to match gnu coreutil
-                        // printf's docs instead of its behavior
-                        // we'd set this to true.
-                        // if subs_mode && e != '0'
-                        //  { ignore = true; }
-                        if !subs_mode || e != '0' {
-                            it.put_back(ch);
-                        }
-                    }
-                    _ => {}
-                }
-                if ignore {
-                    byte_vec.push(ch as u8);
-                } else {
-                    let val = (Self::base_to_u32(min_len, max_len, base, it) % 256) as u8;
-                    byte_vec.push(val);
-                    let bvec = [val];
-                    flush_bytes(writer, &bvec);
-                }
-            }
-            e => {
-                // only for hex and octal
-                // is byte encoding specified.
-                // otherwise, why not leave the door open
-                // for other encodings unless it turns out
-                // a bottleneck.
-                let mut s = String::new();
-                let ch = match e {
-                    '\\' => '\\',
-                    '"' => '"',
-                    'n' => '\n',
-                    'r' => '\r',
-                    't' => '\t',
-                    // bell
-                    'a' => '\x07',
-                    // backspace
-                    'b' => '\x08',
-                    // vertical tab
-                    'v' => '\x0B',
-                    // form feed
-                    'f' => '\x0C',
-                    // escape character
-                    'e' => '\x1B',
-                    'c' => exit(EXIT_OK),
-                    'u' | 'U' => {
-                        let len = match e {
-                            'u' => 4,
-                            /* 'U' | */ _ => 8,
-                        };
-                        let val = Self::base_to_u32(len, len, 16, it);
-                        Self::validate_iec(val, false);
-                        if let Some(c) = from_u32(val) {
-                            c
-                        } else {
-                            '-'
-                        }
-                    }
-                    _ => {
-                        s.push('\\');
-                        ch
-                    }
-                };
-                s.push(ch);
-                write_and_flush!(writer, &s);
-                byte_vec.extend(s.bytes());
-            }
-        };
-    }
-
-    // take an iterator to a string,
-    // and return a wrapper around a Vec<u8> of unescaped bytes
-    // break on encounter of sub symbol ('%[^%]') unless called
-    // through %b subst.
-    #[allow(clippy::cognitive_complexity)]
-    pub fn from_it_core<W>(
-        writer: &mut W,
-        it: &mut PutBackN<Chars>,
-        subs_mode: bool,
-    ) -> Option<token::Token>
-    where
-        W: Write,
-    {
-        let mut addchar = false;
-        let mut new_text = Self::new();
-        let mut tmp_str = String::new();
-        {
-            let new_vec: &mut Vec<u8> = &mut (new_text.0);
-            while let Some(ch) = it.next() {
-                if !addchar {
-                    addchar = true;
-                }
-                match ch {
-                    x if x != '\\' && x != '%' => {
-                        // lazy branch eval
-                        // remember this fn could be called
-                        // many times in a single exec through %b
-                        write_and_flush!(writer, ch);
-                        tmp_str.push(ch);
-                    }
-                    '\\' => {
-                        // the literal may be a literal bytecode
-                        // and not valid utf-8. Str only supports
-                        // valid utf-8.
-                        // if we find the unnecessary drain
-                        // on non hex or octal escapes is costly
-                        // then we can make it faster/more complex
-                        // with as-necessary draining.
-                        if !tmp_str.is_empty() {
-                            new_vec.extend(tmp_str.bytes());
-                            tmp_str = String::new();
-                        }
-                        Self::handle_escaped(writer, new_vec, it, subs_mode);
-                    }
-                    x if x == '%' && !subs_mode => {
-                        if let Some(follow) = it.next() {
-                            if follow == '%' {
-                                write_and_flush!(writer, ch);
-                                tmp_str.push(ch);
-                            } else {
-                                it.put_back(follow);
-                                it.put_back(ch);
-                                break;
-                            }
-                        } else {
-                            it.put_back(ch);
-                            break;
-                        }
-                    }
-                    _ => {
-                        write_and_flush!(writer, ch);
-                        tmp_str.push(ch);
-                    }
-                }
-            }
-            if !tmp_str.is_empty() {
-                new_vec.extend(tmp_str.bytes());
-            }
-        }
-        if addchar {
-            Some(token::Token::UnescapedText(new_text))
-        } else {
-            None
-        }
-    }
-}
-impl UnescapedText {
-    pub(crate) fn write<W>(&self, writer: &mut W)
-    where
-        W: Write,
-    {
-        flush_bytes(writer, &self.0[..]);
-    }
-}
diff --git a/src/uucore/src/lib/lib.rs b/src/uucore/src/lib/lib.rs
index 2f28195dae1..6f8400589ef 100644
--- a/src/uucore/src/lib/lib.rs
+++ b/src/uucore/src/lib/lib.rs
@@ -35,16 +35,16 @@ pub use crate::parser::shortcut_value_parser;
 // * feature-gated modules
 #[cfg(feature = "backup-control")]
 pub use crate::features::backup_control;
+#[cfg(feature = "colors")]
+pub use crate::features::colors;
 #[cfg(feature = "encoding")]
 pub use crate::features::encoding;
+#[cfg(feature = "format")]
+pub use crate::features::format;
 #[cfg(feature = "fs")]
 pub use crate::features::fs;
-#[cfg(feature = "fsext")]
-pub use crate::features::fsext;
 #[cfg(feature = "lines")]
 pub use crate::features::lines;
-#[cfg(feature = "memo")]
-pub use crate::features::memo;
 #[cfg(feature = "quoting-style")]
 pub use crate::features::quoting_style;
 #[cfg(feature = "ranges")]
@@ -77,6 +77,7 @@ pub use crate::features::signals;
     unix,
     not(target_os = "android"),
     not(target_os = "fuchsia"),
+    not(target_os = "openbsd"),
     not(target_os = "redox"),
     not(target_env = "musl"),
     feature = "utmpx"
@@ -86,6 +87,12 @@ pub use crate::features::utmpx;
 #[cfg(all(windows, feature = "wide"))]
 pub use crate::features::wide;
 
+#[cfg(feature = "fsext")]
+pub use crate::features::fsext;
+
+#[cfg(all(unix, not(target_os = "macos"), feature = "fsxattr"))]
+pub use crate::features::fsxattr;
+
 //## core functions
 
 use std::ffi::OsString;
@@ -102,9 +109,15 @@ macro_rules! bin {
     ($util:ident) => {
         pub fn main() {
             use std::io::Write;
-            uucore::panic::mute_sigpipe_panic(); // suppress extraneous error output for SIGPIPE failures/panics
-            let code = $util::uumain(uucore::args_os()); // execute utility code
-            std::io::stdout().flush().expect("could not flush stdout"); // (defensively) flush stdout for utility prior to exit; see <https://github.com/rust-lang/rust/issues/23818>
+            // suppress extraneous error output for SIGPIPE failures/panics
+            uucore::panic::mute_sigpipe_panic();
+            // execute utility code
+            let code = $util::uumain(uucore::args_os());
+            // (defensively) flush stdout for utility prior to exit; see <https://github.com/rust-lang/rust/issues/23818>
+            if let Err(e) = std::io::stdout().flush() {
+                eprintln!("Error flushing stdout: {}", e);
+            }
+
             std::process::exit(code);
         }
     };
diff --git a/src/uucore/src/lib/macros.rs b/src/uucore/src/lib/macros.rs
index ad86d530828..d1a09c281ab 100644
--- a/src/uucore/src/lib/macros.rs
+++ b/src/uucore/src/lib/macros.rs
@@ -91,6 +91,7 @@ pub static UTILITY_IS_SECOND_ARG: AtomicBool = AtomicBool::new(false);
 #[macro_export]
 macro_rules! show(
     ($err:expr) => ({
+        use $crate::error::UError;
         let e = $err;
         $crate::error::set_exit_code(e.code());
         eprintln!("{}: {}", $crate::util_name(), e);
@@ -131,7 +132,7 @@ macro_rules! show(
 macro_rules! show_if_err(
     ($res:expr) => ({
         if let Err(e) = $res {
-            show!(e);
+            $crate::show!(e);
         }
     })
 );
diff --git a/src/uucore/src/lib/parser/parse_size.rs b/src/uucore/src/lib/parser/parse_size.rs
index 0a46ce3271b..163c8942fb2 100644
--- a/src/uucore/src/lib/parser/parse_size.rs
+++ b/src/uucore/src/lib/parser/parse_size.rs
@@ -424,23 +424,23 @@ mod tests {
 
         for &(c, exp) in &suffixes {
             let s = format!("2{c}B"); // KB
-            assert_eq!(Ok((2 * (1000_u128).pow(exp)) as u128), parse_size_u128(&s));
+            assert_eq!(Ok(2 * (1000_u128).pow(exp)), parse_size_u128(&s));
             let s = format!("2{c}"); // K
-            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u128), parse_size_u128(&s));
+            assert_eq!(Ok(2 * (1024_u128).pow(exp)), parse_size_u128(&s));
             let s = format!("2{c}iB"); // KiB
-            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u128), parse_size_u128(&s));
+            assert_eq!(Ok(2 * (1024_u128).pow(exp)), parse_size_u128(&s));
             let s = format!("2{}iB", c.to_lowercase()); // kiB
-            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u128), parse_size_u128(&s));
+            assert_eq!(Ok(2 * (1024_u128).pow(exp)), parse_size_u128(&s));
 
             // suffix only
             let s = format!("{c}B"); // KB
-            assert_eq!(Ok(((1000_u128).pow(exp)) as u128), parse_size_u128(&s));
+            assert_eq!(Ok((1000_u128).pow(exp)), parse_size_u128(&s));
             let s = format!("{c}"); // K
-            assert_eq!(Ok(((1024_u128).pow(exp)) as u128), parse_size_u128(&s));
+            assert_eq!(Ok((1024_u128).pow(exp)), parse_size_u128(&s));
             let s = format!("{c}iB"); // KiB
-            assert_eq!(Ok(((1024_u128).pow(exp)) as u128), parse_size_u128(&s));
+            assert_eq!(Ok((1024_u128).pow(exp)), parse_size_u128(&s));
             let s = format!("{}iB", c.to_lowercase()); // kiB
-            assert_eq!(Ok(((1024_u128).pow(exp)) as u128), parse_size_u128(&s));
+            assert_eq!(Ok((1024_u128).pow(exp)), parse_size_u128(&s));
         }
     }
 
diff --git a/src/uucore/src/lib/parser/shortcut_value_parser.rs b/src/uucore/src/lib/parser/shortcut_value_parser.rs
index 49bb2b62b71..2b94f9b75bc 100644
--- a/src/uucore/src/lib/parser/shortcut_value_parser.rs
+++ b/src/uucore/src/lib/parser/shortcut_value_parser.rs
@@ -163,7 +163,7 @@ mod tests {
         let parser = ShortcutValueParser::new(["abcd"]);
         let cmd = Command::new("cmd");
 
-        let result = parser.parse_ref(&cmd, None, OsStr::from_bytes(&[0xc3 as u8, 0x28 as u8]));
+        let result = parser.parse_ref(&cmd, None, OsStr::from_bytes(&[0xc3, 0x28]));
         assert_eq!(ErrorKind::InvalidUtf8, result.unwrap_err().kind());
     }
 }
diff --git a/src/uucore_procs/Cargo.toml b/src/uucore_procs/Cargo.toml
index f6b92fe6353..2411bb6c166 100644
--- a/src/uucore_procs/Cargo.toml
+++ b/src/uucore_procs/Cargo.toml
@@ -1,7 +1,7 @@
 # spell-checker:ignore uuhelp
 [package]
 name = "uucore_procs"
-version = "0.0.23"
+version = "0.0.24"
 authors = ["Roy Ivy III <rivy.dev@gmail.com>"]
 license = "MIT"
 description = "uutils ~ 'uucore' proc-macros"
@@ -19,4 +19,4 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-uuhelp_parser = { path = "../uuhelp_parser", version = "0.0.23" }
+uuhelp_parser = { path = "../uuhelp_parser", version = "0.0.24" }
diff --git a/src/uuhelp_parser/Cargo.toml b/src/uuhelp_parser/Cargo.toml
index c07bce63160..018aa1d898f 100644
--- a/src/uuhelp_parser/Cargo.toml
+++ b/src/uuhelp_parser/Cargo.toml
@@ -1,7 +1,10 @@
 # spell-checker:ignore uuhelp
 [package]
 name = "uuhelp_parser"
-version = "0.0.23"
+version = "0.0.24"
 edition = "2021"
 license = "MIT"
 description = "A collection of functions to parse the markdown code of help files"
+
+homepage = "https://github.com/uutils/coreutils"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uuhelp_parser"
diff --git a/src/uuhelp_parser/LICENSE b/src/uuhelp_parser/LICENSE
new file mode 120000
index 00000000000..30cff7403da
--- /dev/null
+++ b/src/uuhelp_parser/LICENSE
@@ -0,0 +1 @@
+../../LICENSE
\ No newline at end of file
diff --git a/tests/by-util/test_basenc.rs b/tests/by-util/test_basenc.rs
index 6c71b63f79c..c9e15ef1f61 100644
--- a/tests/by-util/test_basenc.rs
+++ b/tests/by-util/test_basenc.rs
@@ -18,3 +18,16 @@ fn test_z85_not_padded() {
         .fails()
         .stderr_only("basenc: error: invalid input (length must be multiple of 4 characters)\n");
 }
+
+#[test]
+fn test_invalid_input() {
+    let error_message = if cfg!(windows) {
+        "basenc: .: Permission denied\n"
+    } else {
+        "basenc: error: invalid input\n"
+    };
+    new_ucmd!()
+        .args(&["--base32", "."])
+        .fails()
+        .stderr_only(error_message);
+}
diff --git a/tests/by-util/test_chroot.rs b/tests/by-util/test_chroot.rs
index 1fc2231d57a..128d0b812c1 100644
--- a/tests/by-util/test_chroot.rs
+++ b/tests/by-util/test_chroot.rs
@@ -124,7 +124,7 @@ fn test_default_shell() {
     if let Ok(result) = run_ucmd_as_root(&ts, &[dir]) {
         result.stderr_contains(expected);
     } else {
-        print!("TEST SKIPPED");
+        print!("Test skipped; requires root user");
     }
 }
 
diff --git a/tests/by-util/test_cksum.rs b/tests/by-util/test_cksum.rs
index a9d9b272b4c..464de947479 100644
--- a/tests/by-util/test_cksum.rs
+++ b/tests/by-util/test_cksum.rs
@@ -81,15 +81,19 @@ fn test_nonexisting_file() {
 }
 
 #[test]
-fn test_folder() {
+fn test_one_nonexisting_file() {
     let (at, mut ucmd) = at_and_ucmd!();
 
-    let folder_name = "a_folder";
-    at.mkdir(folder_name);
+    at.touch("abc.txt");
+    at.touch("xyz.txt");
 
-    ucmd.arg(folder_name)
-        .succeeds()
-        .stdout_only(format!("4294967295 0 {folder_name}\n"));
+    ucmd.arg("abc.txt")
+        .arg("asdf.txt")
+        .arg("xyz.txt")
+        .fails()
+        .stdout_contains_line("4294967295 0 xyz.txt")
+        .stderr_contains("asdf.txt: No such file or directory")
+        .stdout_contains_line("4294967295 0 abc.txt");
 }
 
 // Make sure crc is correct for files larger than 32 bytes
@@ -228,3 +232,136 @@ fn test_untagged_algorithm_stdin() {
             .stdout_is_fixture(format!("untagged/{algo}_stdin.expected"));
     }
 }
+
+#[test]
+fn test_length_with_wrong_algorithm() {
+    new_ucmd!()
+        .arg("--length=16")
+        .arg("--algorithm=md5")
+        .arg("lorem_ipsum.txt")
+        .fails()
+        .no_stdout()
+        .stderr_contains("cksum: --length is only supported with --algorithm=blake2b")
+        .code_is(1);
+}
+
+#[test]
+fn test_length_not_supported() {
+    new_ucmd!()
+        .arg("--length=15")
+        .arg("lorem_ipsum.txt")
+        .fails()
+        .no_stdout()
+        .stderr_is_fixture("unsupported_length.expected")
+        .code_is(1);
+}
+
+#[test]
+fn test_length() {
+    new_ucmd!()
+        .arg("--length=16")
+        .arg("--algorithm=blake2b")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .succeeds()
+        .stdout_is_fixture("supported_length.expected");
+}
+
+#[test]
+fn test_length_greater_than_512() {
+    new_ucmd!()
+        .arg("--length=1024")
+        .arg("--algorithm=blake2b")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .fails()
+        .no_stdout()
+        .stderr_is_fixture("length_larger_than_512.expected");
+}
+
+#[test]
+fn test_length_is_zero() {
+    new_ucmd!()
+        .arg("--length=0")
+        .arg("--algorithm=blake2b")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .succeeds()
+        .no_stderr()
+        .stdout_is_fixture("length_is_zero.expected");
+}
+
+#[test]
+fn test_raw_single_file() {
+    for algo in ALGOS {
+        new_ucmd!()
+            .arg("--raw")
+            .arg("lorem_ipsum.txt")
+            .arg(format!("--algorithm={algo}"))
+            .succeeds()
+            .no_stderr()
+            .stdout_is_fixture_bytes(format!("raw/{algo}_single_file.expected"));
+    }
+}
+#[test]
+fn test_raw_multiple_files() {
+    new_ucmd!()
+        .arg("--raw")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .fails()
+        .no_stdout()
+        .stderr_contains("cksum: the --raw option is not supported with multiple files")
+        .code_is(1);
+}
+
+#[test]
+fn test_fail_on_folder() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let folder_name = "a_folder";
+    at.mkdir(folder_name);
+
+    ucmd.arg(folder_name)
+        .fails()
+        .no_stdout()
+        .stderr_contains(format!("cksum: {folder_name}: Is a directory"));
+}
+
+#[test]
+fn test_all_algorithms_fail_on_folder() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+
+    let folder_name = "a_folder";
+    at.mkdir(folder_name);
+
+    for algo in ALGOS {
+        scene
+            .ucmd()
+            .arg(format!("--algorithm={algo}"))
+            .arg(folder_name)
+            .fails()
+            .no_stdout()
+            .stderr_contains(format!("cksum: {folder_name}: Is a directory"));
+    }
+}
+
+#[test]
+fn test_folder_and_file() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+
+    let folder_name = "a_folder";
+    at.mkdir(folder_name);
+
+    scene
+        .ucmd()
+        .arg(folder_name)
+        .arg("lorem_ipsum.txt")
+        .fails()
+        .stderr_contains(format!("cksum: {folder_name}: Is a directory"))
+        .stdout_is_fixture("crc_single_file.expected");
+}
diff --git a/tests/by-util/test_cp.rs b/tests/by-util/test_cp.rs
index c8761fab8fb..c0d81d9a915 100644
--- a/tests/by-util/test_cp.rs
+++ b/tests/by-util/test_cp.rs
@@ -2,7 +2,7 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (flags) reflink (fs) tmpfs (linux) rlimit Rlim NOFILE clob btrfs ROOTDIR USERDIR procfs outfile uufs
+// spell-checker:ignore (flags) reflink (fs) tmpfs (linux) rlimit Rlim NOFILE clob btrfs ROOTDIR USERDIR procfs outfile uufs xattrs
 
 use crate::common::util::TestScenario;
 #[cfg(not(windows))]
@@ -13,7 +13,7 @@ use std::os::unix::fs;
 
 #[cfg(unix)]
 use std::os::unix::fs::MetadataExt;
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
 #[cfg(windows)]
 use std::os::windows::fs::symlink_file;
@@ -56,6 +56,8 @@ static TEST_MOUNT_MOUNTPOINT: &str = "mount";
 static TEST_MOUNT_OTHER_FILESYSTEM_FILE: &str = "mount/DO_NOT_copy_me.txt";
 #[cfg(unix)]
 static TEST_NONEXISTENT_FILE: &str = "nonexistent_file.txt";
+#[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
+use crate::common::util::compare_xattrs;
 
 /// Assert that mode, ownership, and permissions of two metadata objects match.
 #[cfg(all(not(windows), not(target_os = "freebsd")))]
@@ -111,10 +113,26 @@ fn test_cp_duplicate_files() {
         .arg(TEST_HELLO_WORLD_SOURCE)
         .arg(TEST_COPY_TO_FOLDER)
         .succeeds()
-        .stderr_contains("specified more than once");
+        .stderr_contains(format!(
+            "source file '{TEST_HELLO_WORLD_SOURCE}' specified more than once"
+        ));
     assert_eq!(at.read(TEST_COPY_TO_FOLDER_FILE), "Hello, World!\n");
 }
 
+#[test]
+fn test_cp_same_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "a";
+
+    at.touch(file);
+
+    ucmd.arg(file)
+        .arg(file)
+        .fails()
+        .code_is(1)
+        .stderr_contains(format!("'{file}' and '{file}' are the same file"));
+}
+
 #[test]
 fn test_cp_multiple_files_target_is_file() {
     new_ucmd!()
@@ -131,7 +149,9 @@ fn test_cp_directory_not_recursive() {
         .arg(TEST_COPY_TO_FOLDER)
         .arg(TEST_HELLO_WORLD_DEST)
         .fails()
-        .stderr_contains("omitting directory");
+        .stderr_is(format!(
+            "cp: -r not specified; omitting directory '{TEST_COPY_TO_FOLDER}'\n"
+        ));
 }
 
 #[test]
@@ -255,6 +275,8 @@ fn test_cp_target_directory_is_file() {
 }
 
 #[test]
+// FixMe: for FreeBSD, flaky test; track repair progress at GH:uutils/coreutils/issue/4725
+#[cfg(not(target_os = "freebsd"))]
 fn test_cp_arg_update_interactive() {
     new_ucmd!()
         .arg(TEST_HELLO_WORLD_SOURCE)
@@ -475,7 +497,7 @@ fn test_cp_arg_interactive() {
 }
 
 #[test]
-#[cfg(not(target_os = "android"))]
+#[cfg(not(any(target_os = "android", target_os = "freebsd")))]
 fn test_cp_arg_interactive_update() {
     // -u -i won't show the prompt to validate the override or not
     // Therefore, the error code will be 0
@@ -527,6 +549,41 @@ fn test_cp_arg_link() {
     assert_eq!(at.metadata(TEST_HELLO_WORLD_SOURCE).st_nlink(), 2);
 }
 
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_arg_link_with_dest_hardlink_to_source() {
+    use std::os::linux::fs::MetadataExt;
+
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+    let hardlink = "hardlink";
+
+    at.touch(file);
+    at.hard_link(file, hardlink);
+
+    ucmd.args(&["--link", file, hardlink]).succeeds();
+
+    assert_eq!(at.metadata(file).st_nlink(), 2);
+    assert!(at.file_exists(file));
+    assert!(at.file_exists(hardlink));
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_arg_link_with_same_file() {
+    use std::os::linux::fs::MetadataExt;
+
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+
+    at.touch(file);
+
+    ucmd.args(&["--link", file, file]).succeeds();
+
+    assert_eq!(at.metadata(file).st_nlink(), 1);
+    assert!(at.file_exists(file));
+}
+
 #[test]
 fn test_cp_arg_symlink() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -655,6 +712,46 @@ fn test_cp_arg_backup() {
     );
 }
 
+#[test]
+fn test_cp_arg_backup_with_dest_a_symlink() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let source = "source";
+    let source_content = "content";
+    let symlink = "symlink";
+    let original = "original";
+    let backup = "symlink~";
+
+    at.write(source, source_content);
+    at.write(original, "original");
+    at.symlink_file(original, symlink);
+
+    ucmd.arg("-b").arg(source).arg(symlink).succeeds();
+
+    assert!(!at.symlink_exists(symlink));
+    assert_eq!(source_content, at.read(symlink));
+    assert!(at.symlink_exists(backup));
+    assert_eq!(original, at.resolve_link(backup));
+}
+
+#[test]
+fn test_cp_arg_backup_with_dest_a_symlink_to_source() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let source = "source";
+    let source_content = "content";
+    let symlink = "symlink";
+    let backup = "symlink~";
+
+    at.write(source, source_content);
+    at.symlink_file(source, symlink);
+
+    ucmd.arg("-b").arg(source).arg(symlink).succeeds();
+
+    assert!(!at.symlink_exists(symlink));
+    assert_eq!(source_content, at.read(symlink));
+    assert!(at.symlink_exists(backup));
+    assert_eq!(source, at.resolve_link(backup));
+}
+
 #[test]
 fn test_cp_arg_backup_with_other_args() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -2377,13 +2474,18 @@ fn test_copy_symlink_force() {
 }
 
 #[test]
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
 fn test_no_preserve_mode() {
     use std::os::unix::prelude::MetadataExt;
 
     use uucore::mode::get_umask;
 
-    const PERMS_ALL: u32 = 0o7777;
+    const PERMS_ALL: u32 = if cfg!(target_os = "freebsd") {
+        // Only the superuser can set the sticky bit on a file.
+        0o6777
+    } else {
+        0o7777
+    };
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.touch("file");
@@ -2403,11 +2505,16 @@ fn test_no_preserve_mode() {
 }
 
 #[test]
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
 fn test_preserve_mode() {
     use std::os::unix::prelude::MetadataExt;
 
-    const PERMS_ALL: u32 = 0o7777;
+    const PERMS_ALL: u32 = if cfg!(target_os = "freebsd") {
+        // Only the superuser can set the sticky bit on a file.
+        0o6777
+    } else {
+        0o7777
+    };
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.touch("file");
@@ -2867,6 +2974,24 @@ fn test_cp_mode_hardlink_no_dereference() {
     assert_eq!(at.read_symlink("z"), "slink");
 }
 
+#[cfg(not(any(windows, target_os = "android")))]
+#[test]
+fn test_remove_destination_with_destination_being_a_hardlink_to_source() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+    let hardlink = "hardlink";
+
+    at.touch(file);
+    at.hard_link(file, hardlink);
+
+    ucmd.args(&["--remove-destination", file, hardlink])
+        .succeeds();
+
+    assert_eq!("", at.resolve_link(hardlink));
+    assert!(at.file_exists(file));
+    assert!(at.file_exists(hardlink));
+}
+
 #[test]
 fn test_remove_destination_with_destination_being_a_symlink_to_source() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -3353,6 +3478,21 @@ fn test_cp_debug_sparse_reflink() {
     }
 }
 
+#[test]
+fn test_cp_debug_no_update() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    at.touch("b");
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--update=none")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("skipped 'b'");
+}
+
 #[test]
 #[cfg(target_os = "linux")]
 fn test_cp_debug_sparse_always() {
@@ -3545,3 +3685,95 @@ fn test_cp_attributes_only() {
     assert_eq!(mode_a, at.metadata(a).mode());
     assert_eq!(mode_b, at.metadata(b).mode());
 }
+
+#[test]
+fn test_cp_seen_file() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+    at.write("a/f", "a");
+    at.write("b/f", "b");
+
+    let result = ts.ucmd().arg("a/f").arg("b/f").arg("c").fails();
+    #[cfg(not(unix))]
+    assert!(result
+        .stderr_str()
+        .contains("will not overwrite just-created 'c\\f' with 'b/f'"));
+    #[cfg(unix)]
+    assert!(result
+        .stderr_str()
+        .contains("will not overwrite just-created 'c/f' with 'b/f'"));
+
+    assert!(at.plus("c").join("f").exists());
+
+    ts.ucmd()
+        .arg("--backup=numbered")
+        .arg("a/f")
+        .arg("b/f")
+        .arg("c")
+        .succeeds();
+    assert!(at.plus("c").join("f").exists());
+    assert!(at.plus("c").join("f.~1~").exists());
+}
+
+#[test]
+fn test_cp_path_ends_with_terminator() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.mkdir("a");
+    ts.ucmd().arg("-r").arg("-T").arg("a").arg("e/").succeeds();
+}
+
+#[test]
+fn test_cp_no_such() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("b");
+    ts.ucmd()
+        .arg("b")
+        .arg("no-such/")
+        .fails()
+        .stderr_is("cp: 'no-such/' is not a directory\n");
+}
+
+#[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
+#[test]
+fn test_acl_preserve() {
+    use std::process::Command;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let path1 = "a";
+    let path2 = "b";
+    let file = "a/file";
+    let file_target = "b/file";
+    at.mkdir(path1);
+    at.mkdir(path2);
+    at.touch(file);
+
+    let path = at.plus_as_string(file);
+    // calling the command directly. xattr requires some dev packages to be installed
+    // and it adds a complex dependency just for a test
+    match Command::new("setfacl")
+        .args(["-m", "group::rwx", &path1])
+        .status()
+        .map(|status| status.code())
+    {
+        Ok(Some(0)) => {}
+        Ok(_) => {
+            println!("test skipped: setfacl failed");
+            return;
+        }
+        Err(e) => {
+            println!("test skipped: setfacl failed with {}", e);
+            return;
+        }
+    }
+
+    scene.ucmd().args(&["-p", &path, path2]).succeeds();
+
+    assert!(compare_xattrs(&file, &file_target));
+}
diff --git a/tests/by-util/test_cut.rs b/tests/by-util/test_cut.rs
index 184e413a867..57e6666d304 100644
--- a/tests/by-util/test_cut.rs
+++ b/tests/by-util/test_cut.rs
@@ -126,7 +126,7 @@ fn test_too_large() {
 }
 
 #[test]
-fn test_specify_delimiter() {
+fn test_delimiter() {
     for param in ["-d", "--delimiter", "--del"] {
         new_ucmd!()
             .args(&[param, ":", "-f", COMPLEX_SEQUENCE.sequence, INPUT])
@@ -135,6 +135,15 @@ fn test_specify_delimiter() {
     }
 }
 
+#[test]
+fn test_delimiter_with_more_than_one_char() {
+    new_ucmd!()
+        .args(&["-d", "ab", "-f1"])
+        .fails()
+        .stderr_contains("cut: the delimiter must be a single character")
+        .no_stdout();
+}
+
 #[test]
 fn test_output_delimiter() {
     // we use -d here to ensure output delimiter
@@ -246,3 +255,13 @@ fn test_equal_as_delimiter3() {
         .succeeds()
         .stdout_only_bytes("abZcd\n");
 }
+
+#[test]
+fn test_multiple() {
+    let result = new_ucmd!()
+        .args(&["-f2", "-d:", "-d="])
+        .pipe_in("a=b\n")
+        .succeeds();
+    assert_eq!(result.stdout_str(), "b\n");
+    assert_eq!(result.stderr_str(), "");
+}
diff --git a/tests/by-util/test_dd.rs b/tests/by-util/test_dd.rs
index f560e35261b..93cfee06718 100644
--- a/tests/by-util/test_dd.rs
+++ b/tests/by-util/test_dd.rs
@@ -2,7 +2,7 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, availible, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat abcdefghijklm abcdefghi nabcde nabcdefg abcdefg
+// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, availible, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat abcdefghijklm abcdefghi nabcde nabcdefg abcdefg fifoname
 
 #[cfg(unix)]
 use crate::common::util::run_ucmd_as_root_with_stdin_stdout;
@@ -15,6 +15,13 @@ use regex::Regex;
 use std::fs::{File, OpenOptions};
 use std::io::{BufReader, Read, Write};
 use std::path::PathBuf;
+#[cfg(all(
+    unix,
+    not(target_os = "macos"),
+    not(target_os = "freebsd"),
+    feature = "printf"
+))]
+use std::process::{Command, Stdio};
 #[cfg(not(windows))]
 use std::thread::sleep;
 #[cfg(not(windows))]
@@ -1470,7 +1477,7 @@ fn test_seek_output_fifo() {
         .args(&["count=0", "seek=1", "of=fifo", "status=noxfer"])
         .run_no_wait();
 
-    std::fs::write(at.plus("fifo"), &vec![0; 512]).unwrap();
+    std::fs::write(at.plus("fifo"), vec![0; 512]).unwrap();
 
     child
         .wait()
@@ -1492,7 +1499,7 @@ fn test_skip_input_fifo() {
         .args(&["count=0", "skip=1", "if=fifo", "status=noxfer"])
         .run_no_wait();
 
-    std::fs::write(at.plus("fifo"), &vec![0; 512]).unwrap();
+    std::fs::write(at.plus("fifo"), vec![0; 512]).unwrap();
 
     child
         .wait()
@@ -1558,7 +1565,7 @@ fn test_skip_past_dev() {
         result.stderr_contains("0+0 records out");
         result.code_is(1);
     } else {
-        print!("TEST SKIPPED");
+        print!("Test skipped; requires root user");
     }
 }
 
@@ -1579,6 +1586,90 @@ fn test_seek_past_dev() {
         result.stderr_contains("0+0 records out");
         result.code_is(1);
     } else {
-        print!("TEST SKIPPED");
+        print!("Test skipped; requires root user");
     }
 }
+
+#[test]
+#[cfg(all(
+    unix,
+    not(target_os = "macos"),
+    not(target_os = "freebsd"),
+    feature = "printf"
+))]
+fn test_reading_partial_blocks_from_fifo() {
+    // Create the FIFO.
+    let ts = TestScenario::new(util_name!());
+    let at = ts.fixtures.clone();
+    at.mkfifo("fifo");
+    let fifoname = at.plus_as_string("fifo");
+
+    // Start a `dd` process that reads from the fifo (so it will wait
+    // until the writer process starts).
+    let mut reader_command = Command::new(TESTS_BINARY);
+    let child = reader_command
+        .args(["dd", "ibs=3", "obs=3", &format!("if={}", fifoname)])
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+
+    // Start different processes to write to the FIFO, with a small
+    // pause in between.
+    let mut writer_command = Command::new("sh");
+    writer_command
+        .args([
+            "-c",
+            &format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {}", fifoname),
+        ])
+        .spawn()
+        .unwrap();
+
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.stdout, b"abcd");
+    let expected = b"0+2 records in\n1+1 records out\n4 bytes copied";
+    assert!(output.stderr.starts_with(expected));
+}
+
+#[test]
+#[cfg(all(
+    unix,
+    not(target_os = "macos"),
+    not(target_os = "freebsd"),
+    feature = "printf"
+))]
+fn test_reading_partial_blocks_from_fifo_unbuffered() {
+    // Create the FIFO.
+    let ts = TestScenario::new(util_name!());
+    let at = ts.fixtures.clone();
+    at.mkfifo("fifo");
+    let fifoname = at.plus_as_string("fifo");
+
+    // Start a `dd` process that reads from the fifo (so it will wait
+    // until the writer process starts).
+    //
+    // `bs=N` takes precedence over `ibs=N` and `obs=N`.
+    let mut reader_command = Command::new(TESTS_BINARY);
+    let child = reader_command
+        .args(["dd", "bs=3", "ibs=1", "obs=1", &format!("if={}", fifoname)])
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+
+    // Start different processes to write to the FIFO, with a small
+    // pause in between.
+    let mut writer_command = Command::new("sh");
+    writer_command
+        .args([
+            "-c",
+            &format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {}", fifoname),
+        ])
+        .spawn()
+        .unwrap();
+
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.stdout, b"abcd");
+    let expected = b"0+2 records in\n0+2 records out\n4 bytes copied";
+    assert!(output.stderr.starts_with(expected));
+}
diff --git a/tests/by-util/test_df.rs b/tests/by-util/test_df.rs
index 227121ef4df..0276f18c3c1 100644
--- a/tests/by-util/test_df.rs
+++ b/tests/by-util/test_df.rs
@@ -422,7 +422,11 @@ fn test_total_label_in_correct_column() {
 #[test]
 fn test_use_percentage() {
     let output = new_ucmd!()
-        .args(&["--total", "--output=used,avail,pcent"])
+        // set block size = 1, otherwise the returned values for
+        // "used" and "avail" will be rounded. And using them to calculate
+        // the "percentage" values might lead to a mismatch with the returned
+        // "percentage" values.
+        .args(&["--total", "--output=used,avail,pcent", "--block-size=1"])
         .succeeds()
         .stdout_move_str();
 
diff --git a/tests/by-util/test_dircolors.rs b/tests/by-util/test_dircolors.rs
index d4fa0a3b0a3..4a256352c76 100644
--- a/tests/by-util/test_dircolors.rs
+++ b/tests/by-util/test_dircolors.rs
@@ -159,6 +159,18 @@ fn test_quoting() {
         .no_stderr();
 }
 
+/*
+#[test]
+fn test_print_ls_colors() {
+    new_ucmd!()
+        .pipe_in("OWT 40;33\n")
+        .args(&["--print-ls-colors"])
+        .succeeds()
+        .stdout_is("\x1B[40;33mtw\t40;33\x1B[0m\n")
+        .no_stderr();
+}
+*/
+
 #[test]
 fn test_extra_operand() {
     new_ucmd!()
diff --git a/tests/by-util/test_du.rs b/tests/by-util/test_du.rs
index c07de2851ee..9e4622c31a8 100644
--- a/tests/by-util/test_du.rs
+++ b/tests/by-util/test_du.rs
@@ -3,11 +3,9 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (paths) sublink subwords azerty azeaze xcwww azeaz amaz azea qzerty tazerty tsublink
+// spell-checker:ignore (paths) sublink subwords azerty azeaze xcwww azeaz amaz azea qzerty tazerty tsublink testfile1 testfile2 filelist testdir testfile
 #[cfg(not(windows))]
 use regex::Regex;
-#[cfg(not(windows))]
-use std::io::Write;
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use crate::common::util::expected_result;
@@ -22,24 +20,54 @@ const SUB_LINK: &str = "subdir/links/sublink.txt";
 
 #[test]
 fn test_du_basics() {
-    new_ucmd!().succeeds().no_stderr();
+    let ts = TestScenario::new(util_name!());
+
+    let result = ts.ucmd().succeeds();
+
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    {
+        let result_reference = unwrap_or_return!(expected_result(&ts, &[]));
+        if result_reference.succeeded() {
+            assert_eq!(result.stdout_str(), result_reference.stdout_str());
+            return;
+        }
+    }
+    _du_basics(result.stdout_str());
 }
+
 #[cfg(target_vendor = "apple")]
 fn _du_basics(s: &str) {
-    let answer = "32\t./subdir
-8\t./subdir/deeper
-24\t./subdir/links
-40\t.
-";
+    let answer = concat!(
+        "4\t./subdir/deeper/deeper_dir\n",
+        "8\t./subdir/deeper\n",
+        "12\t./subdir/links\n",
+        "20\t./subdir\n",
+        "24\t.\n"
+    );
+    assert_eq!(s, answer);
+}
+
+#[cfg(target_os = "windows")]
+fn _du_basics(s: &str) {
+    let answer = concat!(
+        "0\t.\\subdir\\deeper\\deeper_dir\n",
+        "0\t.\\subdir\\deeper\n",
+        "8\t.\\subdir\\links\n",
+        "8\t.\\subdir\n",
+        "8\t.\n"
+    );
     assert_eq!(s, answer);
 }
-#[cfg(not(target_vendor = "apple"))]
+
+#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows"),))]
 fn _du_basics(s: &str) {
-    let answer = "28\t./subdir
-8\t./subdir/deeper
-16\t./subdir/links
-36\t.
-";
+    let answer = concat!(
+        "8\t./subdir/deeper/deeper_dir\n",
+        "16\t./subdir/deeper\n",
+        "16\t./subdir/links\n",
+        "36\t./subdir\n",
+        "44\t.\n"
+    );
     assert_eq!(s, answer);
 }
 
@@ -118,6 +146,32 @@ fn test_du_invalid_size() {
     }
 }
 
+#[test]
+fn test_du_with_posixly_correct() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let dir = "a";
+
+    at.mkdir(dir);
+    at.write(&format!("{dir}/file"), "some content");
+
+    let expected = ts
+        .ucmd()
+        .arg(dir)
+        .arg("--block-size=512")
+        .succeeds()
+        .stdout_move_str();
+
+    let result = ts
+        .ucmd()
+        .arg(dir)
+        .env("POSIXLY_CORRECT", "1")
+        .succeeds()
+        .stdout_move_str();
+
+    assert_eq!(expected, result);
+}
+
 #[test]
 fn test_du_basics_bad_name() {
     new_ucmd!()
@@ -292,12 +346,10 @@ fn test_du_dereference_args() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
 
-    at.mkdir_all("subdir");
-    let mut file1 = at.make_file("subdir/file-ignore1");
-    file1.write_all(b"azeaze").unwrap();
-    let mut file2 = at.make_file("subdir/file-ignore1");
-    file2.write_all(b"amaz?ng").unwrap();
-    at.symlink_dir("subdir", "sublink");
+    at.mkdir("dir");
+    at.write("dir/file-ignore1", "azeaze");
+    at.write("dir/file-ignore2", "amaz?ng");
+    at.symlink_dir("dir", "sublink");
 
     for arg in ["-D", "-H", "--dereference-args"] {
         let result = ts.ucmd().arg(arg).arg("-s").arg("sublink").succeeds();
@@ -365,12 +417,19 @@ fn test_du_no_dereference() {
             .stdout_does_not_contain(symlink);
 
         // ensure dereference "wins"
-        ts.ucmd()
-            .arg(arg)
-            .arg("--dereference")
-            .succeeds()
-            .stdout_contains(symlink)
-            .stdout_does_not_contain(dir);
+        let result = ts.ucmd().arg(arg).arg("--dereference").succeeds();
+
+        #[cfg(target_os = "linux")]
+        {
+            let result_reference = unwrap_or_return!(expected_result(&ts, &[arg, "--dereference"]));
+
+            if result_reference.succeeded() {
+                assert_eq!(result.stdout_str(), result_reference.stdout_str());
+            }
+        }
+
+        #[cfg(not(target_os = "linux"))]
+        result.stdout_contains(symlink).stdout_does_not_contain(dir);
     }
 }
 
@@ -393,12 +452,13 @@ fn test_du_inodes_basic() {
 fn _du_inodes_basic(s: &str) {
     assert_eq!(
         s,
-        "2\t.\\subdir\\deeper\\deeper_dir
-4\t.\\subdir\\deeper
-3\t.\\subdir\\links
-8\t.\\subdir
-11\t.
-"
+        concat!(
+            "2\t.\\subdir\\deeper\\deeper_dir\n",
+            "4\t.\\subdir\\deeper\n",
+            "3\t.\\subdir\\links\n",
+            "8\t.\\subdir\n",
+            "11\t.\n",
+        )
     );
 }
 
@@ -406,12 +466,13 @@ fn _du_inodes_basic(s: &str) {
 fn _du_inodes_basic(s: &str) {
     assert_eq!(
         s,
-        "2\t./subdir/deeper/deeper_dir
-4\t./subdir/deeper
-3\t./subdir/links
-8\t./subdir
-11\t.
-"
+        concat!(
+            "2\t./subdir/deeper/deeper_dir\n",
+            "4\t./subdir/deeper\n",
+            "3\t./subdir/links\n",
+            "8\t./subdir\n",
+            "11\t.\n",
+        )
     );
 }
 
@@ -441,6 +502,7 @@ fn test_du_inodes() {
     }
 }
 
+#[cfg(not(target_os = "android"))]
 #[test]
 fn test_du_inodes_with_count_links() {
     let ts = TestScenario::new(util_name!());
@@ -785,10 +847,8 @@ fn test_du_exclude_mix() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
 
-    let mut file1 = at.make_file("file-ignore1");
-    file1.write_all(b"azeaze").unwrap();
-    let mut file2 = at.make_file("file-ignore2");
-    file2.write_all(b"amaz?ng").unwrap();
+    at.write("file-ignore1", "azeaze");
+    at.write("file-ignore2", "amaz?ng");
 
     at.mkdir_all("azerty/xcwww/azeaze");
     at.mkdir_all("azerty/xcwww/qzerty");
@@ -920,10 +980,135 @@ fn test_du_symlink_multiple_fail() {
     let at = &ts.fixtures;
 
     at.symlink_file("non-existing.txt", "target.txt");
-    let mut file1 = at.make_file("file1");
-    file1.write_all(b"azeaze").unwrap();
+    at.write("file1", "azeaze");
 
     let result = ts.ucmd().arg("-L").arg("target.txt").arg("file1").fails();
     assert_eq!(result.code(), 1);
     result.stdout_contains("4\tfile1\n");
 }
+
+#[test]
+// Disable on Windows because of different path separators and handling of null characters
+#[cfg(not(target_os = "windows"))]
+fn test_du_files0_from() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.write("testfile1", "content1");
+    at.write("testfile2", "content2");
+
+    at.mkdir("testdir");
+    at.write("testdir/testfile3", "content3");
+
+    at.write("filelist", "testfile1\0testfile2\0testdir\0");
+
+    ts.ucmd()
+        .arg("--files0-from=filelist")
+        .succeeds()
+        .stdout_contains("testfile1")
+        .stdout_contains("testfile2")
+        .stdout_contains("testdir");
+}
+
+#[test]
+fn test_du_files0_from_ignore_duplicate_file_names() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let file = "testfile";
+
+    at.touch(file);
+    at.write("filelist", &format!("{file}\0{file}\0"));
+
+    ts.ucmd()
+        .arg("--files0-from=filelist")
+        .succeeds()
+        .stdout_is(format!("0\t{file}\n"));
+}
+
+#[test]
+fn test_du_files0_from_with_invalid_zero_length_file_names() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.touch("testfile");
+
+    at.write("filelist", "\0testfile\0\0");
+
+    ts.ucmd()
+        .arg("--files0-from=filelist")
+        .fails()
+        .code_is(1)
+        .stdout_contains("testfile")
+        .stderr_contains("filelist:1: invalid zero-length file name")
+        .stderr_contains("filelist:3: invalid zero-length file name");
+}
+
+#[test]
+fn test_du_files0_from_stdin() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.write("testfile1", "content1");
+    at.write("testfile2", "content2");
+
+    let input = "testfile1\0testfile2\0";
+
+    ts.ucmd()
+        .arg("--files0-from=-")
+        .pipe_in(input)
+        .succeeds()
+        .stdout_contains("testfile1")
+        .stdout_contains("testfile2");
+}
+
+#[test]
+fn test_du_files0_from_stdin_ignore_duplicate_file_names() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let file = "testfile";
+
+    at.touch(file);
+
+    let input = format!("{file}\0{file}");
+
+    ts.ucmd()
+        .arg("--files0-from=-")
+        .pipe_in(input)
+        .succeeds()
+        .stdout_is(format!("0\t{file}\n"));
+}
+
+#[test]
+fn test_du_files0_from_stdin_with_invalid_zero_length_file_names() {
+    new_ucmd!()
+        .arg("--files0-from=-")
+        .pipe_in("\0\0")
+        .fails()
+        .code_is(1)
+        .stderr_contains("-:1: invalid zero-length file name")
+        .stderr_contains("-:2: invalid zero-length file name");
+}
+
+#[test]
+fn test_du_files0_from_dir() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("dir");
+
+    let result = ts.ucmd().arg("--files0-from=dir").fails();
+    assert_eq!(result.stderr_str(), "du: dir: read error: Is a directory\n");
+}
+
+#[test]
+fn test_du_files0_from_combined() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("dir");
+
+    let result = ts.ucmd().arg("--files0-from=-").arg("foo").fails();
+    let stderr = result.stderr_str();
+
+    assert!(stderr.contains("file operands cannot be combined with --files0-from"));
+}
diff --git a/tests/by-util/test_echo.rs b/tests/by-util/test_echo.rs
index 875ff66cb14..ac6bd74d1e0 100644
--- a/tests/by-util/test_echo.rs
+++ b/tests/by-util/test_echo.rs
@@ -117,6 +117,19 @@ fn test_escape_newline() {
         .stdout_only("\na\n");
 }
 
+#[test]
+fn test_escape_override() {
+    new_ucmd!()
+        .args(&["-e", "-E", "\\na"])
+        .succeeds()
+        .stdout_only("\\na\n");
+
+    new_ucmd!()
+        .args(&["-E", "-e", "\\na"])
+        .succeeds()
+        .stdout_only("\na\n");
+}
+
 #[test]
 fn test_escape_no_further_output() {
     new_ucmd!()
diff --git a/tests/by-util/test_expand.rs b/tests/by-util/test_expand.rs
index f6802358cc3..c420f5ad5b9 100644
--- a/tests/by-util/test_expand.rs
+++ b/tests/by-util/test_expand.rs
@@ -392,3 +392,28 @@ fn test_comma_with_plus_4() {
         //          01234567890
         .stdout_is("a  b    c");
 }
+
+#[test]
+fn test_args_override() {
+    new_ucmd!()
+        .args(&["-i", "-i", "with-trailing-tab.txt"])
+        .run()
+        .stdout_is(
+            "// !note: file contains significant whitespace
+// * indentation uses <TAB> characters
+int main() {
+        // * next line has both a leading & trailing tab
+        // with tabs=>	
+        return 0;
+}
+",
+        );
+}
+
+#[test]
+fn test_expand_directory() {
+    new_ucmd!()
+        .args(&["."])
+        .fails()
+        .stderr_contains("expand: .: Is a directory");
+}
diff --git a/tests/by-util/test_expr.rs b/tests/by-util/test_expr.rs
index 28cfcf0ec90..7c9290d6a49 100644
--- a/tests/by-util/test_expr.rs
+++ b/tests/by-util/test_expr.rs
@@ -6,6 +6,14 @@
 
 use crate::common::util::TestScenario;
 
+#[test]
+fn test_no_arguments() {
+    new_ucmd!()
+        .fails()
+        .code_is(2)
+        .usage_error("missing operand");
+}
+
 #[test]
 fn test_simple_values() {
     // null or 0 => EXIT_VALUE == 1
@@ -100,6 +108,12 @@ fn test_parenthesis() {
         .args(&["(", "1", "+", "1", ")", "*", "2"])
         .succeeds()
         .stdout_only("4\n");
+
+    new_ucmd!()
+        .args(&["1", "(", ")"])
+        .fails()
+        .code_is(2)
+        .stderr_only("expr: syntax error: unexpected argument '('\n");
 }
 
 #[test]
@@ -221,6 +235,12 @@ fn test_index() {
         .args(&["index", "αbcdef_f", "f"])
         .succeeds()
         .stdout_only("6\n");
+
+    new_ucmd!()
+        .args(&["αbcdef", "index", "α"])
+        .fails()
+        .code_is(2)
+        .stderr_only("expr: syntax error: unexpected argument 'index'\n");
 }
 
 #[test]
@@ -234,6 +254,12 @@ fn test_length() {
         .args(&["length", "abcdef"])
         .succeeds()
         .stdout_only("6\n");
+
+    new_ucmd!()
+        .args(&["abcdef", "length"])
+        .fails()
+        .code_is(2)
+        .stderr_only("expr: syntax error: unexpected argument 'length'\n");
 }
 
 #[test]
@@ -263,6 +289,10 @@ fn test_regex() {
         .args(&["-5", ":", "-\\{0,1\\}[0-9]*$"])
         .succeeds()
         .stdout_only("2\n");
+    new_ucmd!()
+        .args(&["abc", ":", "bc"])
+        .fails()
+        .stdout_only("0\n");
 }
 
 #[test]
@@ -271,6 +301,12 @@ fn test_substr() {
         .args(&["substr", "abc", "1", "1"])
         .succeeds()
         .stdout_only("a\n");
+
+    new_ucmd!()
+        .args(&["abc", "substr", "1", "1"])
+        .fails()
+        .code_is(2)
+        .stderr_only("expr: syntax error: unexpected argument 'substr'\n");
 }
 
 #[test]
@@ -326,3 +362,11 @@ fn test_invalid_syntax() {
             .stderr_contains("syntax error");
     }
 }
+
+#[test]
+fn test_num_str_comparison() {
+    new_ucmd!()
+        .args(&["1a", "<", "1", "+", "1"])
+        .succeeds()
+        .stdout_is("1\n");
+}
diff --git a/tests/by-util/test_factor.rs b/tests/by-util/test_factor.rs
index 3326a1ace71..57a2dae0998 100644
--- a/tests/by-util/test_factor.rs
+++ b/tests/by-util/test_factor.rs
@@ -1258,3 +1258,8 @@ const PRIMES50: &[u64] = &[
     1125899906841623,
     1125899906841613,
 ];
+
+#[test]
+fn fails_on_directory() {
+    new_ucmd!().pipe_in(".").fails();
+}
diff --git a/tests/by-util/test_hashsum.rs b/tests/by-util/test_hashsum.rs
index 31471495b07..7edd387c326 100644
--- a/tests/by-util/test_hashsum.rs
+++ b/tests/by-util/test_hashsum.rs
@@ -371,3 +371,18 @@ fn test_tag() {
             "SHA256 (foobar) = 1f2ec52b774368781bed1d1fb140a92e0eb6348090619c9291f9a5a3c8e8d151\n",
         );
 }
+
+#[test]
+#[cfg(not(windows))]
+fn test_with_escape_filename() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+    let filename = "a\nb";
+    at.touch(filename);
+    let result = scene.ccmd("md5sum").arg("--text").arg(filename).succeeds();
+    let stdout = result.stdout_str();
+    println!("stdout {}", stdout);
+    assert!(stdout.starts_with('\\'));
+    assert!(stdout.trim().ends_with("a\\nb"));
+}
diff --git a/tests/by-util/test_head.rs b/tests/by-util/test_head.rs
index f536b26ae08..0b0e98aa122 100644
--- a/tests/by-util/test_head.rs
+++ b/tests/by-util/test_head.rs
@@ -330,7 +330,7 @@ fn test_head_invalid_num() {
             new_ucmd!()
                 .args(&["-c", size])
                 .fails()
-                .stderr_is("head: out of range integral type conversion attempted: number of bytes is too large\n");
+                .stderr_is("head: out of range integral type conversion attempted: number of -bytes or -lines is too large\n");
         }
     }
     new_ucmd!()
@@ -378,3 +378,65 @@ fn test_presume_input_pipe_5_chars() {
         .run()
         .stdout_is_fixture("lorem_ipsum_5_chars.expected");
 }
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_bytes_proc_fs_version() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["-c", "-1", "/proc/version"];
+    let result = ts.ucmd().args(&args).succeeds();
+    assert!(!result.stdout().is_empty());
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_bytes_proc_fs_modules() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["-c", "-1", "/proc/modules"];
+    let result = ts.ucmd().args(&args).succeeds();
+    assert!(!result.stdout().is_empty());
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_lines_proc_fs_modules() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["--lines", "-1", "/proc/modules"];
+    let result = ts.ucmd().args(&args).succeeds();
+    assert!(!result.stdout().is_empty());
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_bytes_sys_kernel_profiling() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["-c", "-1", "/sys/kernel/profiling"];
+    let result = ts.ucmd().args(&args).succeeds();
+    let stdout_str = result.stdout_str();
+    assert_eq!(stdout_str.len(), 1);
+    assert!(stdout_str == "0" || stdout_str == "1");
+}
diff --git a/tests/by-util/test_hostname.rs b/tests/by-util/test_hostname.rs
index 84cb73e2ecf..972ec4aabbf 100644
--- a/tests/by-util/test_hostname.rs
+++ b/tests/by-util/test_hostname.rs
@@ -14,8 +14,8 @@ fn test_hostname() {
     assert!(ls_default_res.stdout().len() >= ls_domain_res.stdout().len());
 }
 
-// FixME: fails for "MacOS" and "freebsd" "failed to lookup address information: Name does not resolve"
-#[cfg(not(any(target_os = "macos", target_os = "freebsd")))]
+// FixME: fails for "MacOS", "freebsd" and "openbsd" "failed to lookup address information: Name does not resolve"
+#[cfg(not(any(target_os = "macos", target_os = "freebsd", target_os = "openbsd")))]
 #[test]
 fn test_hostname_ip() {
     let result = new_ucmd!().arg("-i").succeeds();
diff --git a/tests/by-util/test_install.rs b/tests/by-util/test_install.rs
index 7387748c619..6b1d76e5527 100644
--- a/tests/by-util/test_install.rs
+++ b/tests/by-util/test_install.rs
@@ -4,9 +4,10 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (words) helloworld nodir objdump n'source
 
-use crate::common::util::{is_ci, TestScenario};
+use crate::common::util::{is_ci, run_ucmd_as_root, TestScenario};
 use filetime::FileTime;
-use std::os::unix::fs::PermissionsExt;
+use std::fs;
+use std::os::unix::fs::{MetadataExt, PermissionsExt};
 #[cfg(not(any(windows, target_os = "freebsd")))]
 use std::process::Command;
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -674,6 +675,46 @@ fn test_install_and_strip_with_program() {
     assert!(!stdout.contains(STRIP_SOURCE_FILE_SYMBOL));
 }
 
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+// FixME: Freebsd fails on 'No such file or directory'
+#[cfg(not(target_os = "freebsd"))]
+fn test_install_and_strip_with_program_hyphen() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+    let content = r#"#!/bin/sh
+    printf -- '%s\n' "$1" | grep '^[^-]'
+    "#;
+    at.write("no-hyphen", content);
+    scene.ccmd("chmod").arg("+x").arg("no-hyphen").succeeds();
+
+    at.touch("src");
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--strip-program")
+        .arg("./no-hyphen")
+        .arg("--")
+        .arg("src")
+        .arg("-dest")
+        .succeeds()
+        .no_stderr()
+        .stdout_is("./-dest\n");
+
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--strip-program")
+        .arg("./no-hyphen")
+        .arg("--")
+        .arg("src")
+        .arg("./-dest")
+        .succeeds()
+        .no_stderr()
+        .stdout_is("./-dest\n");
+}
+
 #[test]
 #[cfg(not(windows))]
 fn test_install_and_strip_with_invalid_program() {
@@ -1538,3 +1579,80 @@ fn test_install_compare_option() {
         .code_is(1)
         .stderr_contains("Options --compare and --strip are mutually exclusive");
 }
+
+#[test]
+// Matches part of tests/install/basic-1
+fn test_t_exist_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source1 = "file";
+    let target_dir = "sub4/";
+    let target_file = "sub4/file_exists";
+
+    at.touch(source1);
+    at.mkdir(target_dir);
+    at.touch(target_file);
+
+    scene
+        .ucmd()
+        .arg("-t")
+        .arg(target_file)
+        .arg("-Dv")
+        .arg(source1)
+        .fails()
+        .stderr_contains("failed to access 'sub4/file_exists': Not a directory");
+}
+
+#[test]
+fn test_target_file_ends_with_slash() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source = "source_file";
+    let target_dir = "dir";
+    let target_file = "dir/target_file";
+    let target_file_slash = format!("{}/", target_file);
+
+    at.touch(source);
+    at.mkdir(target_dir);
+    at.touch(target_file);
+
+    scene
+        .ucmd()
+        .arg("-t")
+        .arg(target_file_slash)
+        .arg("-D")
+        .arg(source)
+        .fails()
+        .stderr_contains("failed to access 'dir/target_file/': Not a directory");
+}
+
+#[test]
+fn test_install_root_combined() {
+    let ts = TestScenario::new(util_name!());
+    let at = ts.fixtures.clone();
+    at.touch("a");
+    at.touch("c");
+
+    let run_and_check = |args: &[&str], target: &str, expected_uid: u32, expected_gid: u32| {
+        if let Ok(result) = run_ucmd_as_root(&ts, args) {
+            result.success();
+            assert!(at.file_exists(target));
+
+            let metadata = fs::metadata(at.plus(target)).unwrap();
+            assert_eq!(metadata.uid(), expected_uid);
+            assert_eq!(metadata.gid(), expected_gid);
+        } else {
+            print!("Test skipped; requires root user");
+        }
+    };
+
+    run_and_check(&["-Cv", "-o1", "-g1", "a", "b"], "b", 1, 1);
+    run_and_check(&["-Cv", "-o2", "-g1", "a", "b"], "b", 2, 1);
+    run_and_check(&["-Cv", "-o2", "-g2", "a", "b"], "b", 2, 2);
+
+    run_and_check(&["-Cv", "-o2", "c", "d"], "d", 2, 0);
+    run_and_check(&["-Cv", "c", "d"], "d", 0, 0);
+    run_and_check(&["-Cv", "c", "d"], "d", 0, 0);
+}
diff --git a/tests/by-util/test_ln.rs b/tests/by-util/test_ln.rs
index dc31f726116..b315630ce4e 100644
--- a/tests/by-util/test_ln.rs
+++ b/tests/by-util/test_ln.rs
@@ -719,3 +719,50 @@ fn test_symlink_remove_existing_same_src_and_dest() {
     assert!(at.file_exists("a") && !at.symlink_exists("a"));
     assert_eq!(at.read("a"), "sample");
 }
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_ln_seen_file() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+    at.write("a/f", "a");
+    at.write("b/f", "b");
+
+    let result = ts.ucmd().arg("a/f").arg("b/f").arg("c").fails();
+
+    #[cfg(not(unix))]
+    assert!(result
+        .stderr_str()
+        .contains("will not overwrite just-created 'c\\f' with 'b/f'"));
+    #[cfg(unix)]
+    assert!(result
+        .stderr_str()
+        .contains("will not overwrite just-created 'c/f' with 'b/f'"));
+
+    assert!(at.plus("c").join("f").exists());
+    // b/f still exists
+    assert!(at.plus("b").join("f").exists());
+    // a/f still exists
+    assert!(at.plus("a").join("f").exists());
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt;
+        // Check inode numbers
+        let inode_a_f = at.plus("a").join("f").metadata().unwrap().ino();
+        let inode_b_f = at.plus("b").join("f").metadata().unwrap().ino();
+        let inode_c_f = at.plus("c").join("f").metadata().unwrap().ino();
+
+        assert_eq!(
+            inode_a_f, inode_c_f,
+            "Inode numbers of a/f and c/f should be equal"
+        );
+        assert_ne!(
+            inode_b_f, inode_c_f,
+            "Inode numbers of b/f and c/f should not be equal"
+        );
+    }
+}
diff --git a/tests/by-util/test_ls.rs b/tests/by-util/test_ls.rs
index cdd0292e1f2..1262c2ab9ec 100644
--- a/tests/by-util/test_ls.rs
+++ b/tests/by-util/test_ls.rs
@@ -2,7 +2,7 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile tabsize aaaaaaaa bbbb cccc dddddddd ncccc neee naaaaa nbcdef nfffff dired subdired tmpfs
+// spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile tabsize aaaaaaaa bbbb cccc dddddddd ncccc neee naaaaa nbcdef nfffff dired subdired tmpfs mdir COLORTERM mexe
 
 #[cfg(any(unix, feature = "feat_selinux"))]
 use crate::common::util::expected_result;
@@ -864,11 +864,11 @@ fn test_ls_zero() {
         .succeeds()
         .stdout_only("\"0-test-zero\"\x00\"2-test-zero\"\x00\"3-test-zero\"\x00");
 
-    scene
-        .ucmd()
-        .args(&["--zero", "--color=always"])
-        .succeeds()
-        .stdout_only("\x1b[1;34m0-test-zero\x1b[0m\x002-test-zero\x003-test-zero\x00");
+    let result = scene.ucmd().args(&["--zero", "--color=always"]).succeeds();
+    assert_eq!(
+        result.stdout_str(),
+        "\u{1b}[0m\u{1b}[01;34m0-test-zero\x1b[0m\x002-test-zero\x003-test-zero\x00"
+    );
 
     scene
         .ucmd()
@@ -921,12 +921,9 @@ fn test_ls_zero() {
                 "\"0-test-zero\"\x00\"1\\ntest-zero\"\x00\"2-test-zero\"\x00\"3-test-zero\"\x00",
             );
 
-        scene
-            .ucmd()
-            .args(&["--zero", "--color=always"])
-            .succeeds()
-            .stdout_only(
-                "\x1b[1;34m0-test-zero\x1b[0m\x001\ntest-zero\x002-test-zero\x003-test-zero\x00",
+        let result = scene.ucmd().args(&["--zero", "--color=always"]).succeeds();
+        assert_eq!(result.stdout_str(),
+                "\u{1b}[0m\u{1b}[01;34m0-test-zero\x1b[0m\x001\ntest-zero\x002-test-zero\x003-test-zero\x00",
             );
 
         scene
@@ -994,9 +991,9 @@ fn test_ls_long() {
 fn test_ls_long_format() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    at.mkdir(&at.plus_as_string("test-long-dir"));
+    at.mkdir(at.plus_as_string("test-long-dir"));
     at.touch(at.plus_as_string("test-long-dir/test-long-file"));
-    at.mkdir(&at.plus_as_string("test-long-dir/test-long-dir"));
+    at.mkdir(at.plus_as_string("test-long-dir/test-long-dir"));
 
     for arg in LONG_ARGS {
         // Assuming sane username do not have spaces within them.
@@ -1023,6 +1020,21 @@ fn test_ls_long_format() {
     ).unwrap());
 }
 
+#[test]
+fn test_ls_long_padding_of_size_column_with_multiple_files() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("dir");
+    at.touch("dir/a");
+    at.touch("dir/b");
+
+    ucmd.arg("-l")
+        .arg("dir")
+        .succeeds()
+        .stdout_contains(" 0 ")
+        .stdout_does_not_contain("  0 ");
+}
+
 /// This test tests `ls -laR --color`.
 /// This test is mainly about coloring, but, the recursion, symlink `->` processing,
 /// and `.` and `..` being present in `-a` all need to work for the test to pass.
@@ -1187,12 +1199,21 @@ fn test_ls_long_symlink_color() {
     }
 
     fn capture_colored_string(input: &str) -> (Color, Name) {
-        let colored_name = Regex::new(r"\x1b\[([0-9;]+)m(.+)\x1b\[0m").unwrap();
+        // Input can be:
+        // \u{1b}[0m\u{1b}[01;36mln-dir3\u{1b}[0m
+        // \u{1b}[0m\u{1b}[01;34m./dir1/dir2/dir3\u{1b}[0m
+        // \u{1b}[0m\u{1b}[01;36mln-file-invalid\u{1b}[0m
+        // \u{1b}[01;36mdir1/invalid-target\u{1b}[0m
+        let colored_name = Regex::new(r"(?:\x1b\[0m\x1b)?\[([0-9;]+)m(.+)\x1b\[0m").unwrap();
         match colored_name.captures(input) {
-            Some(captures) => (
-                captures.get(1).unwrap().as_str().to_string(),
-                captures.get(2).unwrap().as_str().to_string(),
-            ),
+            Some(captures) => {
+                dbg!(captures.get(1).unwrap().as_str().to_string());
+                dbg!(captures.get(2).unwrap().as_str().to_string());
+                return (
+                    captures.get(1).unwrap().as_str().to_string(),
+                    captures.get(2).unwrap().as_str().to_string(),
+                );
+            }
             None => (String::new(), input.to_string()),
         }
     }
@@ -1971,7 +1992,7 @@ fn test_ls_color() {
         .join("nested_dir")
         .to_string_lossy()
         .to_string();
-    at.mkdir(&nested_dir);
+    at.mkdir(nested_dir);
     at.mkdir("z");
     let nested_file = Path::new("a")
         .join("nested_file")
@@ -1980,9 +2001,9 @@ fn test_ls_color() {
     at.touch(nested_file);
     at.touch("test-color");
 
-    let a_with_colors = "\x1b[1;34ma\x1b[0m";
-    let z_with_colors = "\x1b[1;34mz\x1b[0m";
-    let nested_dir_with_colors = "\x1b[1;34mnested_dir\x1b[0m"; // spell-checker:disable-line
+    let a_with_colors = "\x1b[0m\x1b[01;34ma\x1b[0m";
+    let z_with_colors = "\x1b[01;34mz\x1b[0m\n";
+    let nested_dir_with_colors = "\x1b[0m\x1b[01;34mnested_dir\x1b[0m\x0anested_file"; // spell-checker:disable-line
 
     // Color is disabled by default
     let result = scene.ucmd().succeeds();
@@ -1991,12 +2012,9 @@ fn test_ls_color() {
 
     // Color should be enabled
     for param in ["--color", "--col", "--color=always", "--col=always"] {
-        scene
-            .ucmd()
-            .arg(param)
-            .succeeds()
-            .stdout_contains(a_with_colors)
-            .stdout_contains(z_with_colors);
+        let result = scene.ucmd().arg(param).succeeds();
+        assert!(result.stdout_str().contains(a_with_colors));
+        assert!(result.stdout_str().contains(z_with_colors));
     }
 
     // Color should be disabled
@@ -2005,12 +2023,8 @@ fn test_ls_color() {
     assert!(!result.stdout_str().contains(z_with_colors));
 
     // Nested dir should be shown and colored
-    scene
-        .ucmd()
-        .arg("--color")
-        .arg("a")
-        .succeeds()
-        .stdout_contains(nested_dir_with_colors);
+    let result = scene.ucmd().arg("--color").arg("a").succeeds();
+    assert!(result.stdout_str().contains(nested_dir_with_colors));
 
     // No output
     scene
@@ -2022,13 +2036,18 @@ fn test_ls_color() {
 
     // The colors must not mess up the grid layout
     at.touch("b");
-    scene
+    let result = scene
         .ucmd()
         .arg("--color")
         .arg("-w=15")
         .arg("-C")
-        .succeeds()
-        .stdout_only(format!("{a_with_colors}  test-color\nb  {z_with_colors}\n"));
+        .succeeds();
+    let expected = format!("{}  test-color\x0ab  {}", a_with_colors, z_with_colors);
+    assert_eq!(
+        result.stdout_str().escape_default().to_string(),
+        expected.escape_default().to_string()
+    );
+    assert_eq!(result.stdout_str(), expected);
 }
 
 #[cfg(unix)]
@@ -2453,13 +2472,16 @@ fn test_ls_quoting_style() {
     {
         at.touch("one\ntwo");
         at.touch("one\\two");
-        // Default is shell-escape
+        // Default is literal, when stdout is not a TTY.
+        // Otherwise, it is shell-escape
         scene
             .ucmd()
             .arg("--hide-control-chars")
             .arg("one\ntwo")
             .succeeds()
-            .stdout_only("'one'$'\\n''two'\n");
+            .stdout_only("one?two\n");
+        // TODO: TTY-expected output, find a way to check this as well
+        // .stdout_only("'one'$'\\n''two'\n");
 
         for (arg, correct) in [
             ("--quoting-style=literal", "one?two"),
@@ -2546,7 +2568,9 @@ fn test_ls_quoting_style() {
         .ucmd()
         .arg("one two")
         .succeeds()
-        .stdout_only("'one two'\n");
+        .stdout_only("one two\n");
+    // TODO: TTY-expected output
+    // .stdout_only("'one two'\n");
 
     for (arg, correct) in [
         ("--quoting-style=literal", "one two"),
@@ -2598,6 +2622,70 @@ fn test_ls_quoting_style() {
     }
 }
 
+#[test]
+fn test_ls_quoting_style_env_var_default() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch(at.plus_as_string("foo-1"));
+    at.touch(at.plus_as_string("bar-2"));
+
+    // If no quoting style argument is provided, the QUOTING_STYLE environment variable
+    // shall be used.
+
+    let correct_c = "\"bar-2\"\n\"foo-1\"";
+    scene
+        .ucmd()
+        .env("QUOTING_STYLE", "c")
+        .succeeds()
+        .stdout_only(format!("{correct_c}\n"));
+}
+
+#[test]
+fn test_ls_quoting_style_arg_overrides_env_var() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch(at.plus_as_string("foo-1"));
+    at.touch(at.plus_as_string("bar-2"));
+
+    // The quoting style given by the env variable should be
+    // overridden by any escape style provided by argument.
+    for (arg, correct) in [
+        ("--quoting-style=literal", "foo-1"),
+        ("-N", "foo-1"),
+        ("--quoting-style=escape", "foo-1"),
+        ("-b", "foo-1"),
+        ("--quoting-style=shell-escape", "foo-1"),
+        ("--quoting-style=shell-escape-always", "'foo-1'"),
+        ("--quoting-style=shell", "foo-1"),
+        ("--quoting-style=shell-always", "'foo-1'"),
+    ] {
+        scene
+            .ucmd()
+            .env("QUOTING_STYLE", "c")
+            .arg("--hide-control-chars")
+            .arg(arg)
+            .arg("foo-1")
+            .succeeds()
+            .stdout_only(format!("{correct}\n"));
+    }
+
+    // Another loop to check for the C quoting style that is used as a default above.
+    for (arg, correct) in [
+        ("--quoting-style=c", "\"foo-1\""),
+        ("-Q", "\"foo-1\""),
+        ("--quote-name", "\"foo-1\""),
+    ] {
+        scene
+            .ucmd()
+            .env("QUOTING_STYLE", "literal")
+            .arg("--hide-control-chars")
+            .arg(arg)
+            .arg("foo-1")
+            .succeeds()
+            .stdout_only(format!("{correct}\n"));
+    }
+}
+
 #[test]
 fn test_ls_quoting_and_color() {
     let scene = TestScenario::new(util_name!());
@@ -2609,7 +2697,9 @@ fn test_ls_quoting_and_color() {
         .arg("--color")
         .arg("one two")
         .succeeds()
-        .stdout_only("'one two'\n");
+        .stdout_only("one two\n");
+    // TODO: TTY-expected output
+    // .stdout_only("'one two'\n");
 }
 
 #[test]
@@ -3141,11 +3231,8 @@ fn test_ls_path() {
         .stdout_is(expected_stdout);
 
     let abs_path = format!("{}/{}", at.as_string(), path);
-    let expected_stdout = if cfg!(windows) {
-        format!("\'{abs_path}\'\n")
-    } else {
-        format!("{abs_path}\n")
-    };
+    let expected_stdout = format!("{abs_path}\n");
+
     scene.ucmd().arg(&abs_path).run().stdout_is(expected_stdout);
 
     let expected_stdout = format!("{path}\n{file1}\n");
@@ -3813,3 +3900,432 @@ fn test_ls_cf_output_should_be_delimited_by_tab() {
         .succeeds()
         .stdout_is("a2345/\tb/\n");
 }
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+fn test_posixly_correct_and_block_size_env_vars() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("dd")
+        .arg("if=/dev/zero")
+        .arg("of=file")
+        .arg("bs=1024")
+        .arg("count=1")
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1024 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .env("POSIXLY_CORRECT", "some_value")
+        .succeeds()
+        .stdout_contains_line("total 8")
+        .stdout_contains(" 1024 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .env("LS_BLOCK_SIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 8")
+        .stdout_contains(" 2 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .env("BLOCK_SIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 8")
+        .stdout_contains(" 2 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .env("BLOCKSIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 8")
+        .stdout_contains(" 1024 ");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+fn test_posixly_correct_and_block_size_env_vars_with_k() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("dd")
+        .arg("if=/dev/zero")
+        .arg("of=file")
+        .arg("bs=1024")
+        .arg("count=1")
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("-k")
+        .env("POSIXLY_CORRECT", "some_value")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1024 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("-k")
+        .env("LS_BLOCK_SIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 2 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("-k")
+        .env("BLOCK_SIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 2 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("-k")
+        .env("BLOCKSIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1024 ");
+}
+
+#[test]
+fn test_ls_invalid_block_size() {
+    new_ucmd!()
+        .arg("--block-size=invalid")
+        .fails()
+        .code_is(2)
+        .no_stdout()
+        .stderr_is("ls: invalid --block-size argument 'invalid'\n");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+fn test_ls_invalid_block_size_in_env_var() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("dd")
+        .arg("if=/dev/zero")
+        .arg("of=file")
+        .arg("bs=1024")
+        .arg("count=1")
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg("-og")
+        .env("LS_BLOCK_SIZE", "invalid")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1 1 "); // hardlink count + file size
+
+    scene
+        .ucmd()
+        .arg("-og")
+        .env("BLOCK_SIZE", "invalid")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1 1 "); // hardlink count + file size
+
+    scene
+        .ucmd()
+        .arg("-og")
+        .env("BLOCKSIZE", "invalid")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1024 ");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+fn test_ls_block_size_override() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("dd")
+        .arg("if=/dev/zero")
+        .arg("of=file")
+        .arg("bs=1024")
+        .arg("count=1")
+        .succeeds();
+
+    // --si "wins"
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--block-size=512")
+        .arg("--si")
+        .succeeds()
+        .stdout_contains_line("total 4.1k");
+
+    // --block-size "wins"
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--si")
+        .arg("--block-size=512")
+        .succeeds()
+        .stdout_contains_line("total 8");
+
+    // --human-readable "wins"
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--block-size=512")
+        .arg("--human-readable")
+        .succeeds()
+        .stdout_contains_line("total 4.0K");
+
+    // --block-size "wins"
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--human-readable")
+        .arg("--block-size=512")
+        .succeeds()
+        .stdout_contains_line("total 8");
+}
+
+#[test]
+fn test_ls_block_size_override_self() {
+    new_ucmd!()
+        .arg("--block-size=512")
+        .arg("--block-size=512")
+        .succeeds();
+
+    new_ucmd!()
+        .arg("--human-readable")
+        .arg("--human-readable")
+        .succeeds();
+
+    new_ucmd!().arg("--si").arg("--si").succeeds();
+}
+
+#[test]
+fn test_ls_hyperlink() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let file = "a.txt";
+
+    at.touch(file);
+
+    let path = at.root_dir_resolved();
+    let separator = std::path::MAIN_SEPARATOR_STR;
+
+    let result = scene.ucmd().arg("--hyperlink").succeeds();
+    assert!(result.stdout_str().contains("\x1b]8;;file://"));
+    assert!(result
+        .stdout_str()
+        .contains(&format!("{path}{separator}{file}\x07{file}\x1b]8;;\x07")));
+
+    let result = scene.ucmd().arg("--hyperlink=always").succeeds();
+    assert!(result.stdout_str().contains("\x1b]8;;file://"));
+    assert!(result
+        .stdout_str()
+        .contains(&format!("{path}{separator}{file}\x07{file}\x1b]8;;\x07")));
+
+    scene
+        .ucmd()
+        .arg("--hyperlink=never")
+        .succeeds()
+        .stdout_is(format!("{file}\n"));
+}
+
+// spell-checker: disable
+#[test]
+fn test_ls_hyperlink_encode_link() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        at.touch("back\\slash");
+        at.touch("ques?tion");
+    }
+    at.touch("encoded%3Fquestion");
+    at.touch("sp ace");
+
+    let result = ucmd.arg("--hyperlink").succeeds();
+    #[cfg(not(target_os = "windows"))]
+    {
+        assert!(result
+            .stdout_str()
+            .contains("back%5cslash\x07back\\slash\x1b]8;;\x07"));
+        assert!(result
+            .stdout_str()
+            .contains("ques%3ftion\x07ques?tion\x1b]8;;\x07"));
+    }
+    assert!(result
+        .stdout_str()
+        .contains("encoded%253Fquestion\x07encoded%3Fquestion\x1b]8;;\x07"));
+    assert!(result
+        .stdout_str()
+        .contains("sp%20ace\x07sp ace\x1b]8;;\x07"));
+}
+// spell-checker: enable
+
+#[test]
+fn test_ls_hyperlink_dirs() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let dir_a = "a";
+    let dir_b = "b";
+
+    at.mkdir(dir_a);
+    at.mkdir(dir_b);
+
+    let path = at.root_dir_resolved();
+    let separator = std::path::MAIN_SEPARATOR_STR;
+
+    let result = scene
+        .ucmd()
+        .arg("--hyperlink")
+        .arg(dir_a)
+        .arg(dir_b)
+        .succeeds();
+
+    assert!(result.stdout_str().contains("\x1b]8;;file://"));
+    assert!(result
+        .stdout_str()
+        .lines()
+        .next()
+        .unwrap()
+        .contains(&format!("{path}{separator}{dir_a}\x07{dir_a}\x1b]8;;\x07:")));
+    assert_eq!(result.stdout_str().lines().nth(1).unwrap(), "");
+    assert!(result
+        .stdout_str()
+        .lines()
+        .nth(2)
+        .unwrap()
+        .contains(&format!("{path}{separator}{dir_b}\x07{dir_b}\x1b]8;;\x07:")));
+}
+
+#[test]
+fn test_ls_color_do_not_reset() {
+    let scene: TestScenario = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("example");
+    at.mkdir("example/a");
+    at.mkdir("example/b");
+
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .arg("example/")
+        .succeeds();
+    // the second color code should not have a reset
+    assert_eq!(
+        result.stdout_str().escape_default().to_string(),
+        "\\u{1b}[0m\\u{1b}[01;34ma\\u{1b}[0m\\n\\u{1b}[01;34mb\\u{1b}[0m\\n"
+    );
+}
+
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_term_colorterm() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("exe");
+    scene.ccmd("chmod").arg("+x").arg("exe").succeeds();
+
+    // Should show colors
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .env("LS_COLORS", "")
+        .env("TERM", "")
+        .succeeds();
+    assert_eq!(
+        result.stdout_str().trim().escape_default().to_string(),
+        "\\u{1b}[0m\\u{1b}[01;32mexe\\u{1b}[0m"
+    );
+
+    // Should show colors
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .env("LS_COLORS", "")
+        .env("COLORTERM", "")
+        .succeeds();
+    assert_eq!(
+        result.stdout_str().trim().escape_default().to_string(),
+        "\\u{1b}[0m\\u{1b}[01;32mexe\\u{1b}[0m"
+    );
+
+    // No colors
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .env("LS_COLORS", "")
+        .env("TERM", "")
+        .env("COLORTERM", "")
+        .succeeds();
+    assert_eq!(
+        result.stdout_str().trim().escape_default().to_string(),
+        "exe"
+    );
+
+    // No colors
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .env("LS_COLORS", "")
+        .env("TERM", "dumb")
+        .env("COLORTERM", "")
+        .succeeds();
+    assert_eq!(
+        result.stdout_str().trim().escape_default().to_string(),
+        "exe"
+    );
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_acl_display() {
+    use std::process::Command;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let path = "a42";
+    at.mkdir(path);
+
+    let path = at.plus_as_string(path);
+    // calling the command directly. xattr requires some dev packages to be installed
+    // and it adds a complex dependency just for a test
+    match Command::new("setfacl")
+        .args(["-d", "-m", "group::rwx", &path])
+        .status()
+        .map(|status| status.code())
+    {
+        Ok(Some(0)) => {}
+        Ok(_) => {
+            println!("test skipped: setfacl failed");
+            return;
+        }
+        Err(e) => {
+            println!("test skipped: setfacl failed with {}", e);
+            return;
+        }
+    }
+
+    scene
+        .ucmd()
+        .args(&["-lda", &path])
+        .succeeds()
+        .stdout_contains("+");
+}
diff --git a/tests/by-util/test_mv.rs b/tests/by-util/test_mv.rs
index c54d24ea906..dd05ffbcd0a 100644
--- a/tests/by-util/test_mv.rs
+++ b/tests/by-util/test_mv.rs
@@ -10,31 +10,31 @@ use std::thread::sleep;
 use std::time::Duration;
 
 #[test]
-fn test_invalid_arg() {
+fn test_mv_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
 }
 
 #[test]
-fn test_mv_rename_dir() {
+fn test_mv_missing_dest() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let dir1 = "test_mv_rename_dir";
-    let dir2 = "test_mv_rename_dir2";
-
-    at.mkdir(dir1);
+    let dir = "dir";
 
-    ucmd.arg(dir1).arg(dir2).succeeds().no_stderr();
+    at.mkdir(dir);
 
-    assert!(at.dir_exists(dir2));
+    ucmd.arg(dir).fails();
 }
 
 #[test]
-fn test_mv_fail() {
+fn test_mv_rename_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
     let dir1 = "test_mv_rename_dir";
+    let dir2 = "test_mv_rename_dir2";
 
     at.mkdir(dir1);
 
-    ucmd.arg(dir1).fails();
+    ucmd.arg(dir1).arg(dir2).succeeds().no_stderr();
+
+    assert!(at.dir_exists(dir2));
 }
 
 #[test]
@@ -905,6 +905,20 @@ fn test_mv_update_option() {
     assert!(!at.file_exists(file_b));
 }
 
+#[test]
+fn test_mv_update_with_dest_ending_with_slash() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let source = "source";
+    let dest = "destination/";
+
+    at.mkdir("source");
+
+    ucmd.arg("--update").arg(source).arg(dest).succeeds();
+
+    assert!(!at.dir_exists(source));
+    assert!(at.dir_exists(dest));
+}
+
 #[test]
 fn test_mv_arg_update_none() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -1158,6 +1172,32 @@ fn test_mv_overwrite_dir() {
     assert!(at.dir_exists(dir_b));
 }
 
+#[test]
+fn test_mv_no_target_dir_with_dest_not_existing() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir_a = "a";
+    let dir_b = "b";
+
+    at.mkdir(dir_a);
+    ucmd.arg("-T").arg(dir_a).arg(dir_b).succeeds().no_output();
+
+    assert!(!at.dir_exists(dir_a));
+    assert!(at.dir_exists(dir_b));
+}
+
+#[test]
+fn test_mv_no_target_dir_with_dest_not_existing_and_ending_with_slash() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir_a = "a";
+    let dir_b = "b/";
+
+    at.mkdir(dir_a);
+    ucmd.arg("-T").arg(dir_a).arg(dir_b).succeeds().no_output();
+
+    assert!(!at.dir_exists(dir_a));
+    assert!(at.dir_exists(dir_b));
+}
+
 #[test]
 fn test_mv_overwrite_nonempty_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -1415,6 +1455,20 @@ fn test_mv_directory_into_subdirectory_of_itself_fails() {
         );
 }
 
+#[test]
+fn test_mv_dir_into_dir_with_source_name_a_prefix_of_target_name() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let source = "test";
+    let target = "test2";
+
+    at.mkdir(source);
+    at.mkdir(target);
+
+    ucmd.arg(source).arg(target).succeeds().no_output();
+
+    assert!(at.dir_exists(&format!("{target}/{source}")));
+}
+
 #[test]
 fn test_mv_file_into_dir_where_both_are_files() {
     let scene = TestScenario::new(util_name!());
@@ -1429,6 +1483,65 @@ fn test_mv_file_into_dir_where_both_are_files() {
         .stderr_contains("mv: failed to access 'b/': Not a directory");
 }
 
+#[test]
+fn test_mv_seen_file() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+    at.write("a/f", "a");
+    at.write("b/f", "b");
+
+    let result = ts.ucmd().arg("a/f").arg("b/f").arg("c").fails();
+
+    #[cfg(not(unix))]
+    assert!(result
+        .stderr_str()
+        .contains("will not overwrite just-created 'c\\f' with 'b/f'"));
+    #[cfg(unix)]
+    assert!(result
+        .stderr_str()
+        .contains("will not overwrite just-created 'c/f' with 'b/f'"));
+
+    // a/f has been moved into c/f
+    assert!(at.plus("c").join("f").exists());
+    // b/f still exists
+    assert!(at.plus("b").join("f").exists());
+    // a/f no longer exists
+    assert!(!at.plus("a").join("f").exists());
+}
+
+#[test]
+fn test_mv_seen_multiple_files_to_directory() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+    at.write("a/f", "a");
+    at.write("b/f", "b");
+    at.write("b/g", "g");
+
+    let result = ts.ucmd().arg("a/f").arg("b/f").arg("b/g").arg("c").fails();
+    #[cfg(not(unix))]
+    assert!(result
+        .stderr_str()
+        .contains("will not overwrite just-created 'c\\f' with 'b/f'"));
+    #[cfg(unix)]
+    assert!(result
+        .stderr_str()
+        .contains("will not overwrite just-created 'c/f' with 'b/f'"));
+
+    assert!(!at.plus("a").join("f").exists());
+    assert!(at.plus("b").join("f").exists());
+    assert!(!at.plus("b").join("g").exists());
+    assert!(at.plus("c").join("f").exists());
+    assert!(at.plus("c").join("g").exists());
+}
+
 #[test]
 fn test_mv_dir_into_file_where_both_are_files() {
     let scene = TestScenario::new(util_name!());
@@ -1443,6 +1556,60 @@ fn test_mv_dir_into_file_where_both_are_files() {
         .stderr_contains("mv: cannot stat 'a/': Not a directory");
 }
 
+#[test]
+fn test_mv_dir_into_path_slash() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("a");
+    scene.ucmd().arg("a").arg("e/").succeeds();
+    assert!(at.dir_exists("e"));
+    at.mkdir("b");
+    at.mkdir("f");
+    scene.ucmd().arg("b").arg("f/").succeeds();
+    assert!(at.dir_exists("f/b"));
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_acl() {
+    use std::process::Command;
+
+    use crate::common::util::compare_xattrs;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let path1 = "a";
+    let path2 = "b";
+    let file = "a/file";
+    let file_target = "b/file";
+    at.mkdir(path1);
+    at.mkdir(path2);
+    at.touch(file);
+
+    let path = at.plus_as_string(file);
+    // calling the command directly. xattr requires some dev packages to be installed
+    // and it adds a complex dependency just for a test
+    match Command::new("setfacl")
+        .args(["-m", "group::rwx", &path1])
+        .status()
+        .map(|status| status.code())
+    {
+        Ok(Some(0)) => {}
+        Ok(_) => {
+            println!("test skipped: setfacl failed");
+            return;
+        }
+        Err(e) => {
+            println!("test skipped: setfacl failed with {}", e);
+            return;
+        }
+    }
+
+    scene.ucmd().arg(&path).arg(path2).succeeds();
+
+    assert!(compare_xattrs(&file, &file_target));
+}
+
 // Todo:
 
 // $ at.touch a b
diff --git a/tests/by-util/test_nl.rs b/tests/by-util/test_nl.rs
index 78c8975a849..a00e37a4767 100644
--- a/tests/by-util/test_nl.rs
+++ b/tests/by-util/test_nl.rs
@@ -634,3 +634,20 @@ fn test_empty_section_delimiter() {
             .stdout_is("     1\ta\n       \n     2\tb\n");
     }
 }
+
+#[test]
+fn test_directory_as_input() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir = "dir";
+    let file = "file";
+    let content = "aaa";
+
+    at.mkdir(dir);
+    at.write(file, content);
+
+    ucmd.arg(dir)
+        .arg(file)
+        .fails()
+        .stderr_is(format!("nl: {dir}: Is a directory\n"))
+        .stdout_contains(content);
+}
diff --git a/tests/by-util/test_pathchk.rs b/tests/by-util/test_pathchk.rs
index d66ecb9efb4..d09c8a2e1e4 100644
--- a/tests/by-util/test_pathchk.rs
+++ b/tests/by-util/test_pathchk.rs
@@ -4,6 +4,14 @@
 // file that was distributed with this source code.
 use crate::common::util::TestScenario;
 
+#[test]
+fn test_no_args() {
+    new_ucmd!()
+        .fails()
+        .no_stdout()
+        .stderr_contains("pathchk: missing operand");
+}
+
 #[test]
 fn test_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
@@ -11,8 +19,6 @@ fn test_invalid_arg() {
 
 #[test]
 fn test_default_mode() {
-    // test the default mode
-
     // accept some reasonable default
     new_ucmd!().args(&["dir/file"]).succeeds().no_stdout();
 
@@ -48,8 +54,6 @@ fn test_default_mode() {
 
 #[test]
 fn test_posix_mode() {
-    // test the posix mode
-
     // accept some reasonable default
     new_ucmd!().args(&["-p", "dir/file"]).succeeds().no_stdout();
 
@@ -74,8 +78,6 @@ fn test_posix_mode() {
 
 #[test]
 fn test_posix_special() {
-    // test the posix special mode
-
     // accept some reasonable default
     new_ucmd!().args(&["-P", "dir/file"]).succeeds().no_stdout();
 
@@ -115,8 +117,6 @@ fn test_posix_special() {
 
 #[test]
 fn test_posix_all() {
-    // test the posix special mode
-
     // accept some reasonable default
     new_ucmd!()
         .args(&["-p", "-P", "dir/file"])
@@ -164,10 +164,3 @@ fn test_posix_all() {
     // fail on empty path
     new_ucmd!().args(&["-p", "-P", ""]).fails().no_stdout();
 }
-
-#[test]
-fn test_args_parsing() {
-    // fail on no args
-    let empty_args: [String; 0] = [];
-    new_ucmd!().args(&empty_args).fails().no_stdout();
-}
diff --git a/tests/by-util/test_pinky.rs b/tests/by-util/test_pinky.rs
index 57413c4c95e..0fff402df96 100644
--- a/tests/by-util/test_pinky.rs
+++ b/tests/by-util/test_pinky.rs
@@ -21,6 +21,7 @@ fn test_capitalize() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_long_format() {
     let login = "root";
     let pw: Passwd = Passwd::locate(login).unwrap();
@@ -44,6 +45,7 @@ fn test_long_format() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_long_format_multiple_users() {
     // multiple instances of one account we know exists,
     // the account of the test runner,
@@ -71,6 +73,7 @@ fn test_long_format_wo_user() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_short_format_i() {
     // allow whitespace variation
     // * minor whitespace differences occur between platform built-in outputs; specifically, the number of trailing TABs may be variant
@@ -85,6 +88,7 @@ fn test_short_format_i() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_short_format_q() {
     // allow whitespace variation
     // * minor whitespace differences occur between platform built-in outputs; specifically, the number of trailing TABs may be variant
@@ -99,6 +103,7 @@ fn test_short_format_q() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_no_flag() {
     let ts = TestScenario::new(util_name!());
     let actual = ts.ucmd().succeeds().stdout_move_str();
diff --git a/tests/by-util/test_printf.rs b/tests/by-util/test_printf.rs
index a297dbf6833..db4c5aa7f8d 100644
--- a/tests/by-util/test_printf.rs
+++ b/tests/by-util/test_printf.rs
@@ -36,6 +36,11 @@ fn escaped_slash() {
         .stdout_only("hello\\ world");
 }
 
+#[test]
+fn unescaped_double_quote() {
+    new_ucmd!().args(&["\\\""]).succeeds().stdout_only("\"");
+}
+
 #[test]
 fn escaped_hex() {
     new_ucmd!().args(&["\\x41"]).succeeds().stdout_only("A");
@@ -162,6 +167,14 @@ fn sub_char() {
         .stdout_only("the letter A");
 }
 
+#[test]
+fn sub_char_from_string() {
+    new_ucmd!()
+        .args(&["%c%c%c", "five", "%", "oval"])
+        .succeeds()
+        .stdout_only("f%o");
+}
+
 #[test]
 fn sub_num_int() {
     new_ucmd!()
@@ -224,6 +237,11 @@ fn sub_num_int_char_const_in() {
         .args(&["ninety seven is %i", "'a"])
         .succeeds()
         .stdout_only("ninety seven is 97");
+
+    new_ucmd!()
+        .args(&["emoji is %i", "'🙃"])
+        .succeeds()
+        .stdout_only("emoji is 128579");
 }
 
 #[test]
@@ -258,6 +276,14 @@ fn sub_num_hex_upper() {
         .stdout_only("thirty in hex is 1E");
 }
 
+#[test]
+fn sub_num_hex_non_numerical() {
+    new_ucmd!()
+        .args(&["parameters need to be numbers %X", "%194"])
+        .fails()
+        .code_is(1);
+}
+
 #[test]
 fn sub_num_float() {
     new_ucmd!()
@@ -283,7 +309,16 @@ fn sub_num_float_e_no_round() {
 }
 
 #[test]
-fn sub_num_float_round() {
+fn sub_num_float_round_to_one() {
+    new_ucmd!()
+        .args(&["one is %f", "0.9999995"])
+        .succeeds()
+        .stdout_only("one is 1.000000");
+}
+
+#[test]
+#[ignore = "Requires 'long double' precision floats to be used internally"]
+fn sub_num_float_round_to_two() {
     new_ucmd!()
         .args(&["two is %f", "1.9999995"])
         .succeeds()
@@ -568,3 +603,80 @@ fn sub_general_round_float_leading_zeroes() {
         .succeeds()
         .stdout_only("1.00001");
 }
+
+#[test]
+fn partial_float() {
+    new_ucmd!()
+        .args(&["%.2f is %s", "42.03x", "a lot"])
+        .fails()
+        .code_is(1)
+        .stdout_is("42.03 is a lot")
+        .stderr_is("printf: '42.03x': value not completely converted\n");
+}
+
+#[test]
+fn partial_integer() {
+    new_ucmd!()
+        .args(&["%d is %s", "42x23", "a lot"])
+        .fails()
+        .code_is(1)
+        .stdout_is("42 is a lot")
+        .stderr_is("printf: '42x23': value not completely converted\n");
+}
+
+#[test]
+fn test_overflow() {
+    new_ucmd!()
+        .args(&["%d", "36893488147419103232"])
+        .fails()
+        .code_is(1)
+        .stderr_is("printf: '36893488147419103232': Numerical result out of range\n");
+}
+
+#[test]
+fn partial_char() {
+    new_ucmd!()
+        .args(&["%d", "'abc"])
+        .fails()
+        .code_is(1)
+        .stdout_is("97")
+        .stderr_is(
+            "printf: warning: bc: character(s) following character constant have been ignored\n",
+        );
+}
+
+#[test]
+fn sub_alternative_lower_hex_0() {
+    new_ucmd!().args(&["%#x", "0"]).succeeds().stdout_only("0");
+}
+
+#[test]
+fn sub_alternative_lower_hex() {
+    new_ucmd!()
+        .args(&["%#x", "42"])
+        .succeeds()
+        .stdout_only("0x2a");
+}
+
+#[test]
+fn sub_alternative_upper_hex_0() {
+    new_ucmd!().args(&["%#X", "0"]).succeeds().stdout_only("0");
+}
+
+#[test]
+fn sub_alternative_upper_hex() {
+    new_ucmd!()
+        .args(&["%#X", "42"])
+        .succeeds()
+        .stdout_only("0x2A");
+}
+
+#[test]
+fn char_as_byte() {
+    new_ucmd!().args(&["%c", "🙃"]).succeeds().stdout_only("ð");
+}
+
+#[test]
+fn no_infinite_loop() {
+    new_ucmd!().args(&["a", "b"]).succeeds().stdout_only("a");
+}
diff --git a/tests/by-util/test_seq.rs b/tests/by-util/test_seq.rs
index da28181eb61..b29d898a87a 100644
--- a/tests/by-util/test_seq.rs
+++ b/tests/by-util/test_seq.rs
@@ -766,3 +766,37 @@ fn test_invalid_zero_increment_value() {
         .no_stdout()
         .usage_error("invalid Zero increment value: '0'");
 }
+
+#[test]
+fn test_power_of_ten_display() {
+    new_ucmd!()
+        .args(&["-f", "%.2g", "10", "10"])
+        .succeeds()
+        .stdout_only("10\n");
+}
+
+#[test]
+fn test_default_g_precision() {
+    new_ucmd!()
+        .args(&["-f", "%010g", "1e5", "1e5"])
+        .succeeds()
+        .stdout_only("0000100000\n");
+    new_ucmd!()
+        .args(&["-f", "%010g", "1e6", "1e6"])
+        .succeeds()
+        .stdout_only("000001e+06\n");
+}
+
+#[test]
+fn test_invalid_format() {
+    new_ucmd!()
+        .args(&["-f", "%%g", "1"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("format '%%g' has no % directive");
+    new_ucmd!()
+        .args(&["-f", "%g%g", "1"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("format '%g%g' has too many % directives");
+}
diff --git a/tests/by-util/test_shred.rs b/tests/by-util/test_shred.rs
index 83d2890ed0b..d5de7882f57 100644
--- a/tests/by-util/test_shred.rs
+++ b/tests/by-util/test_shred.rs
@@ -2,6 +2,9 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+
+// spell-checker:ignore wipesync
+
 use crate::common::util::TestScenario;
 
 #[test]
@@ -9,8 +12,82 @@ fn test_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
 }
 
+#[test]
+fn test_invalid_remove_arg() {
+    new_ucmd!().arg("--remove=unknown").fails().code_is(1);
+}
+
+#[test]
+fn test_shred() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_shred";
+    let file_original_content = "test_shred file content";
+
+    at.write(file, file_original_content);
+
+    ucmd.arg(file).succeeds();
+
+    // File exists
+    assert!(at.file_exists(file));
+    // File is obfuscated
+    assert!(at.read_bytes(file) != file_original_content.as_bytes());
+}
+
 #[test]
 fn test_shred_remove() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_shred_remove";
+    at.touch(file);
+
+    ucmd.arg("--remove").arg(file).succeeds();
+
+    // File was deleted
+    assert!(!at.file_exists(file));
+}
+
+#[test]
+fn test_shred_remove_unlink() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_shred_remove_unlink";
+    at.touch(file);
+
+    ucmd.arg("--remove=unlink").arg(file).succeeds();
+
+    // File was deleted
+    assert!(!at.file_exists(file));
+}
+
+#[test]
+fn test_shred_remove_wipe() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_shred_remove_wipe";
+    at.touch(file);
+
+    ucmd.arg("--remove=wipe").arg(file).succeeds();
+
+    // File was deleted
+    assert!(!at.file_exists(file));
+}
+
+#[test]
+fn test_shred_remove_wipesync() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_shred_remove_wipesync";
+    at.touch(file);
+
+    ucmd.arg("--remove=wipesync").arg(file).succeeds();
+
+    // File was deleted
+    assert!(!at.file_exists(file));
+}
+
+#[test]
+fn test_shred_u() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
diff --git a/tests/by-util/test_sort.rs b/tests/by-util/test_sort.rs
index 690623c1c96..97c72c7b19b 100644
--- a/tests/by-util/test_sort.rs
+++ b/tests/by-util/test_sort.rs
@@ -1181,3 +1181,8 @@ fn test_tmp_files_deleted_on_sigint() {
 fn test_same_sort_mode_twice() {
     new_ucmd!().args(&["-k", "2n,2n", "empty.txt"]).succeeds();
 }
+
+#[test]
+fn test_args_override() {
+    new_ucmd!().args(&["-f", "-f"]).pipe_in("foo").succeeds();
+}
diff --git a/tests/by-util/test_split.rs b/tests/by-util/test_split.rs
index aec6f059441..acb8ab56140 100644
--- a/tests/by-util/test_split.rs
+++ b/tests/by-util/test_split.rs
@@ -2,11 +2,13 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore xzaaa sixhundredfiftyonebytes ninetyonebytes threebytes asciilowercase fghij klmno pqrst uvwxyz fivelines twohundredfortyonebytes onehundredlines nbbbb dxen ncccc
+// spell-checker:ignore xzaaa sixhundredfiftyonebytes ninetyonebytes threebytes asciilowercase ghijkl mnopq rstuv wxyz fivelines twohundredfortyonebytes onehundredlines nbbbb dxen ncccc rlimit NOFILE
 
 use crate::common::util::{AtPath, TestScenario};
 use rand::{thread_rng, Rng, SeedableRng};
 use regex::Regex;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use rlimit::Resource;
 #[cfg(not(windows))]
 use std::env;
 use std::path::Path;
@@ -606,13 +608,13 @@ fn test_split_obs_lines_as_other_option_value() {
         .args(&["-n", "-200", "file"])
         .fails()
         .code_is(1)
-        .stderr_contains("split: invalid number of chunks: -200\n");
+        .stderr_contains("split: invalid number of chunks: '-200'\n");
     scene
         .ucmd()
         .args(&["--number", "-e200", "file"])
         .fails()
         .code_is(1)
-        .stderr_contains("split: invalid number of chunks: -e200\n");
+        .stderr_contains("split: invalid number of chunks: '-e200'\n");
 }
 
 /// Test for using more than one obsolete lines option (standalone)
@@ -704,60 +706,41 @@ fn test_split_overflow_bytes_size() {
     assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
-#[test]
-#[cfg(target_pointer_width = "32")]
-fn test_split_chunks_num_chunks_oversized_32() {
-    let scene = TestScenario::new(util_name!());
-    let at = &scene.fixtures;
-    at.touch("file");
-    scene
-        .ucmd()
-        .args(&["--number", "5000000000", "sixhundredfiftyonebytes.txt"])
-        .fails()
-        .code_is(1)
-        .stderr_only("split: Number of chunks too big\n");
-}
-
 #[test]
 fn test_split_stdin_num_chunks() {
-    new_ucmd!()
-        .args(&["--number=1"])
-        .fails()
-        .code_is(1)
-        .stderr_only("split: -: cannot determine file size\n");
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=1"]).pipe_in("").succeeds();
+    assert_eq!(at.read("xaa"), "");
+    assert!(!at.plus("xab").exists());
 }
 
 #[test]
 fn test_split_stdin_num_kth_chunk() {
     new_ucmd!()
         .args(&["--number=1/2"])
-        .fails()
-        .code_is(1)
-        .stderr_only("split: -: cannot determine file size\n");
+        .pipe_in("1\n2\n3\n4\n5\n")
+        .succeeds()
+        .stdout_only("1\n2\n3");
 }
 
 #[test]
 fn test_split_stdin_num_line_chunks() {
-    new_ucmd!()
-        .args(&["--number=l/2"])
-        .fails()
-        .code_is(1)
-        .stderr_only("split: -: cannot determine file size\n");
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=l/2"])
+        .pipe_in("1\n2\n3\n4\n5\n")
+        .succeeds();
+    assert_eq!(at.read("xaa"), "1\n2\n3\n");
+    assert_eq!(at.read("xab"), "4\n5\n");
+    assert!(!at.plus("xac").exists());
 }
 
 #[test]
 fn test_split_stdin_num_kth_line_chunk() {
     new_ucmd!()
         .args(&["--number=l/2/5"])
-        .fails()
-        .code_is(1)
-        .stderr_only("split: -: cannot determine file size\n");
-}
-
-fn file_read(at: &AtPath, filename: &str) -> String {
-    let mut s = String::new();
-    at.open(filename).read_to_string(&mut s).unwrap();
-    s
+        .pipe_in("1\n2\n3\n4\n5\n")
+        .succeeds()
+        .stdout_only("2\n");
 }
 
 /// Test for the default suffix length behavior: dynamically increasing size.
@@ -779,11 +762,11 @@ fn test_alphabetic_dynamic_suffix_length() {
     for i in b'a'..=b'y' {
         for j in b'a'..=b'z' {
             let filename = format!("x{}{}", i as char, j as char);
-            let contents = file_read(&at, &filename);
+            let contents = at.read(&filename);
             assert_eq!(contents, "a");
         }
     }
-    assert_eq!(file_read(&at, "xzaaa"), "a");
+    assert_eq!(at.read("xzaaa"), "a");
 }
 
 /// Test for the default suffix length behavior: dynamically increasing size.
@@ -803,10 +786,10 @@ fn test_numeric_dynamic_suffix_length() {
         .succeeds();
     for i in 0..90 {
         let filename = format!("x{i:02}");
-        let contents = file_read(&at, &filename);
+        let contents = at.read(&filename);
         assert_eq!(contents, "a");
     }
-    assert_eq!(file_read(&at, "x9000"), "a");
+    assert_eq!(at.read("x9000"), "a");
 }
 
 #[test]
@@ -825,10 +808,10 @@ fn test_hex_dynamic_suffix_length() {
         .succeeds();
     for i in 0..240 {
         let filename = format!("x{i:02x}");
-        let contents = file_read(&at, &filename);
+        let contents = at.read(&filename);
         assert_eq!(contents, "a");
     }
-    assert_eq!(file_read(&at, "xf000"), "a");
+    assert_eq!(at.read("xf000"), "a");
 }
 
 /// Test for dynamic suffix length (auto-widening) disabled when suffix start number is specified
@@ -846,7 +829,7 @@ fn test_dynamic_suffix_length_on_with_suffix_start_no_value() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-b", "1", "--numeric-suffixes", "ninetyonebytes.txt"])
         .succeeds();
-    assert_eq!(file_read(&at, "x9000"), "a");
+    assert_eq!(at.read("x9000"), "a");
 }
 
 /// Test for suffix auto-width with --number strategy and suffix start number
@@ -858,8 +841,8 @@ fn test_suffix_auto_width_with_number() {
     let glob = Glob::new(&at, ".", r"x\d\d\d$");
     assert_eq!(glob.count(), 100);
     assert_eq!(glob.collate(), at.read_bytes("fivelines.txt"));
-    assert_eq!(file_read(&at, "x001"), "1\n");
-    assert_eq!(file_read(&at, "x100"), "");
+    assert_eq!(at.read("x001"), "1\n");
+    assert_eq!(at.read("x100"), "");
 
     new_ucmd!()
         .args(&["--numeric-suffixes=100", "--number=r/100", "fivelines.txt"])
@@ -912,6 +895,14 @@ fn test_suffixes_exhausted() {
         .stderr_only("split: output file suffixes exhausted\n");
 }
 
+#[test]
+fn test_suffix_length_req() {
+    new_ucmd!()
+        .args(&["-n", "100", "-a", "1", "asciilowercase.txt"])
+        .fails()
+        .stderr_only("split: the suffix length needs to be at least 2\n");
+}
+
 #[test]
 fn test_verbose() {
     new_ucmd!()
@@ -931,17 +922,12 @@ creating file 'xaf'
 #[test]
 fn test_number_n() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let file_read = |f| {
-        let mut s = String::new();
-        at.open(f).read_to_string(&mut s).unwrap();
-        s
-    };
     ucmd.args(&["-n", "5", "asciilowercase.txt"]).succeeds();
-    assert_eq!(file_read("xaa"), "abcde");
-    assert_eq!(file_read("xab"), "fghij");
-    assert_eq!(file_read("xac"), "klmno");
-    assert_eq!(file_read("xad"), "pqrst");
-    assert_eq!(file_read("xae"), "uvwxyz\n");
+    assert_eq!(at.read("xaa"), "abcdef");
+    assert_eq!(at.read("xab"), "ghijkl");
+    assert_eq!(at.read("xac"), "mnopq");
+    assert_eq!(at.read("xad"), "rstuv");
+    assert_eq!(at.read("xae"), "wxyz\n");
     #[cfg(unix)]
     new_ucmd!()
         .args(&["--number=100", "/dev/null"])
@@ -954,11 +940,11 @@ fn test_number_kth_of_n() {
     new_ucmd!()
         .args(&["--number=3/5", "asciilowercase.txt"])
         .succeeds()
-        .stdout_only("klmno");
+        .stdout_only("mnopq");
     new_ucmd!()
         .args(&["--number=5/5", "asciilowercase.txt"])
         .succeeds()
-        .stdout_only("uvwxyz\n");
+        .stdout_only("wxyz\n");
     new_ucmd!()
         .args(&["-e", "--number=99/100", "asciilowercase.txt"])
         .succeeds()
@@ -979,11 +965,11 @@ fn test_number_kth_of_n() {
     new_ucmd!()
         .args(&["--number=0/5", "asciilowercase.txt"])
         .fails()
-        .stderr_contains("split: invalid chunk number: 0");
+        .stderr_contains("split: invalid chunk number: '0'");
     new_ucmd!()
         .args(&["--number=10/5", "asciilowercase.txt"])
         .fails()
-        .stderr_contains("split: invalid chunk number: 10");
+        .stderr_contains("split: invalid chunk number: '10'");
     #[cfg(target_pointer_width = "64")]
     new_ucmd!()
         .args(&[
@@ -991,7 +977,7 @@ fn test_number_kth_of_n() {
             "asciilowercase.txt",
         ])
         .fails()
-        .stderr_contains("split: invalid number of chunks: 18446744073709551616");
+        .stderr_contains("split: invalid number of chunks: '18446744073709551616'");
 }
 
 #[test]
@@ -1025,32 +1011,27 @@ fn test_number_kth_of_n_round_robin() {
             "fivelines.txt",
         ])
         .fails()
-        .stderr_contains("split: invalid number of chunks: 18446744073709551616");
+        .stderr_contains("split: invalid number of chunks: '18446744073709551616'");
     new_ucmd!()
         .args(&["--number", "r/0/3", "fivelines.txt"])
         .fails()
-        .stderr_contains("split: invalid chunk number: 0");
+        .stderr_contains("split: invalid chunk number: '0'");
     new_ucmd!()
         .args(&["--number", "r/10/3", "fivelines.txt"])
         .fails()
-        .stderr_contains("split: invalid chunk number: 10");
+        .stderr_contains("split: invalid chunk number: '10'");
 }
 
 #[test]
 fn test_split_number_with_io_blksize() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let file_read = |f| {
-        let mut s = String::new();
-        at.open(f).read_to_string(&mut s).unwrap();
-        s
-    };
     ucmd.args(&["-n", "5", "asciilowercase.txt", "---io-blksize", "1024"])
         .succeeds();
-    assert_eq!(file_read("xaa"), "abcde");
-    assert_eq!(file_read("xab"), "fghij");
-    assert_eq!(file_read("xac"), "klmno");
-    assert_eq!(file_read("xad"), "pqrst");
-    assert_eq!(file_read("xae"), "uvwxyz\n");
+    assert_eq!(at.read("xaa"), "abcdef");
+    assert_eq!(at.read("xab"), "ghijkl");
+    assert_eq!(at.read("xac"), "mnopq");
+    assert_eq!(at.read("xad"), "rstuv");
+    assert_eq!(at.read("xae"), "wxyz\n");
 }
 
 #[test]
@@ -1065,6 +1046,32 @@ fn test_split_default_with_io_blksize() {
     assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
+#[test]
+fn test_split_invalid_io_blksize() {
+    new_ucmd!()
+        .args(&["---io-blksize=XYZ", "threebytes.txt"])
+        .fails()
+        .stderr_only("split: invalid IO block size: 'XYZ'\n");
+    new_ucmd!()
+        .args(&["---io-blksize=5000000000", "threebytes.txt"])
+        .fails()
+        .stderr_only("split: invalid IO block size: '5000000000'\n");
+    #[cfg(target_pointer_width = "32")]
+    new_ucmd!()
+        .args(&["---io-blksize=2146435072", "threebytes.txt"])
+        .fails()
+        .stderr_only("split: invalid IO block size: '2146435072'\n");
+}
+
+#[test]
+fn test_split_number_oversized_stdin() {
+    new_ucmd!()
+        .args(&["--number=3", "---io-blksize=600"])
+        .pipe_in_fixture("sixhundredfiftyonebytes.txt")
+        .fails()
+        .stderr_only("split: -: cannot determine input size\n");
+}
+
 #[test]
 fn test_invalid_suffix_length() {
     new_ucmd!()
@@ -1132,7 +1139,7 @@ fn test_allow_empty_files() {
 }
 
 #[test]
-fn test_elide_empty_files() {
+fn test_elide_empty_files_n_chunks() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-e", "-n", "4", "threebytes.txt"])
         .succeeds()
@@ -1146,7 +1153,7 @@ fn test_elide_empty_files() {
 
 #[test]
 #[cfg(unix)]
-fn test_elide_dev_null() {
+fn test_elide_dev_null_n_chunks() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-e", "-n", "3", "/dev/null"])
         .succeeds()
@@ -1158,30 +1165,108 @@ fn test_elide_dev_null() {
 }
 
 #[test]
-fn test_lines() {
+#[cfg(unix)]
+fn test_dev_zero() {
     let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-n", "3", "/dev/zero"])
+        .fails()
+        .stderr_only("split: /dev/zero: cannot determine file size\n");
+    assert!(!at.plus("xaa").exists());
+    assert!(!at.plus("xab").exists());
+    assert!(!at.plus("xac").exists());
+}
 
-    let file_read = |f| {
-        let mut s = String::new();
-        at.open(f).read_to_string(&mut s).unwrap();
-        s
-    };
+#[test]
+fn test_elide_empty_files_l_chunks() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-e", "-n", "l/7", "fivelines.txt"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert_eq!(at.read("xaa"), "1\n");
+    assert_eq!(at.read("xab"), "2\n");
+    assert_eq!(at.read("xac"), "3\n");
+    assert_eq!(at.read("xad"), "4\n");
+    assert_eq!(at.read("xae"), "5\n");
+    assert!(!at.plus("xaf").exists());
+    assert!(!at.plus("xag").exists());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_elide_dev_null_l_chunks() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-e", "-n", "l/3", "/dev/null"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(!at.plus("xaa").exists());
+    assert!(!at.plus("xab").exists());
+    assert!(!at.plus("xac").exists());
+}
 
+#[test]
+#[cfg(unix)]
+fn test_number_by_bytes_dev_zero() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-n", "3", "/dev/zero"])
+        .fails()
+        .stderr_only("split: /dev/zero: cannot determine file size\n");
+    assert!(!at.plus("xaa").exists());
+    assert!(!at.plus("xab").exists());
+    assert!(!at.plus("xac").exists());
+}
+
+#[test]
+fn test_number_by_lines() {
+    let (at, mut ucmd) = at_and_ucmd!();
     // Split into two files without splitting up lines.
     ucmd.args(&["-n", "l/2", "fivelines.txt"]).succeeds();
 
-    assert_eq!(file_read("xaa"), "1\n2\n3\n");
-    assert_eq!(file_read("xab"), "4\n5\n");
+    assert_eq!(at.read("xaa"), "1\n2\n3\n");
+    assert_eq!(at.read("xab"), "4\n5\n");
 }
 
 #[test]
-fn test_lines_kth() {
+fn test_number_by_lines_kth() {
     new_ucmd!()
         .args(&["-n", "l/3/10", "onehundredlines.txt"])
         .succeeds()
         .stdout_only("20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n");
 }
 
+#[test]
+#[cfg(unix)]
+fn test_number_by_lines_kth_dev_null() {
+    new_ucmd!()
+        .args(&["-n", "l/3/10", "/dev/null"])
+        .succeeds()
+        .stdout_only("");
+}
+
+#[test]
+fn test_number_by_lines_kth_no_end_sep() {
+    new_ucmd!()
+        .args(&["-n", "l/3/10"])
+        .pipe_in("1\n2222\n3\n4")
+        .succeeds()
+        .stdout_only("2222\n");
+    new_ucmd!()
+        .args(&["-e", "-n", "l/2/2"])
+        .pipe_in("1\n2222\n3\n4")
+        .succeeds()
+        .stdout_only("3\n4");
+}
+
+#[test]
+fn test_number_by_lines_rr_kth_no_end_sep() {
+    new_ucmd!()
+        .args(&["-n", "r/2/3"])
+        .pipe_in("1\n2\n3\n4\n5")
+        .succeeds()
+        .stdout_only("2\n5");
+}
+
 #[test]
 fn test_line_bytes() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -1321,7 +1406,7 @@ fn test_numeric_suffix() {
 }
 
 #[test]
-fn test_numeric_suffix_alias() {
+fn test_numeric_suffix_inferred() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-n", "4", "--numeric=9", "threebytes.txt"])
         .succeeds()
@@ -1546,17 +1631,19 @@ fn test_effective_suffix_hex_last() {
 #[test]
 fn test_round_robin() {
     let (at, mut ucmd) = at_and_ucmd!();
-
-    let file_read = |f| {
-        let mut s = String::new();
-        at.open(f).read_to_string(&mut s).unwrap();
-        s
-    };
-
     ucmd.args(&["-n", "r/2", "fivelines.txt"]).succeeds();
 
-    assert_eq!(file_read("xaa"), "1\n3\n5\n");
-    assert_eq!(file_read("xab"), "2\n4\n");
+    assert_eq!(at.read("xaa"), "1\n3\n5\n");
+    assert_eq!(at.read("xab"), "2\n4\n");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_round_robin_limited_file_descriptors() {
+    new_ucmd!()
+        .args(&["-n", "r/40", "onehundredlines.txt"])
+        .limit(Resource::NOFILE, 9, 9)
+        .succeeds();
 }
 
 #[test]
@@ -1589,7 +1676,7 @@ fn test_split_invalid_input() {
         .args(&["-n", "0", "file"])
         .fails()
         .no_stdout()
-        .stderr_contains("split: invalid number of chunks: 0");
+        .stderr_contains("split: invalid number of chunks: '0'");
 }
 
 /// Test if there are invalid (non UTF-8) in the arguments - unix
@@ -1648,9 +1735,9 @@ fn test_split_separator_nl_lines() {
         .pipe_in("1\n2\n3\n4\n5\n")
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1\n2\n");
-    assert_eq!(file_read(&at, "xab"), "3\n4\n");
-    assert_eq!(file_read(&at, "xac"), "5\n");
+    assert_eq!(at.read("xaa"), "1\n2\n");
+    assert_eq!(at.read("xab"), "3\n4\n");
+    assert_eq!(at.read("xac"), "5\n");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1661,9 +1748,9 @@ fn test_split_separator_nl_line_bytes() {
         .pipe_in("1\n2\n3\n4\n5\n")
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1\n2\n");
-    assert_eq!(file_read(&at, "xab"), "3\n4\n");
-    assert_eq!(file_read(&at, "xac"), "5\n");
+    assert_eq!(at.read("xaa"), "1\n2\n");
+    assert_eq!(at.read("xab"), "3\n4\n");
+    assert_eq!(at.read("xac"), "5\n");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1673,9 +1760,9 @@ fn test_split_separator_nl_number_l() {
     ucmd.args(&["--number=l/3", "--separator=\n", "fivelines.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1\n2\n");
-    assert_eq!(file_read(&at, "xab"), "3\n4\n");
-    assert_eq!(file_read(&at, "xac"), "5\n");
+    assert_eq!(at.read("xaa"), "1\n2\n");
+    assert_eq!(at.read("xab"), "3\n4\n");
+    assert_eq!(at.read("xac"), "5\n");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1685,9 +1772,9 @@ fn test_split_separator_nl_number_r() {
     ucmd.args(&["--number=r/3", "--separator", "\n", "fivelines.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1\n4\n");
-    assert_eq!(file_read(&at, "xab"), "2\n5\n");
-    assert_eq!(file_read(&at, "xac"), "3\n");
+    assert_eq!(at.read("xaa"), "1\n4\n");
+    assert_eq!(at.read("xab"), "2\n5\n");
+    assert_eq!(at.read("xac"), "3\n");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1697,9 +1784,9 @@ fn test_split_separator_nul_lines() {
     ucmd.args(&["--lines=2", "-t", "\\0", "separator_nul.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1\x002\0");
-    assert_eq!(file_read(&at, "xab"), "3\x004\0");
-    assert_eq!(file_read(&at, "xac"), "5\0");
+    assert_eq!(at.read("xaa"), "1\x002\0");
+    assert_eq!(at.read("xab"), "3\x004\0");
+    assert_eq!(at.read("xac"), "5\0");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1709,9 +1796,9 @@ fn test_split_separator_nul_line_bytes() {
     ucmd.args(&["--line-bytes=4", "-t", "\\0", "separator_nul.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1\x002\0");
-    assert_eq!(file_read(&at, "xab"), "3\x004\0");
-    assert_eq!(file_read(&at, "xac"), "5\0");
+    assert_eq!(at.read("xaa"), "1\x002\0");
+    assert_eq!(at.read("xab"), "3\x004\0");
+    assert_eq!(at.read("xac"), "5\0");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1721,9 +1808,9 @@ fn test_split_separator_nul_number_l() {
     ucmd.args(&["--number=l/3", "--separator=\\0", "separator_nul.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1\x002\0");
-    assert_eq!(file_read(&at, "xab"), "3\x004\0");
-    assert_eq!(file_read(&at, "xac"), "5\0");
+    assert_eq!(at.read("xaa"), "1\x002\0");
+    assert_eq!(at.read("xab"), "3\x004\0");
+    assert_eq!(at.read("xac"), "5\0");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1733,9 +1820,9 @@ fn test_split_separator_nul_number_r() {
     ucmd.args(&["--number=r/3", "--separator=\\0", "separator_nul.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1\x004\0");
-    assert_eq!(file_read(&at, "xab"), "2\x005\0");
-    assert_eq!(file_read(&at, "xac"), "3\0");
+    assert_eq!(at.read("xaa"), "1\x004\0");
+    assert_eq!(at.read("xab"), "2\x005\0");
+    assert_eq!(at.read("xac"), "3\0");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1745,9 +1832,9 @@ fn test_split_separator_semicolon_lines() {
     ucmd.args(&["--lines=2", "-t", ";", "separator_semicolon.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1;2;");
-    assert_eq!(file_read(&at, "xab"), "3;4;");
-    assert_eq!(file_read(&at, "xac"), "5;");
+    assert_eq!(at.read("xaa"), "1;2;");
+    assert_eq!(at.read("xab"), "3;4;");
+    assert_eq!(at.read("xac"), "5;");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1757,9 +1844,9 @@ fn test_split_separator_semicolon_line_bytes() {
     ucmd.args(&["--line-bytes=4", "-t", ";", "separator_semicolon.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1;2;");
-    assert_eq!(file_read(&at, "xab"), "3;4;");
-    assert_eq!(file_read(&at, "xac"), "5;");
+    assert_eq!(at.read("xaa"), "1;2;");
+    assert_eq!(at.read("xab"), "3;4;");
+    assert_eq!(at.read("xac"), "5;");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1769,9 +1856,9 @@ fn test_split_separator_semicolon_number_l() {
     ucmd.args(&["--number=l/3", "--separator=;", "separator_semicolon.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1;2;");
-    assert_eq!(file_read(&at, "xab"), "3;4;");
-    assert_eq!(file_read(&at, "xac"), "5;");
+    assert_eq!(at.read("xaa"), "1;2;");
+    assert_eq!(at.read("xab"), "3;4;");
+    assert_eq!(at.read("xac"), "5;");
     assert!(!at.plus("xad").exists());
 }
 
@@ -1781,9 +1868,9 @@ fn test_split_separator_semicolon_number_r() {
     ucmd.args(&["--number=r/3", "--separator=;", "separator_semicolon.txt"])
         .succeeds();
 
-    assert_eq!(file_read(&at, "xaa"), "1;4;");
-    assert_eq!(file_read(&at, "xab"), "2;5;");
-    assert_eq!(file_read(&at, "xac"), "3;");
+    assert_eq!(at.read("xaa"), "1;4;");
+    assert_eq!(at.read("xab"), "2;5;");
+    assert_eq!(at.read("xac"), "3;");
     assert!(!at.plus("xad").exists());
 }
 
diff --git a/tests/by-util/test_stdbuf.rs b/tests/by-util/test_stdbuf.rs
index 9a67dad9e37..50de4c54696 100644
--- a/tests/by-util/test_stdbuf.rs
+++ b/tests/by-util/test_stdbuf.rs
@@ -65,7 +65,7 @@ fn test_stdbuf_invalid_mode_fails() {
             .args(&[*option, "1024R", "head"])
             .fails()
             .code_is(125)
-            .stderr_only("stdbuf: invalid mode '1024R': Value too large for defined data type\n");
+            .usage_error("invalid mode '1024R': Value too large for defined data type");
         #[cfg(not(target_pointer_width = "128"))]
         new_ucmd!()
             .args(&[*option, "1Y", "head"])
diff --git a/tests/by-util/test_tee.rs b/tests/by-util/test_tee.rs
index 2b3fd2670ab..34076bbf9b1 100644
--- a/tests/by-util/test_tee.rs
+++ b/tests/by-util/test_tee.rs
@@ -3,6 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 use crate::common::util::TestScenario;
+#[cfg(target_os = "linux")]
 use std::fmt::Write;
 
 // tests for basic tee functionality.
diff --git a/tests/by-util/test_test.rs b/tests/by-util/test_test.rs
index 922d854c640..1999634efbc 100644
--- a/tests/by-util/test_test.rs
+++ b/tests/by-util/test_test.rs
@@ -553,7 +553,7 @@ fn test_nonexistent_file_is_not_symlink() {
 }
 
 #[test]
-// FixME: freebsd fails with 'chmod: sticky_file: Inappropriate file type or format'
+// Only the superuser is allowed to set the sticky bit on files on FreeBSD.
 // Windows has no concept of sticky bit
 #[cfg(not(any(windows, target_os = "freebsd")))]
 fn test_file_is_sticky() {
@@ -667,7 +667,7 @@ fn test_nonexistent_file_not_owned_by_euid() {
 }
 
 #[test]
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(not(windows))]
 fn test_file_not_owned_by_euid() {
     new_ucmd!()
         .args(&["-f", "/bin/sh", "-a", "!", "-O", "/bin/sh"])
@@ -675,9 +675,32 @@ fn test_file_not_owned_by_euid() {
 }
 
 #[test]
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(not(windows))]
 fn test_file_owned_by_egid() {
-    new_ucmd!().args(&["-G", "regular_file"]).succeeds();
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    // On some platforms (mostly the BSDs) the test fixture files copied to the
+    // /tmp directory will have a different gid than the current egid (due to
+    // the sticky bit set on the /tmp directory). Fix this before running the
+    // test command.
+    use std::ffi::CString;
+    use std::os::unix::ffi::OsStrExt;
+    use std::os::unix::fs::MetadataExt;
+    use uucore::process::getegid;
+
+    let metadata = at.metadata("regular_file");
+    let file_gid = metadata.gid();
+    let user_gid = getegid();
+
+    if user_gid != file_gid {
+        let file_uid = metadata.uid();
+        let path = CString::new(at.plus("regular_file").as_os_str().as_bytes()).expect("bad path");
+        let r = unsafe { libc::chown(path.as_ptr(), file_uid, user_gid) };
+        assert_ne!(r, -1);
+    }
+
+    scene.ucmd().args(&["-G", "regular_file"]).succeeds();
 }
 
 #[test]
@@ -690,10 +713,19 @@ fn test_nonexistent_file_not_owned_by_egid() {
 }
 
 #[test]
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(not(windows))]
 fn test_file_not_owned_by_egid() {
+    let target_file = if cfg!(target_os = "freebsd") {
+        // The coreutils test runner user has a primary group id of "wheel",
+        // which matches the gid of /bin/sh, so use /sbin/shutdown which has gid
+        // of "operator".
+        "/sbin/shutdown"
+    } else {
+        "/bin/sh"
+    };
+
     new_ucmd!()
-        .args(&["-f", "/bin/sh", "-a", "!", "-G", "/bin/sh"])
+        .args(&["-f", target_file, "-a", "!", "-G", target_file])
         .succeeds();
 }
 
diff --git a/tests/by-util/test_tr.rs b/tests/by-util/test_tr.rs
index 7c475a492ef..01d062cab7b 100644
--- a/tests/by-util/test_tr.rs
+++ b/tests/by-util/test_tr.rs
@@ -29,12 +29,12 @@ fn test_small_set2() {
 }
 
 #[test]
-fn test_unicode() {
+fn test_invalid_unicode() {
     new_ucmd!()
-        .args(&[", ┬─┬", "╯︵┻━┻"])
-        .pipe_in("(,°□°）, ┬─┬")
-        .run()
-        .stdout_is("(╯°□°）╯︵┻━┻");
+        .args(&["-dc", "abc"])
+        .pipe_in([0o200, b'a', b'b', b'c'])
+        .succeeds()
+        .stdout_is("abc");
 }
 
 #[test]
@@ -733,10 +733,11 @@ fn check_against_gnu_tr_tests_w() {
     //  {IN=>"\300\301\377\345\345\350\345"},
     //  {OUT=>"\300\301\377\345"}],
     new_ucmd!()
-        .args(&["-ds", "\u{350}", "\u{345}"])
-        .pipe_in("\u{300}\u{301}\u{377}\u{345}\u{345}\u{350}\u{345}")
+        .arg("-ds")
+        .args(&["\\350", "\\345"])
+        .pipe_in([0o300, 0o301, 0o377, 0o345, 0o345, 0o350, 0o345])
         .succeeds()
-        .stdout_is("\u{300}\u{301}\u{377}\u{345}");
+        .stdout_is_bytes([0o300, 0o301, 0o377, 0o345]);
 }
 
 #[test]
diff --git a/tests/by-util/test_tsort.rs b/tests/by-util/test_tsort.rs
index 18889451629..79195efa211 100644
--- a/tests/by-util/test_tsort.rs
+++ b/tests/by-util/test_tsort.rs
@@ -64,3 +64,12 @@ fn test_multiple_arguments() {
         .fails()
         .stderr_contains("unexpected argument 'invalid_file' found");
 }
+
+#[test]
+fn test_error_on_dir() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("tsort_test_dir");
+    ucmd.arg("tsort_test_dir")
+        .fails()
+        .stderr_contains("tsort: tsort_test_dir: read error: Is a directory");
+}
diff --git a/tests/by-util/test_unexpand.rs b/tests/by-util/test_unexpand.rs
index ddbe3343efa..c1310be01a3 100644
--- a/tests/by-util/test_unexpand.rs
+++ b/tests/by-util/test_unexpand.rs
@@ -2,6 +2,7 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+// spell-checker:ignore contenta
 use crate::common::util::TestScenario;
 
 #[test]
@@ -235,3 +236,34 @@ fn test_tabs_shortcut_with_too_large_size() {
 
     new_ucmd!().arg(arg).fails().stderr_contains(expected_error);
 }
+
+#[test]
+fn test_is_directory() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir_name = "dir";
+    at.mkdir(dir_name);
+
+    ucmd.arg(dir_name)
+        .fails()
+        .stderr_contains(format!("unexpand: {}: Is a directory", dir_name));
+}
+
+#[test]
+fn test_multiple_files() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.write("file", "content");
+    at.write("file1", "a        b");
+
+    ucmd.args(&["file", "file1"])
+        .succeeds()
+        .stdout_is("contenta        b");
+}
+
+#[test]
+fn test_one_nonexisting_file() {
+    new_ucmd!()
+        .arg("asdf.txt")
+        .fails()
+        .stderr_contains("asdf.txt: No such file or directory");
+}
diff --git a/tests/by-util/test_uptime.rs b/tests/by-util/test_uptime.rs
index 3967d025251..89e5567fba4 100644
--- a/tests/by-util/test_uptime.rs
+++ b/tests/by-util/test_uptime.rs
@@ -11,6 +11,7 @@ fn test_invalid_arg() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_uptime() {
     TestScenario::new(util_name!())
         .ucmd()
@@ -22,6 +23,7 @@ fn test_uptime() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_uptime_since() {
     let re = Regex::new(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}").unwrap();
 
diff --git a/tests/by-util/test_users.rs b/tests/by-util/test_users.rs
index 766378a9dca..3d87aa9d068 100644
--- a/tests/by-util/test_users.rs
+++ b/tests/by-util/test_users.rs
@@ -21,11 +21,9 @@ fn test_users_check_name() {
     #[cfg(target_os = "linux")]
     let util_name = util_name!();
     #[cfg(target_vendor = "apple")]
-    let util_name = format!("g{}", util_name!());
+    let util_name = &format!("g{}", util_name!());
 
-    // note: clippy::needless_borrow *false positive*
-    #[allow(clippy::needless_borrow)]
-    let expected = TestScenario::new(&util_name)
+    let expected = TestScenario::new(util_name)
         .cmd(util_name)
         .env("LC_ALL", "C")
         .succeeds()
diff --git a/tests/by-util/test_wc.rs b/tests/by-util/test_wc.rs
index 6417470c57f..c0a4a341319 100644
--- a/tests/by-util/test_wc.rs
+++ b/tests/by-util/test_wc.rs
@@ -243,6 +243,14 @@ fn test_single_only_lines() {
         .stdout_is("18 moby_dick.txt\n");
 }
 
+#[test]
+fn test_single_only_bytes() {
+    new_ucmd!()
+        .args(&["-c", "lorem_ipsum.txt"])
+        .run()
+        .stdout_is("772 lorem_ipsum.txt\n");
+}
+
 #[test]
 fn test_single_all_counts() {
     new_ucmd!()
@@ -419,11 +427,24 @@ fn test_files_from_pseudo_filesystem() {
     use pretty_assertions::assert_ne;
     let result = new_ucmd!().arg("-c").arg("/proc/cpuinfo").succeeds();
     assert_ne!(result.stdout_str(), "0 /proc/cpuinfo\n");
+
+    // the following block fails on Android with a "Permission denied" error
+    #[cfg(target_os = "linux")]
+    {
+        let (at, mut ucmd) = at_and_ucmd!();
+        let result = ucmd.arg("-c").arg("/sys/kernel/profiling").succeeds();
+        let actual = at.read("/sys/kernel/profiling").len();
+        assert_eq!(
+            result.stdout_str(),
+            format!("{} /sys/kernel/profiling\n", actual)
+        );
+    }
 }
 
 #[test]
 fn test_files0_disabled_files_argument() {
-    const MSG: &str = "file operands cannot be combined with --files0-from";
+    const MSG: &str =
+        "extra operand 'lorem_ipsum.txt'\nfile operands cannot be combined with --files0-from";
     new_ucmd!()
         .args(&["--files0-from=files0_list.txt"])
         .arg("lorem_ipsum.txt")
@@ -708,3 +729,16 @@ fn files0_from_dir() {
         .fails()
         .stderr_only(dir_err!("-"));
 }
+
+#[test]
+fn test_args_override() {
+    new_ucmd!()
+        .args(&["-ll", "-l", "alice_in_wonderland.txt"])
+        .run()
+        .stdout_is("5 alice_in_wonderland.txt\n");
+
+    new_ucmd!()
+        .args(&["--total=always", "--total=never", "alice_in_wonderland.txt"])
+        .run()
+        .stdout_is("  5  57 302 alice_in_wonderland.txt\n");
+}
diff --git a/tests/by-util/test_who.rs b/tests/by-util/test_who.rs
index 3bacc38c112..36325fe7c57 100644
--- a/tests/by-util/test_who.rs
+++ b/tests/by-util/test_who.rs
@@ -25,6 +25,7 @@ fn test_count() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_boot() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-b", "--boot", "--b"] {
@@ -65,6 +66,7 @@ fn test_short() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_login() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-l", "--login", "--log"] {
@@ -75,6 +77,7 @@ fn test_login() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_m() {
     let ts = TestScenario::new(util_name!());
     let expected_stdout = unwrap_or_return!(expected_result(&ts, &["-m"])).stdout_move_str();
@@ -83,6 +86,7 @@ fn test_m() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_process() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-p", "--process", "--p"] {
@@ -93,6 +97,7 @@ fn test_process() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_runlevel() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-r", "--runlevel", "--r"] {
@@ -106,6 +111,7 @@ fn test_runlevel() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_time() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-t", "--time", "--t"] {
@@ -141,6 +147,7 @@ fn test_mesg() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_arg1_arg2() {
     let args = ["am", "i"];
     let ts = TestScenario::new(util_name!());
@@ -195,6 +202,7 @@ fn test_lookup() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_dead() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-d", "--dead", "--de"] {
diff --git a/tests/common/util.rs b/tests/common/util.rs
index 6f4e76d4228..9055c238e08 100644
--- a/tests/common/util.rs
+++ b/tests/common/util.rs
@@ -55,9 +55,7 @@ const DEFAULT_ENV: [(&str, &str); 2] = [("LC_ALL", "C"), ("TZ", "UTC")];
 
 /// Test if the program is running under CI
 pub fn is_ci() -> bool {
-    std::env::var("CI")
-        .unwrap_or_else(|_| String::from("false"))
-        .eq_ignore_ascii_case("true")
+    std::env::var("CI").is_ok_and(|s| s.eq_ignore_ascii_case("true"))
 }
 
 /// Read a test scenario fixture, returning its bytes
@@ -758,6 +756,26 @@ pub fn get_root_path() -> &'static str {
     }
 }
 
+/// Compares the extended attributes (xattrs) of two files or directories.
+///
+/// # Returns
+///
+/// `true` if both paths have the same set of extended attributes, `false` otherwise.
+#[cfg(all(unix, not(target_os = "macos")))]
+pub fn compare_xattrs<P: AsRef<std::path::Path>>(path1: P, path2: P) -> bool {
+    let get_sorted_xattrs = |path: P| {
+        xattr::list(path)
+            .map(|attrs| {
+                let mut attrs = attrs.collect::<Vec<_>>();
+                attrs.sort();
+                attrs
+            })
+            .unwrap_or_else(|_| Vec::new())
+    };
+
+    get_sorted_xattrs(path1) == get_sorted_xattrs(path2)
+}
+
 /// Object-oriented path struct that represents and operates on
 /// paths relative to the directory it was constructed for.
 #[derive(Clone)]
@@ -3377,4 +3395,26 @@ mod tests {
         );
         assert!(command.tmpd.is_some());
     }
+
+    #[cfg(all(unix, not(target_os = "macos")))]
+    #[test]
+    fn test_compare_xattrs() {
+        use tempfile::tempdir;
+
+        let temp_dir = tempdir().unwrap();
+        let file_path1 = temp_dir.path().join("test_file1.txt");
+        let file_path2 = temp_dir.path().join("test_file2.txt");
+
+        File::create(&file_path1).unwrap();
+        File::create(&file_path2).unwrap();
+
+        let test_attr = "user.test_attr";
+        let test_value = b"test value";
+        xattr::set(&file_path1, test_attr, test_value).unwrap();
+
+        assert!(!compare_xattrs(&file_path1, &file_path2));
+
+        xattr::set(&file_path2, test_attr, test_value).unwrap();
+        assert!(compare_xattrs(&file_path1, &file_path2));
+    }
 }
diff --git a/tests/fixtures/cksum/length_is_zero.expected b/tests/fixtures/cksum/length_is_zero.expected
new file mode 100644
index 00000000000..97d06eb6fea
--- /dev/null
+++ b/tests/fixtures/cksum/length_is_zero.expected
@@ -0,0 +1,2 @@
+BLAKE2b (lorem_ipsum.txt) = 0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3
+BLAKE2b (alice_in_wonderland.txt) = 91b8b0f0868e905ad18b8ac35e4a1dacd289857b19258ab5d1e071761af758b0134ec152d4f011fe1825ca889c80c2e072ca70eb50548c25fc49a98937515af4
diff --git a/tests/fixtures/cksum/length_larger_than_512.expected b/tests/fixtures/cksum/length_larger_than_512.expected
new file mode 100644
index 00000000000..312b6230e9a
--- /dev/null
+++ b/tests/fixtures/cksum/length_larger_than_512.expected
@@ -0,0 +1,2 @@
+cksum: invalid length: ‘1024’
+cksum: maximum digest length for ‘BLAKE2b’ is 512 bits
diff --git a/tests/fixtures/cksum/raw/blake2b_single_file.expected b/tests/fixtures/cksum/raw/blake2b_single_file.expected
new file mode 100644
index 00000000000..19b3112206d
--- /dev/null
+++ b/tests/fixtures/cksum/raw/blake2b_single_file.expected
@@ -0,0 +1 @@
+�����`�x��
f��W���Et�B��l��W^J�0�aX´��8�����5�B��9m��
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/bsd_single_file.expected b/tests/fixtures/cksum/raw/bsd_single_file.expected
new file mode 100644
index 00000000000..538ab19f728
--- /dev/null
+++ b/tests/fixtures/cksum/raw/bsd_single_file.expected
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/crc_single_file.expected b/tests/fixtures/cksum/raw/crc_single_file.expected
new file mode 100644
index 00000000000..de175b04582
--- /dev/null
+++ b/tests/fixtures/cksum/raw/crc_single_file.expected
@@ -0,0 +1 @@
+�Ph
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/md5_single_file.expected b/tests/fixtures/cksum/raw/md5_single_file.expected
new file mode 100644
index 00000000000..e7b47aebbcb
Binary files /dev/null and b/tests/fixtures/cksum/raw/md5_single_file.expected differ
diff --git a/tests/fixtures/cksum/raw/sha1_single_file.expected b/tests/fixtures/cksum/raw/sha1_single_file.expected
new file mode 100644
index 00000000000..0f634be4749
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha1_single_file.expected
@@ -0,0 +1 @@
+�к�؈:=�m毽(%,��
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha224_single_file.expected b/tests/fixtures/cksum/raw/sha224_single_file.expected
new file mode 100644
index 00000000000..bc3fa6bf18f
Binary files /dev/null and b/tests/fixtures/cksum/raw/sha224_single_file.expected differ
diff --git a/tests/fixtures/cksum/raw/sha256_single_file.expected b/tests/fixtures/cksum/raw/sha256_single_file.expected
new file mode 100644
index 00000000000..b9ce06f39d9
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha256_single_file.expected
@@ -0,0 +1 @@
+�� PP�0�P
g�^�	�SkE���C[�+?
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha384_single_file.expected b/tests/fixtures/cksum/raw/sha384_single_file.expected
new file mode 100644
index 00000000000..4b337f859ed
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha384_single_file.expected
@@ -0,0 +1,3 @@
+K�
+

2�i���J��Mϸ��/g������LZ{WZ3S�
+��H�
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha512_single_file.expected b/tests/fixtures/cksum/raw/sha512_single_file.expected
new file mode 100644
index 00000000000..79f78cf00cb
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha512_single_file.expected
@@ -0,0 +1 @@
+�Td�%V�Վ�sؚ�!�Yyu)���f���������|T,�Bn^Oऊ�Vg�D	k!=���
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sm3_single_file.expected b/tests/fixtures/cksum/raw/sm3_single_file.expected
new file mode 100644
index 00000000000..3506406dc42
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sm3_single_file.expected
@@ -0,0 +1 @@
+m)k�]��(�0���CyM��g@�p��i��
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sysv_single_file.expected b/tests/fixtures/cksum/raw/sysv_single_file.expected
new file mode 100644
index 00000000000..b975da49c01
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sysv_single_file.expected
@@ -0,0 +1 @@
+I
\ No newline at end of file
diff --git a/tests/fixtures/cksum/supported_length.expected b/tests/fixtures/cksum/supported_length.expected
new file mode 100644
index 00000000000..a2edb23e9ee
--- /dev/null
+++ b/tests/fixtures/cksum/supported_length.expected
@@ -0,0 +1,2 @@
+BLAKE2b-16 (lorem_ipsum.txt) = 7e2f
+BLAKE2b-16 (alice_in_wonderland.txt) = a546
diff --git a/tests/fixtures/cksum/unsupported_length.expected b/tests/fixtures/cksum/unsupported_length.expected
new file mode 100644
index 00000000000..c2a05fec7be
--- /dev/null
+++ b/tests/fixtures/cksum/unsupported_length.expected
@@ -0,0 +1,2 @@
+cksum: invalid length: ‘15’
+cksum: length is not a multiple of 8
diff --git a/tests/fixtures/dircolors/internal.expected b/tests/fixtures/dircolors/internal.expected
index 7bc91ef470c..e151973f200 100644
--- a/tests/fixtures/dircolors/internal.expected
+++ b/tests/fixtures/dircolors/internal.expected
@@ -1,8 +1,5 @@
 # Configuration file for dircolors, a utility to help you set the
 # LS_COLORS environment variable used by GNU ls with the --color option.
-# Copyright (C) 1996-2022 Free Software Foundation, Inc.
-# Copying and distribution of this file, with or without modification,
-# are permitted provided the copyright notice and this notice are preserved.
 # The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the
 # slackware version of dircolors) are recognized but ignored.
 # Global config options can be specified before TERM or COLORTERM entries
@@ -46,40 +43,26 @@ TERM xterm*
 # 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
 #NORMAL 00 # no color code at all
 #FILE 00 # regular file: use no color at all
-RESET 0 # reset to "normal" color
-DIR 01;34 # directory
-LINK 01;36 # symbolic link. (If you set this to 'target' instead of a
- # numerical value, the color is as for the file pointed to.)
-MULTIHARDLINK 00 # regular file with more than one link
-FIFO 40;33 # pipe
-SOCK 01;35 # socket
-DOOR 01;35 # door
-BLK 40;33;01 # block device driver
-CHR 40;33;01 # character device driver
-ORPHAN 40;31;01 # symlink to nonexistent file, or non-stat'able file ...
-MISSING 00 # ... and the files they point to
-SETUID 37;41 # file that is setuid (u+s)
-SETGID 30;43 # file that is setgid (g+s)
-CAPABILITY 00 # file with capability (very expensive to lookup)
-STICKY_OTHER_WRITABLE 30;42 # dir that is sticky and other-writable (+t,o+w)
-OTHER_WRITABLE 34;42 # dir that is other-writable (o+w) and not sticky
-STICKY 37;44 # dir with the sticky bit set (+t) and not other-writable
-# This is for files with execute permission:
+RESET 0
+DIR 01;34
+LINK 01;36
+MULTIHARDLINK 00
+FIFO 40;33
+SOCK 01;35
+DOOR 01;35
+BLK 40;33;01
+CHR 40;33;01
+ORPHAN 40;31;01
+MISSING 00
+SETUID 37;41
+SETGID 30;43
+CAPABILITY 00
+STICKY_OTHER_WRITABLE 30;42
+OTHER_WRITABLE 34;42
+STICKY 37;44
 EXEC 01;32
 # List any file extensions like '.gz' or '.tar' that you would like ls
 # to color below. Put the extension, a space, and the color init string.
-# (and any comments you want to add after a '#')
-# If you use DOS-style suffixes, you may want to uncomment the following:
-#.cmd 01;32 # executables (bright green)
-#.exe 01;32
-#.com 01;32
-#.btm 01;32
-#.bat 01;32
-# Or if you want to color scripts even if they do not have the
-# executable bit actually set.
-#.sh 01;32
-#.csh 01;32
- # archives or compressed (bright red)
 .tar 01;31
 .tgz 01;31
 .arc 01;31
@@ -126,7 +109,6 @@ EXEC 01;32
 .swm 01;31
 .dwm 01;31
 .esd 01;31
-# image formats
 .avif 01;35
 .jpg 01;35
 .jpeg 01;35
@@ -176,10 +158,8 @@ EXEC 01;32
 .yuv 01;35
 .cgm 01;35
 .emf 01;35
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
 .ogv 01;35
 .ogx 01;35
-# audio formats
 .aac 00;36
 .au 00;36
 .flac 00;36
@@ -192,12 +172,10 @@ EXEC 01;32
 .ogg 00;36
 .ra 00;36
 .wav 00;36
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
 .oga 00;36
 .opus 00;36
 .spx 00;36
 .xspf 00;36
-# backup files
 *~ 00;90
 *# 00;90
 .bak 00;90
diff --git a/util/analyze-gnu-results.sh b/util/analyze-gnu-results.sh
old mode 100644
new mode 100755
index 045e3b93dfb..76ade340f6b
--- a/util/analyze-gnu-results.sh
+++ b/util/analyze-gnu-results.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # spell-checker:ignore xpass XPASS testsuite
 set -e
 
diff --git a/util/android-commands.sh b/util/android-commands.sh
index 4b504de5649..652e3d992bf 100755
--- a/util/android-commands.sh
+++ b/util/android-commands.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # spell-checker:ignore termux keyevent sdcard binutils unmatch adb's dumpsys logcat pkill nextest logfile
 
 # There are three shells: the host's, adb, and termux. Only adb lets us run
diff --git a/util/build-code_coverage.sh b/util/build-code_coverage.sh
index 4082bc13dcf..bbe4abaab3f 100755
--- a/util/build-code_coverage.sh
+++ b/util/build-code_coverage.sh
@@ -1,15 +1,25 @@
-#!/bin/sh
+#!/usr/bin/env bash
 
 # spell-checker:ignore (abbrevs/acronyms) HTML gcno llvm
 # spell-checker:ignore (jargon) toolchain
 # spell-checker:ignore (rust) Ccodegen Cinline Coverflow Cpanic RUSTC RUSTDOCFLAGS RUSTFLAGS RUSTUP Zpanic
-# spell-checker:ignore (shell) OSID esac
-# spell-checker:ignore (utils) genhtml grcov lcov readlink sccache shellcheck uutils
+# spell-checker:ignore (shell) OSID OSTYPE esac
+# spell-checker:ignore (utils) genhtml grcov lcov greadlink readlink sccache shellcheck uutils
 
 FEATURES_OPTION="--features feat_os_unix"
 
+# Use GNU coreutils for readlink on *BSD
+case "$OSTYPE" in
+    *bsd*)
+        READLINK="greadlink"
+        ;;
+    *)
+        READLINK="readlink"
+        ;;
+esac
+
 ME="${0}"
-ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "${ME}")")"
 REPO_main_dir="$(dirname -- "${ME_dir}")"
 
 cd "${REPO_main_dir}" &&
diff --git a/util/build-gnu.sh b/util/build-gnu.sh
index 7c0691c0697..9fdb3079d9d 100755
--- a/util/build-gnu.sh
+++ b/util/build-gnu.sh
@@ -1,20 +1,48 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # `build-gnu.bash` ~ builds GNU coreutils (from supplied sources)
 #
-# UU_MAKE_PROFILE == 'debug' | 'release' ## build profile for *uutils* build; may be supplied by caller, defaults to 'release'
 
-# spell-checker:ignore (paths) abmon deref discrim eacces getlimits getopt ginstall inacc infloop inotify reflink ; (misc) INT_OFLOW OFLOW baddecode submodules ; (vars/env) SRCDIR vdir rcexp xpart dired
+# spell-checker:ignore (paths) abmon deref discrim eacces getlimits getopt ginstall inacc infloop inotify reflink ; (misc) INT_OFLOW OFLOW baddecode submodules ; (vars/env) SRCDIR vdir rcexp xpart dired OSTYPE ; (utils) gnproc greadlink gsed
 
 set -e
 
+# Use GNU version for make, nproc, readlink and sed on *BSD
+case "$OSTYPE" in
+    *bsd*)
+        MAKE="gmake"
+        NPROC="gnproc"
+        READLINK="greadlink"
+        SED="gsed"
+        ;;
+    *)
+        MAKE="make"
+        NPROC="nproc"
+        READLINK="readlink"
+        SED="sed"
+        ;;
+esac
+
 ME="${0}"
-ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "${ME}")")"
 REPO_main_dir="$(dirname -- "${ME_dir}")"
 
+# Default profile is 'debug'
+UU_MAKE_PROFILE='debug'
+
+for arg in "$@"
+do
+    if [ "$arg" == "--release-build" ]; then
+        UU_MAKE_PROFILE='release'
+        break
+    fi
+done
+
+echo "UU_MAKE_PROFILE='${UU_MAKE_PROFILE}'"
+
 ### * config (from environment with fallback defaults); note: GNU is expected to be a sibling repo directory
 
 path_UUTILS=${path_UUTILS:-${REPO_main_dir}}
-path_GNU="$(readlink -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
+path_GNU="$("${READLINK}" -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
 
 ###
 
@@ -56,9 +84,6 @@ echo "path_GNU='${path_GNU}'"
 
 ###
 
-UU_MAKE_PROFILE=${UU_MAKE_PROFILE:-release}
-echo "UU_MAKE_PROFILE='${UU_MAKE_PROFILE}'"
-
 UU_BUILD_DIR="${path_UUTILS}/target/${UU_MAKE_PROFILE}"
 echo "UU_BUILD_DIR='${UU_BUILD_DIR}'"
 
@@ -69,7 +94,7 @@ if [ "$(uname)" == "Linux" ]; then
     export SELINUX_ENABLED=1
 fi
 
-make PROFILE="${UU_MAKE_PROFILE}"
+"${MAKE}" PROFILE="${UU_MAKE_PROFILE}"
 
 cp "${UU_BUILD_DIR}/install" "${UU_BUILD_DIR}/ginstall" # The GNU tests rename this script before running, to avoid confusion with the make target
 # Create *sum binaries
@@ -93,20 +118,20 @@ for binary in $(./build-aux/gen-lists-of-programs.sh --list-progs); do
 done
 
 if test -f gnu-built; then
-    # Change the PATH in the Makefile to test the uutils coreutils instead of the GNU coreutils
-    sed -i "s/^[[:blank:]]*PATH=.*/  PATH='${UU_BUILD_DIR//\//\\/}\$(PATH_SEPARATOR)'\"\$\$PATH\" \\\/" Makefile
     echo "GNU build already found. Skip"
     echo "'rm -f $(pwd)/gnu-built' to force the build"
     echo "Note: the customization of the tests will still happen"
 else
     ./bootstrap --skip-po
-    ./configure --quiet --disable-gcc-warnings
+    ./configure --quiet --disable-gcc-warnings --disable-nls --disable-dependency-tracking --disable-bold-man-page-references
     #Add timeout to to protect against hangs
     sed -i 's|^"\$@|'"${SYSTEM_TIMEOUT}"' 600 "\$@|' build-aux/test-driver
     # Change the PATH in the Makefile to test the uutils coreutils instead of the GNU coreutils
     sed -i "s/^[[:blank:]]*PATH=.*/  PATH='${UU_BUILD_DIR//\//\\/}\$(PATH_SEPARATOR)'\"\$\$PATH\" \\\/" Makefile
     sed -i 's| tr | /usr/bin/tr |' tests/init.sh
-    make -j "$(nproc)"
+    # Use a better diff
+    sed -i 's|diff -c|diff -u|g' tests/Coreutils.pm
+    "${MAKE}" -j "$("${NPROC}")"
     touch gnu-built
 fi
 
@@ -126,7 +151,7 @@ t_max=36
 #         done
 #     )
 #     for i in ${seq}; do
-#         make "tests/factor/t${i}.sh"
+#         "${MAKE}" "tests/factor/t${i}.sh"
 #     done
 #     cat
 #     sed -i -e 's|^seq |/usr/bin/seq |' -e 's|sha1sum |/usr/bin/sha1sum |' tests/factor/t*.sh
@@ -168,9 +193,18 @@ sed -i 's|chmod |/usr/bin/chmod |' tests/du/inacc-dir.sh tests/tail/tail-n0f.sh
 sed -i 's|sort |/usr/bin/sort |' tests/ls/hyperlink.sh tests/test/test-N.sh
 sed -i 's|split |/usr/bin/split |' tests/factor/factor-parallel.sh
 sed -i 's|id -|/usr/bin/id -|' tests/runcon/runcon-no-reorder.sh
+sed -i "s|grep '^#define HAVE_CAP 1' \$CONFIG_HEADER > /dev/null|true|"  tests/ls/capability.sh
 # tests/ls/abmon-align.sh - https://github.com/uutils/coreutils/issues/3505
 sed -i 's|touch |/usr/bin/touch |' tests/cp/reflink-perm.sh tests/ls/block-size.sh tests/mv/update.sh tests/ls/ls-time.sh tests/stat/stat-nanoseconds.sh tests/misc/time-style.sh tests/test/test-N.sh tests/ls/abmon-align.sh
 sed -i 's|ln -|/usr/bin/ln -|' tests/cp/link-deref.sh
+
+# our messages are better
+sed -i "s|cannot stat 'symlink': Permission denied|not writing through dangling symlink 'symlink'|" tests/cp/fail-perm.sh
+sed -i "s|cp: target directory 'symlink': Permission denied|cp: 'symlink' is not a directory|" tests/cp/fail-perm.sh
+
+# Our message is a bit better
+sed -i "s|cannot create regular file 'no-such/': Not a directory|'no-such/' is not a directory|" tests/mv/trailing-slash.sh
+
 sed -i 's|cp |/usr/bin/cp |' tests/mv/hard-2.sh
 sed -i 's|paste |/usr/bin/paste |' tests/od/od-endian.sh
 sed -i 's|timeout |'"${SYSTEM_TIMEOUT}"' |' tests/tail/follow-stdin.sh
@@ -179,8 +213,8 @@ sed -i 's|timeout |'"${SYSTEM_TIMEOUT}"' |' tests/tail/follow-stdin.sh
 sed -i 's|\(^\s*\)seq \$|\1'"${SYSTEM_TIMEOUT}"' 0.1 seq \$|' tests/seq/seq-precision.sh tests/seq/seq-long-double.sh
 
 # Remove dup of /usr/bin/ and /usr/local/bin/ when executed several times
-grep -rlE '/usr/bin/\s?/usr/bin' init.cfg tests/* | xargs --no-run-if-empty sed -Ei 's|/usr/bin/\s?/usr/bin/|/usr/bin/|g'
-grep -rlE '/usr/local/bin/\s?/usr/local/bin' init.cfg tests/* | xargs --no-run-if-empty sed -Ei 's|/usr/local/bin/\s?/usr/local/bin/|/usr/local/bin/|g'
+grep -rlE '/usr/bin/\s?/usr/bin' init.cfg tests/* | xargs -r sed -Ei 's|/usr/bin/\s?/usr/bin/|/usr/bin/|g'
+grep -rlE '/usr/local/bin/\s?/usr/local/bin' init.cfg tests/* | xargs -r sed -Ei 's|/usr/local/bin/\s?/usr/local/bin/|/usr/local/bin/|g'
 
 #### Adjust tests to make them work with Rust/coreutils
 # in some cases, what we are doing in rust/coreutils is good (or better)
@@ -206,6 +240,9 @@ sed -i -e "s|rm: cannot remove 'rel': Permission denied|rm: cannot remove 'rel':
 # however there's a bug because `---dis` is an alias for: `---disable-inotify`
 sed -i -e "s|---dis ||g" tests/tail/overlay-headers.sh
 
+# Do not FAIL, just do a regular ERROR
+sed -i -e "s|framework_failure_ 'no inotify_add_watch';|fail=1;|" tests/tail/inotify-rotate-resources.sh
+
 test -f "${UU_BUILD_DIR}/getlimits" || cp src/getlimits "${UU_BUILD_DIR}"
 
 # pr produces very long log and this command isn't super interesting
@@ -257,28 +294,44 @@ sed -i -e "s/ginstall: creating directory/install: creating directory/g" tests/i
 
 # GNU doesn't support padding < -LONG_MAX
 # disable this test case
-sed -i -Ez "s/\n([^\n#]*pad-3\.2[^\n]*)\n([^\n]*)\n([^\n]*)/\n# uutils\/numfmt supports padding = LONG_MIN\n#\1\n#\2\n#\3/" tests/misc/numfmt.pl
+# Use GNU sed because option -z is not available on BSD sed
+"${SED}" -i -Ez "s/\n([^\n#]*pad-3\.2[^\n]*)\n([^\n]*)\n([^\n]*)/\n# uutils\/numfmt supports padding = LONG_MIN\n#\1\n#\2\n#\3/" tests/misc/numfmt.pl
 
 # Update the GNU error message to match the one generated by clap
 sed -i -e "s/\$prog: multiple field specifications/error: The argument '--field <FIELDS>' was provided more than once, but cannot be used multiple times\n\nUsage: numfmt [OPTION]... [NUMBER]...\n\n\nFor more information try '--help'/g" tests/misc/numfmt.pl
 sed -i -e "s/Try 'mv --help' for more information/For more information, try '--help'/g" -e "s/mv: missing file operand/error: the following required arguments were not provided:\n  <files>...\n\nUsage: mv [OPTION]... [-T] SOURCE DEST\n       mv [OPTION]... SOURCE... DIRECTORY\n       mv [OPTION]... -t DIRECTORY SOURCE...\n/g" -e "s/mv: missing destination file operand after 'no-file'/error: The argument '<files>...' requires at least 2 values, but only 1 was provided\n\nUsage: mv [OPTION]... [-T] SOURCE DEST\n       mv [OPTION]... SOURCE... DIRECTORY\n       mv [OPTION]... -t DIRECTORY SOURCE...\n/g" tests/mv/diag.sh
 
+# our error message is better
+sed -i -e "s|mv: cannot overwrite 'a/t': Directory not empty|mv: cannot move 'b/t' to 'a/t': Directory not empty|" tests/mv/dir2dir.sh
+
 # GNU doesn't support width > INT_MAX
 # disable these test cases
 sed -i -E "s|^([^#]*2_31.*)$|#\1|g" tests/printf/printf-cov.pl
 
 sed -i -e "s/du: invalid -t argument/du: invalid --threshold argument/" -e "s/du: option requires an argument/error: a value is required for '--threshold <SIZE>' but none was supplied/" -e "/Try 'du --help' for more information./d" tests/du/threshold.sh
 
+# Remove the extra output check
+sed -i -e "s|Try '\$prog --help' for more information.\\\n||" tests/du/files0-from.pl
+sed -i -e "s|when reading file names from stdin, no file name of\"|-: No such file or directory\n\"|" -e "s| '-' allowed\\\n||" tests/du/files0-from.pl
+
 awk 'BEGIN {count=0} /compare exp out2/ && count < 6 {sub(/compare exp out2/, "grep -q \"cannot be used with\" out2"); count++} 1' tests/df/df-output.sh > tests/df/df-output.sh.tmp && mv tests/df/df-output.sh.tmp tests/df/df-output.sh
 
 # with ls --dired, in case of error, we have a slightly different error position
 sed -i -e "s|44 45|48 49|" tests/ls/stat-failed.sh
 
 # small difference in the error message
-sed -i -e "/ls: invalid argument 'XX' for 'time style'/,/Try 'ls --help' for more information\./c\
+# Use GNU sed for /c command
+"${SED}" -i -e "/ls: invalid argument 'XX' for 'time style'/,/Try 'ls --help' for more information\./c\
 ls: invalid --time-style argument 'XX'\nPossible values are: [\"full-iso\", \"long-iso\", \"iso\", \"locale\", \"+FORMAT (e.g., +%H:%M) for a 'date'-style format\"]\n\nFor more information try --help" tests/ls/time-style-diag.sh
 
 # disable two kind of tests:
 # "hostid BEFORE --help" doesn't fail for GNU. we fail. we are probably doing better
 # "hostid BEFORE --help AFTER " same for this
 sed -i -e "s/env \$prog \$BEFORE \$opt > out2/env \$prog \$BEFORE \$opt > out2 #/" -e "s/env \$prog \$BEFORE \$opt AFTER > out3/env \$prog \$BEFORE \$opt AFTER > out3 #/" -e "s/compare exp out2/compare exp out2 #/" -e "s/compare exp out3/compare exp out3 #/" tests/help/help-version-getopt.sh
+
+# Add debug info + we have less syscall then GNU's. Adjust our check.
+# Use GNU sed for /c command
+"${SED}" -i -e '/test \$n_stat1 = \$n_stat2 \\/c\
+echo "n_stat1 = \$n_stat1"\n\
+echo "n_stat2 = \$n_stat2"\n\
+test \$n_stat1 -ge \$n_stat2 \\' tests/ls/stat-free-color.sh
diff --git a/util/deps.nu b/util/deps.nu
new file mode 100644
index 00000000000..368048fff45
--- /dev/null
+++ b/util/deps.nu
@@ -0,0 +1,130 @@
+# This is a script to analyze the dependencies of this project.
+# It is a replacement of / complement to
+#
+#  - cargo tree (used by this script)
+#  - cargo deps
+#  - cargo deny
+#
+# The idea is that by calling all_dep_info, you get a table of all dependencies
+# in Cargo.lock, with a few additional columns based on some other tools.
+# Currently, these tools are
+#
+#  - cargo tree
+#  - the crates.io API
+#
+# The most useful columns in the table are:
+#
+#  - `name`: the name of the crate.
+#  - `version`: the version of the crate.
+#  - `num_versions`: the number of versions in Cargo.lock.
+#  - `normal_dep`: whether the crate is a normal dependency.
+#  - `build_dep`: whether the crate is a build dependency.
+#  - `dev_dep`: whether the crate is a dev dependency.
+#  - `organization`: the GitHub/GitLab organization or user of the repository of the crate.
+#  - `repository_name`: the name of the repository the crate is in. The format is "{owner}/{repo}".
+#  - `dependencies`: direct dependencies of the crate (in the format of Cargo.lock).
+#
+# To use this script, start Nushell (tested only on version 0.82.0), import the library and
+# call `all_dep_info`:
+#
+# ```
+# > nu
+# > use util/deps.nu
+# > let dep = (deps all_dep_info)
+# ```
+#
+# Then you can perform analysis. For example, to group the dependencies by organization:
+#
+# ```
+# > $dep | group-by organization
+# ```
+#
+# Or to find all crates with multiple versions (like cargo deny):
+# ```
+# > $dep | where num_versions > 1
+# ```
+#
+# Ideas to expand this:
+#
+#  - Figure out the whole dependency graph
+#  - Figure out which platforms and which features enable which crates
+#  - Figure out which utils require which crates
+#  - Count the number of crates on different platforms
+#  - Add license information
+#  - Add functions to perform common analyses
+#  - Add info from cargo bloat
+#  - Add MSRV info
+#  - Add up-to-date info (the necessary info is there, it just needs to be derived)
+#  - Check the number of owners/contributors
+#  - Make a webpage to more easily explore the data
+
+# Read the names output by cargo tree
+export def read_tree_names [edge_kind: string, features: list<string>]: any -> table<> {
+    cargo tree --edges $edge_kind --features ($features | str join ",")
+        | parse -r "(?P<name>[a-zA-Z0-9_-]+) v(?P<version>[0-9.]+)"
+}
+
+# Read the crates.io info for a list of crates names
+def read_crates_io [names: list<string>] -> any -> table<> {
+    let total = $names | length
+    $names | enumerate | par-each {|name|
+        print $"($name.index)/($total): ($name.item)"
+        http get $"https://crates.io/api/v1/crates/($name.item)" | get crate
+    }
+}
+
+# Add column for a dependency type
+def add_dep_type [dep_type: string, features: list<string>]: table<> -> table<> {
+    let input_table = $in
+    let table = read_tree_names $dep_type $features
+    $input_table | insert $"($dep_type)_dep" {|outer|
+        $table | any {|inner|
+            $inner.name == $outer.name and $inner.version == $outer.version
+        }
+    }
+}
+
+export def all_dep_info [] {
+    let features = [unix, feat_selinux]
+
+    let lock = open Cargo.lock | from toml | get package
+    
+    $lock
+    # Add number of versions
+    | join ($lock | group-by name | transpose | update column1 { length } | rename name num_versions) name
+    # Add dependency types
+    | add_dep_type normal $features
+    | add_dep_type build $features
+    | add_dep_type dev $features
+    | insert used {|x| $x.normal_dep or $x.build_dep or $x.dev_dep}
+    # Add crates.io info
+    | join (read_crates_io ($lock.name | uniq)) name
+    # Add GH org or user info
+    # The organization is an indicator that crates should be treated as one dependency.
+    # However, there are also unrelated projects by a single organization, so it's not
+    # clear.
+    | insert organization {|x|
+        let repository = $x.repository?
+        if ($repository == null) { "" } else {
+            $repository | url parse | get path | path split | get 1
+        }
+    }
+    # Add repository (truncate everything after repo name)
+    # If we get a url like
+    #  https://github.com/uutils/coreutils/tree/src/uu/ls
+    # we only keep
+    #  uutils/coreutils
+    # The idea is that crates in the same repo definitely belong to the same project and should
+    # be treated as one dependency.
+    | insert repository_name {|x|
+        let repository = $x.repository?
+        if ($repository == null) { '' } else {
+            $repository
+            | url parse
+            | get path
+            | path split
+            | select 1 2
+            | path join
+        }
+    }
+}
diff --git a/util/publish.sh b/util/publish.sh
index 71830f1f915..7207ba7fb91 100755
--- a/util/publish.sh
+++ b/util/publish.sh
@@ -5,6 +5,22 @@ if test "$1" != "--do-it"; then
     ARG="--dry-run --allow-dirty"
 fi
 
+# Function to check if the crate is already published
+is_already_published() {
+    local crate_name=$1
+    local crate_version=$2
+
+    # Use the crates.io API to get the latest version of the crate
+    local latest_published_version
+    latest_published_version=$(curl -s https://crates.io/api/v1/crates/$crate_name | jq -r '.crate.max_version')
+
+    if [ "$latest_published_version" = "$crate_version" ]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
 # Figure out any dependencies between the util via Cargo.toml
 # We store this as edges in a graph with each line:
 # [dependent] [dependency]
@@ -35,12 +51,19 @@ TOTAL_ORDER=$(echo -e $PARTIAL_ORDER | tsort | tac)
 # Remove the ROOT node from the start
 TOTAL_ORDER=${TOTAL_ORDER#ROOT}
 
+CRATE_VERSION=$(grep '^version' Cargo.toml | head -n1 | cut -d '"' -f2)
+
 set -e
 for dir in src/uuhelp_parser/ src/uucore_procs/ src/uucore/ src/uu/stdbuf/src/libstdbuf/; do
     (
         cd "$dir"
+        CRATE_NAME=$(grep '^name =' "Cargo.toml" | head -n1 | cut -d '"' -f2)
         #shellcheck disable=SC2086
-        cargo publish $ARG
+        if ! is_already_published "$CRATE_NAME" "$CRATE_VERSION"; then
+            cargo publish $ARG
+        else
+            echo "Skip: $CRATE_NAME $CRATE_VERSION already published"
+        fi
     )
     sleep 2s
 done
@@ -48,8 +71,13 @@ done
 for p in $TOTAL_ORDER; do
     (
         cd "src/uu/$p"
+        CRATE_NAME=$(grep '^name =' "Cargo.toml" | head -n1 | cut -d '"' -f2)
         #shellcheck disable=SC2086
-        cargo publish $ARG
+        if ! is_already_published "$CRATE_NAME" "$CRATE_VERSION"; then
+            cargo publish $ARG
+        else
+            echo "Skip: $CRATE_NAME $CRATE_VERSION already published"
+        fi
     )
 done
 
diff --git a/util/remaining-gnu-error.py b/util/remaining-gnu-error.py
index 5fd47300ab2..20b3faee7fa 100755
--- a/util/remaining-gnu-error.py
+++ b/util/remaining-gnu-error.py
@@ -11,10 +11,21 @@
 import sys
 
 base = "../gnu/tests/"
-urllib.request.urlretrieve(
-    "https://raw.githubusercontent.com/uutils/coreutils-tracking/main/gnu-full-result.json",
-    "result.json",
-)
+
+# Try to download the file, use local copy if download fails
+result_json = "result.json"
+try:
+    urllib.request.urlretrieve(
+        "https://raw.githubusercontent.com/uutils/coreutils-tracking/main/gnu-full-result.json",
+        result_json
+    )
+except Exception as e:
+    print(f"Failed to download the file: {e}")
+    if not os.path.exists(result_json):
+        print(f"Local file '{result_json}' not found. Exiting.")
+        sys.exit(1)
+    else:
+        print(f"Using local file '{result_json}'.")
 
 types = ("/*/*.sh", "/*/*.pl", "/*/*.xpl")
 
@@ -33,11 +44,22 @@ def show_list(l):
     tests = list(filter(lambda k: "factor" not in k, l))
 
     for f in reversed(tests):
-        print("%s: %s" % (f, os.stat(f).st_size))
+        if contains_require_root(f):
+            print("%s: %s / require_root" % (f, os.stat(f).st_size))
+        else:
+            print("%s: %s" % (f, os.stat(f).st_size))
     print("")
     print("%s tests remaining" % len(tests))
 
 
+def contains_require_root(file_path):
+    try:
+        with open(file_path, "r") as file:
+            return "require_root_" in file.read()
+    except IOError:
+        return False
+
+
 with open("result.json", "r") as json_file:
     data = json.load(json_file)
 
diff --git a/util/run-gnu-test.sh b/util/run-gnu-test.sh
index 1abb476b72b..4148c3f96db 100755
--- a/util/run-gnu-test.sh
+++ b/util/run-gnu-test.sh
@@ -1,13 +1,27 @@
-#!/bin/sh
+#!/usr/bin/env bash
 # `run-gnu-test.bash [TEST]`
 # run GNU test (or all tests if TEST is missing/null)
 
-# spell-checker:ignore (env/vars) GNULIB SRCDIR SUBDIRS ; (utils) shellcheck
+# spell-checker:ignore (env/vars) GNULIB SRCDIR SUBDIRS OSTYPE ; (utils) shellcheck gnproc greadlink
 
 # ref: [How the GNU coreutils are tested](https://www.pixelbeat.org/docs/coreutils-testing.html) @@ <https://archive.is/p2ITW>
 # * note: to run a single test => `make check TESTS=PATH/TO/TEST/SCRIPT SUBDIRS=. VERBOSE=yes`
 
-ME_dir="$(dirname -- "$(readlink -fm -- "$0")")"
+# Use GNU version for make, nproc, readlink on *BSD
+case "$OSTYPE" in
+    *bsd*)
+        MAKE="gmake"
+        NPROC="gnproc"
+        READLINK="greadlink"
+        ;;
+    *)
+        MAKE="make"
+        NPROC="nproc"
+        READLINK="readlink"
+        ;;
+esac
+
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "$0")")"
 REPO_main_dir="$(dirname -- "${ME_dir}")"
 
 echo "ME_dir='${ME_dir}'"
@@ -18,7 +32,7 @@ set -e
 ### * config (from environment with fallback defaults); note: GNU and GNULIB are expected to be sibling repo directories
 
 path_UUTILS=${path_UUTILS:-${REPO_main_dir}}
-path_GNU="$(readlink -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
+path_GNU="$("${READLINK}" -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
 
 echo "path_UUTILS='${path_UUTILS}'"
 echo "path_GNU='${path_GNU}'"
@@ -47,7 +61,7 @@ if test "$1" != "run-root"; then
             fi
         done
         # trim it
-        SPECIFIC_TESTS=$(echo $SPECIFIC_TESTS | xargs)
+        SPECIFIC_TESTS=$(echo "$SPECIFIC_TESTS" | xargs)
         echo "Running specific tests: $SPECIFIC_TESTS"
     fi
 fi
@@ -60,16 +74,16 @@ fi
 if test "$1" != "run-root"; then
     # run the regular tests
     if test $# -ge 1; then
-        timeout -sKILL 4h make -j "$(nproc)" check TESTS="$SPECIFIC_TESTS" SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
+        timeout -sKILL 4h "${MAKE}" -j "$("${NPROC}")" check TESTS="$SPECIFIC_TESTS" SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
     else
-        timeout -sKILL 4h make -j "$(nproc)" check SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
+        timeout -sKILL 4h "${MAKE}" -j "$("${NPROC}")" check SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
     fi
 else
     # in case we would like to run tests requiring root
     if test -z "$1" -o "$1" == "run-root"; then
         if test -n "$CI"; then
             echo "Running check-root to run only root tests"
-            sudo make -j "$(nproc)" check-root SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" TEST_SUITE_LOG="tests/test-suite-root.log" || :
+            sudo "${MAKE}" -j "$("${NPROC}")" check-root SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" TEST_SUITE_LOG="tests/test-suite-root.log" || :
         fi
     fi
 fi
diff --git a/util/show-code_coverage.sh b/util/show-code_coverage.sh
index 3f51462c904..8c6f5e20a67 100755
--- a/util/show-code_coverage.sh
+++ b/util/show-code_coverage.sh
@@ -1,9 +1,19 @@
-#!/bin/sh
+#!/usr/bin/env bash
 
-# spell-checker:ignore (vars) OSID binfmt
+# spell-checker:ignore (vars) OSID OSTYPE binfmt greadlink
+
+# Use GNU coreutils for readlink on *BSD
+case "$OSTYPE" in
+    *bsd*)
+        READLINK="greadlink"
+        ;;
+    *)
+        READLINK="readlink"
+        ;;
+esac
 
 ME="${0}"
-ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "${ME}")")"
 REPO_main_dir="$(dirname -- "${ME_dir}")"
 
 export COVERAGE_REPORT_DIR="${REPO_main_dir}/target/debug/coverage-nix"
diff --git a/util/show-utils.sh b/util/show-utils.sh
index dda01abe2d2..f53a92cc817 100755
--- a/util/show-utils.sh
+++ b/util/show-utils.sh
@@ -1,13 +1,23 @@
-#!/bin/sh
+#!/usr/bin/env bash
 
-# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath  rmdir shuf tsort unexpand
+# spell-checker:ignore (shell) OSTYPE
+# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath grealpath rmdir shuf tsort unexpand
 # spell-checker:ignore (jq) deps startswith
 
+# Use GNU version for realpath on *BSD
+case "$OSTYPE" in
+    *bsd*)
+        REALPATH="grealpath"
+        ;;
+    *)
+        REALPATH="realpath"
+        ;;
+esac
+
 ME="${0}"
 ME_dir="$(dirname -- "${ME}")"
 ME_parent_dir="$(dirname -- "${ME_dir}")"
-# NOTE: On FreeBSD, `-mP` arguments are not available.
-ME_parent_dir_abs="$(realpath -mP -- "${ME_parent_dir}" || realpath -- "${ME_parent_dir}")"
+ME_parent_dir_abs="$("${REALPATH}" -mP -- "${ME_parent_dir}" || "${REALPATH}" -- "${ME_parent_dir}")"
 
 # refs: <https://forge.rust-lang.org/release/platform-support.html> , <https://docs.rs/platforms/0.2.1/platforms/platform/tier1/index.html>
 
diff --git a/util/update-version.sh b/util/update-version.sh
index 244a7a7b29a..7f785f1d7af 100755
--- a/util/update-version.sh
+++ b/util/update-version.sh
@@ -17,8 +17,8 @@
 # 10) Create the release on github https://github.com/uutils/coreutils/releases/new
 # 11) Make sure we have good release notes
 
-FROM="0.0.22"
-TO="0.0.23"
+FROM="0.0.23"
+TO="0.0.24"
 
 PROGS=$(ls -1d src/uu/*/Cargo.toml src/uu/stdbuf/src/libstdbuf/Cargo.toml src/uucore/Cargo.toml Cargo.toml)